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


Quellcode-Bibliothek convex_functions.prf

  Sprache: Lisp
 

(convex_functions
 (composition_of_convex 0
  (composition_of_convex-1 nil 3465141264
   ("" (skeep)
    (("" (expand "convex?")
      (("" (skeep)
        (("" (expand "o")
          (("" (inst -2 "x" "y" "t")
            (("" (assert)
              ((""
                (inst - "f(t * x - t * y + y)"
                 "f(y) - t * f(y) + t * f(x)")
                (("" (assert)
                  (("" (inst - "f(x)" "f(y)" "t")
                    (("" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions nil)
    (O const-decl "T3" function_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields 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))
   nil))
 (max_of_convex 0
  (max_of_convex-1 nil 3462698433
   ("" (skeep)
    (("" (expand "convex?")
      (("" (skeep)
        (("" (inst?)
          (("" (inst?)
            (("" (assert)
              (("" (hide -3)
                (("" (hide -3)
                  ((""
                    (case "f(t * x - t * y + y) >= g(t * x - t * y + y) or f(t * x - t * y + y) < g(t * x - t * y + y)")
                    (("1" (case "f(y) >= g(y) or f(y) < g(y)")
                      (("1" (case "f(x) >= g(x) or f(x) < g(x)")
                        (("1" (prop)
                          (("1" (expand "max") (("1" (assertnil nil))
                            nil)
                           ("2" (expand "max")
                            (("2" (assert)
                              (("2"
                                (mult-by -2 "(1-t)")
                                (("2"
                                  (mult-by -3 "t")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (expand "max")
                            (("3" (assert)
                              (("3"
                                (mult-by -2 "(1-t)")
                                (("3"
                                  (mult-by -3 "t")
                                  (("3" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("4" (expand "max")
                            (("4" (assert)
                              (("4"
                                (mult-by -2 "(1-t)")
                                (("4"
                                  (mult-by -3 "t")
                                  (("4" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("5" (expand "max")
                            (("5" (assert)
                              (("5"
                                (mult-by -2 "(1-t)")
                                (("5"
                                  (mult-by -3 "t")
                                  (("5" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("6" (expand "max")
                            (("6" (assert)
                              (("6"
                                (mult-by -2 "(1-t)")
                                (("6"
                                  (mult-by -3 "t")
                                  (("6" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("7" (expand "max")
                            (("7" (assert)
                              (("7"
                                (mult-by -2 "(1-t)")
                                (("7"
                                  (mult-by -3 "t")
                                  (("7" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("8" (expand "max") (("8" (assertnil nil))
                            nil))
                          nil)
                         ("2" (mult-by -3 "t")
                          (("2" (hide-all-but 1)
                            (("2" (grind) nil nil)) nil))
                          nil))
                        nil)
                       ("2" (hide-all-but 1) (("2" (grind) nil nil))
                        nil))
                      nil)
                     ("2" (hide-all-but 1) (("2" (grind) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions 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)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (< const-decl "bool" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   shostak))
 (sum_of_convex 0
  (sum_of_convex-1 nil 3465141970
   ("" (skeep)
    (("" (expand "convex?")
      (("" (skeep)
        (("" (inst - "x" "y" "t")
          (("" (inst - "x" "y" "t")
            (("" (assert)
              (("" (expand "+") (("" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions 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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (+ const-decl "[T -> real]" real_fun_ops nil))
   shostak))
 (scal_convex 0
  (scal_convex-1 nil 3465142317
   ("" (skeep)
    (("" (expand "convex?")
      (("" (skeep)
        (("" (inst - "x" "y" "t")
          (("" (expand "*")
            (("" (assert)
              (("" (factor 1)
                (("" (mult-by -1 "aaa") (("" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions 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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (* const-decl "[T -> real]" real_fun_ops nil))
   shostak))
 (convex_function_right_lt_TCC1 0
  (convex_function_right_lt_TCC1-1 nil 3465305677
   ("" (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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (convex? const-decl "bool" convex_functions nil)
    (/= const-decl "boolean" notequal nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (convex_function_right_lt 0
  (convex_function_right_lt-3 nil 3465305900
   ("" (skeep)
    (("" (name "tt" "(C-A)/(B-A)")
      (("1" (label "ttname" -1)
        (("1" (case "1-tt = (B-C)/(B-A)")
          (("1" (label "ottname" -1)
            (("1" (expand "convex?")
              (("1" (inst - "B" "A" "tt")
                (("1" (case "A + tt * B - tt * A = C")
                  (("1" (replace -1)
                    (("1" (assert)
                      (("1" (split)
                        (("1"
                          (case-replace
                           "(B - C) / (C - A) = (1-tt)/tt")
                          (("1"
                            (case-replace "(B - A) / (C - A) = 1/tt")
                            (("1" (field 1)
                              (("1"
                                (replace "ttname" + rl)
                                (("1"
                                  (cross-mult 1)
                                  (("1" (assertnil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (cross-mult 1)
                              (("2" (assertnil nil)) nil))
                            nil)
                           ("2" (cross-mult 1)
                            (("2" (field 1) nil nil)) nil))
                          nil)
                         ("2" (replace "ttname" + rl)
                          (("2" (cross-mult 1) (("2" (assertnil nil))
                            nil))
                          nil)
                         ("3" (replace "ttname" + rl)
                          (("3" (cross-mult 1) (("3" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (replace "ttname" + rl)
                    (("2" (field 1) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (replace "ttname" + rl) (("2" (field 1) nil nil)) nil))
          nil))
        nil)
       ("2" (assertnil nil))
      nil))
    nil)
   ((real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals 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)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (div_cancel3 formula-decl nil real_props nil)
    (div_cancel4 formula-decl nil real_props nil)
    (times_div2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (> const-decl "bool" reals nil)
    (both_sides_times_pos_ge1 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (FDX_65 skolem-const-decl "real" convex_functions nil)
    (>= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (both_sides_times_neg_ge1 formula-decl nil real_props nil)
    (nonpos_real nonempty-type-eq-decl nil real_types nil)
    (negreal nonempty-type-eq-decl nil real_types nil)
    (< const-decl "bool" reals nil) (<= const-decl "bool" reals nil)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (both_sides_times1 formula-decl nil real_props nil))
   nil)
  (convex_function_right_lt-2 nil 3465305846
   ("" (skeep)
    (("" (name "tt" "(C-A)/(B-A)")
      (("1" (label "ttname" -1)
        (("1" (case "1-tt = (B-C)/(B-A)")
          (("1" (label "ottname" -1)
            (("1" (expand "convex?")
              (("1" (inst - "B" "A" "tt")
                (("1" (case "A + tt * B - tt * A = C")
                  (("1" (replace -1)
                    (("1" (assert)
                      (("1" (splitt)
                        (("1"
                          (case-replace
                           "(B - C) / (C - A) = (1-tt)/tt")
                          (("1"
                            (case-replace "(B - A) / (C - A) = 1/tt")
                            (("1" (field 1)
                              (("1"
                                (replace "ttname" + rl)
                                (("1"
                                  (cross-mult 1)
                                  (("1" (assertnil)))))))
                             ("2" (cross-mult 1)
                              (("2" (assertnil)))))
                           ("2" (cross-mult 1) (("2" (field 1) nil)))))
                         ("2" (replace "ttname" + rl)
                          (("2" (cross-mult 1) (("2" (assertnil)))))
                         ("3" (replace "ttname" + rl)
                          (("3" (cross-mult 1)
                            (("3" (assertnil)))))))))))
                   ("2" (replace "ttname" + rl)
                    (("2" (field 1) nil)))))))))))
           ("2" (replace "ttname" + rl) (("2" (field 1) nil)))))))
       ("2" (assertnil))))
    nil)
   nil nil)
  (convex_function_right_lt-1 nil 3465305687
   ("" (skeep)
    (("" (name "t" "(C-A)/(B-A)")
      (("1" (label "tname" -1)
        (("1" (case "1-t = (B-C)/(B-A)")
          (("1" (label "otname" -1)
            (("1" (expand "convex?")
              (("1" (inst - "B" "A" "t")
                (("1" (case "A + t * B - t * A = C")
                  (("1" (replace -1)
                    (("1" (assert)
                      (("1" (split)
                        (("1"
                          (case-replace "(B - C) / (C - A) = (1-t)/t")
                          (("1"
                            (case-replace "(B - A) / (C - A) = 1/t")
                            (("1" (field 1)
                              (("1"
                                (replace "tname" + rl)
                                (("1"
                                  (cross-mult 1)
                                  (("1" (assertnil)))))))
                             ("2" (cross-mult 1)
                              (("2" (assertnil)))))
                           ("2" (cross-mult 1) (("2" (field 1) nil)))))
                         ("2" (replace "tname" + rl)
                          (("2" (cross-mult 1) (("2" (assertnil)))))
                         ("3" (replace "tname" + rl)
                          (("3" (cross-mult 1)
                            (("3" (assertnil)))))))))))
                   ("2" (replace "tname" + rl)
                    (("2" (field 1) nil)))))))))))
           ("2" (replace "tname" + rl) (("2" (field 1) nil)))))))
       ("2" (assertnil))))
    nil)
   nil nil))
 (convex_function_left_lt_TCC1 0
  (convex_function_left_lt_TCC1-1 nil 3465305984
   ("" (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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (convex? const-decl "bool" convex_functions nil)
    (/= const-decl "boolean" notequal nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (convex_function_left_lt 0
  (convex_function_left_lt-1 nil 3465305985
   ("" (lemma "convex_function_right_lt")
    (("" (skeep)
      (("" (inst - "A" "B" "C" "f")
        (("" (assert) (("" (field -1) (("" (field 1) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (TRUE const-decl "bool" booleans nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (bijective? const-decl "bool" functions nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (>= const-decl "bool" reals nil)
    (FDX_69 skolem-const-decl "real" convex_functions nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (div_mult_pos_ge2 formula-decl nil real_props nil)
    (div_distributes_minus formula-decl nil real_props nil)
    (times_div2 formula-decl nil real_props nil)
    (> const-decl "bool" reals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers 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)
    (convex_function_right_lt formula-decl nil convex_functions nil))
   shostak))
 (between_point_is_wtd_av 0
  (between_point_is_wtd_av-1 nil 3462871251
   ("" (skeep)
    (("" (case "x = y")
      (("1" (inst + 0) (("1" (assertnil nil)) nil)
       ("2" (inst + "(y-z)/(y-x)")
        (("1" (prop)
          (("1" (cross-mult 1) (("1" (assertnil nil)) nil)
           ("2" (cross-mult 1) (("2" (assertnil nil)) nil)
           ("3" (mult-by 1 "(y-x)") (("3" (field) nil nil)) nil))
          nil)
         ("2" (assertnil nil))
        nil))
      nil))
    nil)
   ((real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers 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_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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (y skolem-const-decl "real" convex_functions nil)
    (x skolem-const-decl "real" convex_functions nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil))
   shostak))
 (between_point_is_wtd_av2 0
  (between_point_is_wtd_av2-1 nil 3462897482
   ("" (skeep)
    (("" (lemma "between_point_is_wtd_av")
      (("" (inst - "x" "y" "z")
        (("" (assert)
          (("" (skosimp*)
            (("" (inst + "(1-t!1)") (("" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((between_point_is_wtd_av formula-decl nil convex_functions nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real_plus_real_is_real application-judgement "real" 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)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (convex_const_on_connected_min 0
  (convex_const_on_connected_min-1 nil 3462807489
   ("" (skosimp*)
    (("" (case "w!1 >= y!1")
      (("1" (expand "convex?")
        (("1" (name "ttt" "(y!1-x!1)/(w!1-x!1)")
          (("1" (label "tname" -1)
            (("1" (inst - "w!1" "x!1" "ttt")
              (("1" (prop)
                (("1" (case "x!1 + ttt * w!1 - ttt * x!1 = y!1")
                  (("1" (replace -1)
                    (("1" (label "yname" -1)
                      (("1" (inst - "y!1")
                        (("1" (assert)
                          (("1" (replace -6 - rl)
                            (("1"
                              (both-sides "-" "f!1(x!1)+ttt*f!1(x!1)"
                               -2)
                              (("1"
                                (assert)
                                (("1"
                                  (cancel-by -2 "ttt")
                                  (("1"
                                    (replace "tname" + rl)
                                    (("1"
                                      (cross-mult 1)
                                      (("1" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (replace "tname" + rl)
                    (("2" (hide-all-but 1)
                      (("2" (mult-by 1 "(w!1 - x!1)")
                        (("2" (assert)
                          (("2" (grind) (("2" (field 1) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (replace "tname" + rl)
                  (("2" (cross-mult 1) (("2" (assertnil nil)) nil))
                  nil)
                 ("3" (replace "tname" + rl)
                  (("3" (cross-mult 1) (("3" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil)
       ("2" (case "w!1 < x!1")
        (("1" (expand "convex?")
          (("1" (name "ttt" "(x!1-w!1)/(y!1-w!1)")
            (("1" (label "tname" -1)
              (("1" (inst - "y!1" "w!1" "ttt")
                (("1" (prop)
                  (("1" (case "w!1 + ttt * y!1 - ttt * w!1 = x!1")
                    (("1" (replace -1)
                      (("1" (label "xname" -1)
                        (("1" (inst - "y!1")
                          (("1" (assert)
                            (("1" (replace -6 - rl)
                              (("1"
                                (both-sides "-" "ttt*f!1(x!1)" -2)
                                (("1"
                                  (assert)
                                  (("1"
                                    (factor -2)
                                    (("1"
                                      (name "GEE" "(1-ttt)")
                                      (("1"
                                        (replace -1)
                                        (("1"
                                          (div-by -3 "GEE")
                                          (("1"
                                            (case "ttt < 1")
                                            (("1" (assertnil nil)
                                             ("2"
                                              (replace "tname" + rl)
                                              (("2"
                                                (cross-mult 1)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (replace "tname" 1 rl)
                      (("2" (mult-by 1 "(y!1 - w!1)")
                        (("2" (field 1) nil nil)) nil))
                      nil))
                    nil)
                   ("2" (replace "tname" + rl)
                    (("2" (cross-mult 1) (("2" (assertnil nil)) nil))
                    nil)
                   ("3" (replace "tname" + rl)
                    (("3" (cross-mult 1) (("3" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil)
         ("2" (inst - "w!1") (("2" (assertnil nil)) nil))
        nil))
      nil))
    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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields 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 "[numfield, numfield -> numfield]" number_fields nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (w!1 skolem-const-decl "real" convex_functions nil)
    (x!1 skolem-const-decl "real" convex_functions nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (<= const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (both_sides_minus_le1 formula-decl nil real_props nil)
    (both_sides_plus_le2 formula-decl nil real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (> const-decl "bool" reals nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (CBD_77 skolem-const-decl "real" convex_functions nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (minus_even_is_even application-judgement "even_int" integers nil)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (zero_times1 formula-decl nil real_props nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (nonpos_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_neg_le1_imp formula-decl nil extra_real_props
     nil)
    (div_mult_neg_le1 formula-decl nil real_props nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (neg_one_times formula-decl nil extra_tegies nil)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (convex? const-decl "bool" convex_functions nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (GEE skolem-const-decl "real" convex_functions nil)
    (times_div_cancel2 formula-decl nil extra_real_props nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (y!1 skolem-const-decl "real" convex_functions nil)
    (< const-decl "bool" reals nil))
   shostak))
 (convex_min_is_connected 0
  (convex_min_is_connected-1 nil 3462871047
   ("" (skeep)
    (("" (skeep)
      (("" (lemma "between_point_is_wtd_av")
        (("" (inst - "x" "y" "w")
          (("" (assert)
            (("" (skosimp*)
              (("" (expand "convex?")
                (("" (inst - "x" "y" "t!1")
                  (("" (assert)
                    (("" (replace -3 - rl)
                      (("" (inst - "w")
                        ((""
                          (case-replace
                           "f(y) - t!1*f(y) = (1-t!1)*f(y)")
                          (("1" (grind) nil nil) ("2" (grind) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (minus_odd_is_odd application-judgement "odd_int" 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)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (convex? const-decl "bool" convex_functions 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)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (between_point_is_wtd_av formula-decl nil convex_functions nil))
   shostak))
 (loc_convex_min_is_connected 0
  (loc_convex_min_is_connected-1 nil 3462873854
   ("" (skeep)
    (("" (skeep)
      (("" (lemma "between_point_is_wtd_av")
        (("" (inst - "x" "y" "w")
          (("" (assert)
            (("" (skosimp*)
              (("" (expand "convex?")
                (("" (inst - "x" "y" "t!1")
                  (("" (assert)
                    (("" (replace -3 - rl)
                      (("" (inst - "w") (("" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (convex? const-decl "bool" convex_functions nil)
    (real_plus_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)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (between_point_is_wtd_av formula-decl nil convex_functions nil))
   shostak))
 (convex_btw_pt_left_lt 0
  (convex_btw_pt_left_lt-1 nil 3465122240
   ("" (skeep)
    (("" (label "convexf" -1)
      (("" (label "Ax" -2)
        (("" (label "Bx" -3)
          (("" (label "fac" -4)
            (("" (label "fbc" -5)
              (("" (label "fxc" 1)
                (("" (lemma "between_point_is_wtd_av2")
                  (("" (label "bpwa" -1)
                    (("" (inst - "A" "B" "x")
                      (("" (assert)
                        (("" (skosimp*)
                          (("" (expand "convex?")
                            (("" (inst - "B" "A" "t!1")
                              ((""
                                (assert)
                                ((""
                                  (copy "fac")
                                  ((""
                                    (mult-by -1 "1-t!1")
                                    ((""
                                      (copy "fbc")
                                      ((""
                                        (mult-by -1 "t!1")
                                        ((""
                                          (add-formulas -1 -2)
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((between_point_is_wtd_av2 formula-decl nil convex_functions 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)
    (< const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions 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_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (convex_btw_pt_right_lt 0
  (convex_btw_pt_right_lt-1 nil 3465122644
   ("" (skeep)
    (("" (label "convexf" -1)
      (("" (label "Ax" -2)
        (("" (label "Bx" -3)
          (("" (label "fac" -4)
            (("" (label "fbc" -5)
              (("" (label "fxc" 1)
                (("" (lemma "between_point_is_wtd_av2")
                  (("" (label "bpwa" -1)
                    (("" (inst - "A" "B" "x")
                      (("" (assert)
                        (("" (skosimp*)
                          (("" (expand "convex?")
                            (("" (inst - "B" "A" "t!1")
                              ((""
                                (assert)
                                ((""
                                  (copy "fac")
                                  ((""
                                    (mult-by -1 "1-t!1")
                                    ((""
                                      (copy "fbc")
                                      ((""
                                        (mult-by -1 "t!1")
                                        ((""
                                          (add-formulas -1 -2)
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((between_point_is_wtd_av2 formula-decl nil convex_functions 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)
    (< const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (convex_wtd_av_lt 0
  (convex_wtd_av_lt-1 nil 3466357784
   ("" (skeep)
    (("" (skeep)
      (("" (expand "convex?")
        (("" (inst - "x" "y" "t")
          (("" (assert)
            (("" (mult-by -2 "t")
              (("" (mult-by -3 "1-t")
                (("" (add-formulas -2 -3) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (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_minus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil))
 (convex_increasing 0
  (convex_increasing-1 nil 3487678404
   ("" (skeep)
    (("" (lemma "convex_btw_pt_left_lt")
      (("" (inst - "x" "w" "f(w) + (f(v)-f(w))/2" "f" "v")
        (("" (assert)
          (("" (split)
            (("1" (case "x = v")
              (("1" (replace -1) (("1" (inst - "w"nil nil)) nil)
               ("2" (assertnil nil))
              nil)
             ("2" (inst - "w") (("2" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((convex_btw_pt_left_lt formula-decl nil convex_functions nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_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)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (numfield nonempty-type-eq-decl nil number_fields 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_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (convex_decreasing 0
  (convex_decreasing-1 nil 3487678783
   ("" (skeep)
    (("" (lemma "convex_btw_pt_left_lt")
      (("" (inst - "w" "x" "(f(v)-f(w))/2 + f(w)" "f" "v")
        (("" (assert) (("" (inst - "w") (("" (assertnil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((convex_btw_pt_left_lt formula-decl nil convex_functions nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props 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)
    (numfield nonempty-type-eq-decl nil number_fields 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_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (strictly_convex_implies_convex 0
  (strictly_convex_implies_convex-1 nil 3466438530
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (expand "convex?")
        (("" (skeep)
          (("" (case "t = 0")
            (("1" (replace -1) (("1" (assertnil nil)) nil)
             ("2" (case "t = 1")
              (("1" (replace -1) (("1" (assertnil nil)) nil)
               ("2" (inst - "x" "y" "t") (("2" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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_minus_real_is_real application-judgement "real" reals nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (convex? const-decl "bool" convex_functions nil))
   shostak))
 (strictly_convex_unique_min 0
  (strictly_convex_unique_min-1 nil 3462701259
   ("" (skosimp*)
    (("" (expand "strictly_convex?")
      (("" (inst - "x!1" "y!1" "1/2")
        (("" (assert)
          (("" (inst - "1 / 2 * x!1 - 1 / 2 * y!1 + y!1")
            (("" (grind) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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_minus_real_is_real application-judgement "real" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil))
   shostak))
 (strictly_conv_uniq_intv_min 0
  (strictly_conv_uniq_intv_min-1 nil 3462701814
   ("" (skosimp*)
    (("" (expand "strictly_convex?")
      (("" (prop)
        (("" (inst - "x!1" "y!1" "1/2")
          (("" (assert)
            (("" (inst - "1 / 2 * x!1 - 1 / 2 * y!1 + y!1")
              (("" (assert) (("" (hide -1) (("" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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_minus_real_is_real application-judgement "real" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil))
   shostak))
 (composition_of_strictly_convex 0
  (composition_of_strictly_convex-1 nil 3465141383
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (expand "convex?")
        (("" (skeep)
          (("" (expand "o")
            (("" (inst -2 "x" "y" "t")
              (("" (assert)
                ((""
                  (inst - "f(t * x - t * y + y)"
                   "f(y) - t * f(y) + t * f(x)")
                  (("" (assert)
                    (("" (inst - "f(x)" "f(y)" "t")
                      (("" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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)
    (* const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (O const-decl "T3" function_props nil)
    (convex? const-decl "bool" convex_functions nil))
   nil))
 (max_of_strictly_convex 0
  (max_of_strictly_convex-1 nil 3462703577
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (skeep)
        (("" (inst?)
          (("" (inst?)
            (("" (assert)
              (("" (hide -3)
                (("" (hide -3)
                  ((""
                    (case "f(t * x - t * y + y) >= g(t * x - t * y + y) or f(t * x - t * y + y) < g(t * x - t * y + y)")
                    (("1" (case "f(y) >= g(y) or f(y) < g(y)")
                      (("1" (case "f(x) >= g(x) or f(x) < g(x)")
                        (("1" (prop)
                          (("1" (expand "max") (("1" (assertnil nil))
                            nil)
                           ("2" (expand "max")
                            (("2" (assert)
                              (("2"
                                (mult-by -2 "(1-t)")
                                (("2"
                                  (mult-by -3 "t")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (expand "max")
                            (("3" (assert)
                              (("3"
                                (mult-by -2 "(1-t)")
                                (("3"
                                  (mult-by -3 "t")
                                  (("3" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("4" (expand "max")
                            (("4" (assert)
                              (("4"
                                (mult-by -2 "(1-t)")
                                (("4"
                                  (mult-by -3 "t")
                                  (("4" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("5" (expand "max")
                            (("5" (assert)
                              (("5"
                                (mult-by -2 "(1-t)")
                                (("5"
                                  (mult-by -3 "t")
                                  (("5" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("6" (expand "max")
                            (("6" (assert)
                              (("6"
                                (mult-by -2 "(1-t)")
                                (("6"
                                  (mult-by -3 "t")
                                  (("6" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("7" (expand "max")
                            (("7" (assert)
                              (("7"
                                (mult-by -2 "(1-t)")
                                (("7"
                                  (mult-by -3 "t")
                                  (("7" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("8" (expand "max") (("8" (assertnil nil))
                            nil))
                          nil)
                         ("2" (mult-by -3 "t")
                          (("2" (hide-all-but 1)
                            (("2" (grind) nil nil)) nil))
                          nil))
                        nil)
                       ("2" (hide-all-but 1) (("2" (grind) nil nil))
                        nil))
                      nil)
                     ("2" (hide-all-but 1) (("2" (grind) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (< const-decl "bool" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil))
 (sum_of_strictly_convex 0
  (sum_of_strictly_convex-1 nil 3465142133
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (skeep)
        (("" (inst - "x" "y" "t")
          (("" (inst - "x" "y" "t")
            (("" (expand "+") (("" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (+ const-decl "[T -> real]" real_fun_ops nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (scal_strictly_convex 0
  (scal_strictly_convex-1 nil 3465142513
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (skeep)
        (("" (inst - "x" "y" "t")
          (("" (expand "*")
            (("" (assert)
              (("" (mult-by -1 "a") (("" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (* const-decl "[T -> real]" real_fun_ops nil))
   nil))
 (strictly_convex_btw_pt_lt 0
  (strictly_convex_btw_pt_lt-1 nil 3465122828
   ("" (skeep)
    (("" (label "convexf" -1)
      (("" (label "Ax" -2)
        (("" (label "Bx" -3)
          (("" (label "fac" -4)
            (("" (label "fbc" -5)
              (("" (label "fxc" 1)
                (("" (lemma "between_point_is_wtd_av2")
                  (("" (label "bpwa" -1)
                    (("" (inst - "A" "B" "x")
                      (("" (assert)
                        (("" (skosimp*)
                          (("" (expand "strictly_convex?")
                            (("" (inst - "B" "A" "t!1")
                              ((""
                                (assert)
                                ((""
                                  (copy "fac")
                                  ((""
                                    (mult-by -1 "1-t!1")
                                    ((""
                                      (copy "fbc")
                                      ((""
                                        (mult-by -1 "t!1")
                                        ((""
                                          (add-formulas -1 -2)
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((between_point_is_wtd_av2 formula-decl nil convex_functions 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)
    (<= const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions 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_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (quad_convex 0
  (quad_convex-3 nil 3462806957
   ("" (skeep)
    (("" (expand "convex?")
      (("" (skeep)
        (("" (lemma "complete_square")
          (("" (copy -1)
            (("" (copy -1)
              (("" (inst - "aaa" "b" "c" "y + t * x - t * y")
                (("1" (inst - "aaa" "b" "c" "y")
                  (("1" (inst - "aaa" "b" "c" "x")
                    (("1" (replace -1)
                      (("1" (hide -1)
                        (("1" (replace -1)
                          (("1" (hide -1)
                            (("1" (replace -1)
                              (("1"
                                (hide -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (both-sides
                                     "-"
                                     "(4 * (aaa * c) - sq(b)) / (4 * aaa)"
                                     1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case "aaa = 0")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (cancel-by 2 "aaa")
                                          (("2"
                                            (name "W" "b/(2 * aaa)")
                                            (("2"
                                              (label "wname" -1)
                                              (("2"
                                                (replace "wname")
                                                (("2"
                                                  (hide "wname")
                                                  (("2"
                                                    (name "Qx" "W + x")
                                                    (("2"
                                                      (label
                                                       "qxname"
                                                       -1)
                                                      (("2"
                                                        (name
                                                         "Qy"
                                                         "W + y")
                                                        (("2"
                                                          (label
                                                           "qyname"
                                                           -1)
                                                          (("2"
                                                            (case
                                                             "x = Qx - W and y = Qy - W")
                                                            (("1"
                                                              (prop)
                                                              (("1"
                                                                (label
                                                                 "xQx"
                                                                 -1)
                                                                (("1"
                                                                  (label
                                                                   "yQy"
                                                                   -2)
                                                                  (("1"
                                                                    (replace
                                                                     "xQx")
                                                                    (("1"
                                                                      (replace
                                                                       "yQy")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (hide
                                                                           ("xQx"
                                                                            "yQy"
                                                                            "qyname"
                                                                            "qxname"))
                                                                          (("1"
                                                                            (case
                                                                             "sq(Qx - Qy) > 0")
                                                                            (("1"
                                                                              (expand
                                                                               "sq"
                                                                               -)
                                                                              (("1"
                                                                                (both-sides
                                                                                 "+"
                                                                                 "2*Qx*Qy"
                                                                                 -1)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (mult-by
                                                                                       -1
                                                                                       "t*(1-t)")
                                                                                      (("1"
                                                                                        (grind)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide-all-but
                                                                                         (-3
                                                                                          -4
                                                                                          1))
                                                                                        (("2"
                                                                                          (lemma
                                                                                           "lt_times_lt_pos1")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "t"
                                                                                             "t"
                                                                                             "1"
                                                                                             "t")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               (1
                                                                                4))
                                                                              (("2"
                                                                                (lemma
                                                                                 "pos_times_gt")
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "Qx-Qy"
                                                                                   "Qx-Qy")
                                                                                  (("2"
                                                                                    (grind)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide-all-but (1 2))
                      (("2" (expand "quadratic")
                        (("2" (grind) nil nil)) nil))
                      nil))
                    nil)
                   ("2" (hide-all-but (1 2)) (("2" (grind) nil nil))
                    nil))
                  nil)
                 ("2" (hide-all-but (1 2)) (("2" (grind) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions nil)
    (complete_square formula-decl nil quadratic nil)
    (quadratic const-decl "real" quadratic nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (> const-decl "bool" reals nil)
    (TRUE const-decl "bool" booleans nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (bijective? const-decl "bool" functions nil)
    (CBD_85 skolem-const-decl "nnreal" convex_functions nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (pos_div_gt formula-decl nil real_props nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (zero_times1 formula-decl nil real_props nil)
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (t skolem-const-decl "real" convex_functions nil)
    (lt_times_lt_pos1 formula-decl nil real_props nil)
    (both_sides_times_pos_ge2 formula-decl nil real_props nil)
    (both_sides_times_pos_gt2 formula-decl nil real_props nil)
    (both_sides_plus_gt1 formula-decl nil real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (neg_times_le formula-decl nil real_props nil)
    (neg_times_lt formula-decl nil real_props nil)
    (pos_times_gt formula-decl nil real_props nil)
    (both_sides_plus_le2 formula-decl nil real_props nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (both_sides_minus_le2 formula-decl nil real_props nil)
    (both_sides_minus_le1 formula-decl nil real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (sq const-decl "nonneg_real" sq nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (<= const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (/= const-decl "boolean" notequal nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nnreal type-eq-decl nil real_types nil)
    (aaa skolem-const-decl "nnreal" convex_functions nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil)
  (quad_convex-2 nil 3462806762
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (skeep)
        (("" (lemma "complete_square")
          (("" (copy -1)
            (("" (copy -1)
              (("" (inst - "a" "b" "c" "y + t * x - t * y")
                (("" (inst - "a" "b" "c" "y")
                  (("" (inst - "a" "b" "c" "x")
                    (("" (replace -1)
                      (("" (hide -1)
                        (("" (replace -1)
                          (("" (hide -1)
                            (("" (replace -1)
                              ((""
                                (hide -1)
                                ((""
                                  (assert)
                                  ((""
                                    (both-sides
                                     "-"
                                     "(4 * (a * c) - sq(b)) / (4 * a)"
                                     2)
                                    ((""
                                      (assert)
                                      ((""
                                        (cancel-by 2 "a")
                                        ((""
                                          (name "W" "b/(2 * a)")
                                          ((""
                                            (label "wname" -1)
                                            ((""
                                              (replace "wname")
                                              ((""
                                                (hide "wname")
                                                ((""
                                                  (name "Qx" "W + x")
                                                  ((""
                                                    (label "qxname" -1)
                                                    ((""
                                                      (name
                                                       "Qy"
                                                       "W + y")
                                                      ((""
                                                        (label
                                                         "qyname"
                                                         -1)
                                                        ((""
                                                          (case
                                                           "x = Qx - W and y = Qy - W")
                                                          (("1"
                                                            (prop)
                                                            (("1"
                                                              (label
                                                               "xQx"
                                                               -1)
                                                              (("1"
                                                                (label
                                                                 "yQy"
                                                                 -2)
                                                                (("1"
                                                                  (replace
                                                                   "xQx")
                                                                  (("1"
                                                                    (replace
                                                                     "yQy")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (hide
                                                                         ("xQx"
                                                                          "yQy"
                                                                          "qyname"
                                                                          "qxname"))
                                                                        (("1"
                                                                          (case
                                                                           "sq(Qx - Qy) > 0")
                                                                          (("1"
                                                                            (expand
                                                                             "sq"
                                                                             -)
                                                                            (("1"
                                                                              (both-sides
                                                                               "+"
                                                                               "2*Qx*Qy"
                                                                               -1)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (mult-by
                                                                                     -1
                                                                                     "t*(1-t)")
                                                                                    (("1"
                                                                                      (grind)
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide-all-but
                                                                                       (-3
                                                                                        -4
                                                                                        1))
                                                                                      (("2"
                                                                                        (lemma
                                                                                         "lt_times_lt_pos1")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "t"
                                                                                           "t"
                                                                                           "1"
                                                                                           "t")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil)))))))))))))))))
                                                                           ("2"
                                                                            (hide-all-but
                                                                             (1
                                                                              4))
                                                                            (("2"
                                                                              (lemma
                                                                               "pos_times_gt")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "Qx-Qy"
                                                                                 "Qx-Qy")
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil)))))))))))))))))))))))
                                                           ("2"
                                                            (assert)
                                                            nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (quad_convex-1 nil 3462806328
   ("" (skeep)
    (("" (expand "convex?")
      (("" (skeep)
        (("" (lemma "complete_square")
          (("" (copy -1)
            (("" (copy -1)
              (("" (inst - "b" "c" "d" "y + t * x - t * y")
                (("1" (inst - "b" "c" "d" "y")
                  (("1" (inst - "b" "c" "d" "x")
                    (("1" (replace -1)
                      (("1" (hide -1)
                        (("1" (replace -1)
                          (("1" (hide -1)
                            (("1" (replace -1)
                              (("1"
                                (hide -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (both-sides
                                     "-"
                                     "(4 * (b * d) - sq(c)) / (4 * b)"
                                     1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case "b = 0")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (cancel-by 2 "b")
                                          (("1" (postpone) nil nil)
                                           ("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (postpone) nil nil))
                    nil)
                   ("2" (postpone) nil nil))
                  nil)
                 ("2" (postpone) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil))
 (quad_strictly_convex 0
  (quad_strictly_convex-1 nil 3462701949
   ("" (skeep)
    (("" (expand "strictly_convex?")
      (("" (skeep)
        (("" (lemma "complete_square")
          (("" (copy -1)
            (("" (copy -1)
              (("" (inst - "a" "b" "c" "y + t * x - t * y")
                (("" (inst - "a" "b" "c" "y")
                  (("" (inst - "a" "b" "c" "x")
                    (("" (replace -1)
                      (("" (hide -1)
                        (("" (replace -1)
                          (("" (hide -1)
                            (("" (replace -1)
                              ((""
                                (hide -1)
                                ((""
                                  (assert)
                                  ((""
                                    (both-sides
                                     "-"
                                     "(4 * (a * c) - sq(b)) / (4 * a)"
                                     2)
                                    ((""
                                      (assert)
                                      ((""
                                        (cancel-by 2 "a")
                                        ((""
                                          (name "W" "b/(2 * a)")
                                          ((""
                                            (label "wname" -1)
                                            ((""
                                              (replace "wname")
                                              ((""
                                                (hide "wname")
                                                ((""
                                                  (name "Qx" "W + x")
                                                  ((""
                                                    (label "qxname" -1)
                                                    ((""
                                                      (name
                                                       "Qy"
                                                       "W + y")
                                                      ((""
                                                        (label
                                                         "qyname"
                                                         -1)
                                                        ((""
                                                          (case
                                                           "x = Qx - W and y = Qy - W")
                                                          (("1"
                                                            (prop)
                                                            (("1"
                                                              (label
                                                               "xQx"
                                                               -1)
                                                              (("1"
                                                                (label
                                                                 "yQy"
                                                                 -2)
                                                                (("1"
                                                                  (replace
                                                                   "xQx")
                                                                  (("1"
                                                                    (replace
                                                                     "yQy")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (hide
                                                                         ("xQx"
                                                                          "yQy"
                                                                          "qyname"
                                                                          "qxname"))
                                                                        (("1"
                                                                          (case
                                                                           "sq(Qx - Qy) > 0")
                                                                          (("1"
                                                                            (expand
                                                                             "sq"
                                                                             -)
                                                                            (("1"
                                                                              (both-sides
                                                                               "+"
                                                                               "2*Qx*Qy"
                                                                               -1)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (mult-by
                                                                                     -1
                                                                                     "t*(1-t)")
                                                                                    (("1"
                                                                                      (grind)
                                                                                      nil
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide-all-but
                                                                                       (-3
                                                                                        -4
                                                                                        1))
                                                                                      (("2"
                                                                                        (lemma
                                                                                         "lt_times_lt_pos1")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "t"
                                                                                           "t"
                                                                                           "1"
                                                                                           "t")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             (1
                                                                              4))
                                                                            (("2"
                                                                              (lemma
                                                                               "pos_times_gt")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "Qx-Qy"
                                                                                 "Qx-Qy")
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (strictly_convex? const-decl "bool" convex_functions nil)
    (complete_square formula-decl nil quadratic nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (both_sides_plus_gt1 formula-decl nil real_props nil)
    (both_sides_times_pos_gt2 formula-decl nil real_props nil)
    (both_sides_times_pos_ge2 formula-decl nil real_props nil)
    (lt_times_lt_pos1 formula-decl nil real_props nil)
    (t skolem-const-decl "real" convex_functions nil)
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (pos_times_gt formula-decl nil real_props nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (neg_times_le formula-decl nil real_props nil)
    (neg_times_lt formula-decl nil real_props nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (both_sides_times_pos_lt2 formula-decl nil real_props nil)
    (both_sides_plus_lt2 formula-decl nil real_props nil)
    (both_sides_minus_le2 formula-decl nil real_props nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (both_sides_plus_le2 formula-decl nil real_props nil)
    (both_sides_minus_lt2 formula-decl nil real_props nil)
    (both_sides_div_pos_lt1 formula-decl nil real_props nil)
    (both_sides_minus_lt1 formula-decl nil real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (sq const-decl "nonneg_real" sq nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (< const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (/= const-decl "boolean" notequal 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_minus_real_is_real application-judgement "real" reals nil))
   shostak))
 (abs_linear_convex 0
  (abs_linear_convex-1 nil 3462872201
   ("" (skeep)
    (("" (lemma "max_of_convex")
      (("" (assert)
        (("" (hide -1)
          (("" (lemma "quad_convex")
            (("" (assert)
              (("" (hide -1)
                (("" (expand "convex?")
                  (("" (skosimp*)
                    (("" (both-sides "+" "H" 1)
                      (("" (assert)
                        (("" (lemma "triangle")
                          ((""
                            (inst - "(1-t!1)*(y!1*y + x)"
                             "t!1*(x!1*y + x)")
                            (("" (lemma "abs_mult")
                              ((""
                                (inst - "(1-t!1)" "y!1*y + x")
                                ((""
                                  (replace -1)
                                  ((""
                                    (hide -1)
                                    ((""
                                      (lemma "abs_mult")
                                      ((""
                                        (inst - "t!1" "x!1*y + x")
                                        ((""
                                          (replace -1)
                                          ((""
                                            (hide -1)
                                            ((""
                                              (expand "abs" -1 2)
                                              ((""
                                                (expand "abs" -1 3)
                                                (("" (assertnil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((max_of_convex formula-decl nil convex_functions nil)
    (convex? const-decl "bool" convex_functions nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields 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)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (both_sides_plus_le1 formula-decl nil real_props nil)
    (both_sides_minus_le1 formula-decl nil 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (triangle formula-decl nil real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (quad_convex formula-decl nil convex_functions nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (quad_linear_max_convex 0
  (quad_linear_max_convex-1 nil 3462806001
   ("" (skeep)
    (("" (skoletin 1)
      (("" (lemma "max_of_convex")
        ((""
          (inst - "quadratic(a,b,c)" "(lambda (t): abs(x + t*y) - H)")
          (("" (assert)
            (("" (hide 2)
              (("" (hide -1)
                (("" (lemma "quad_convex")
                  (("" (inst - "a" "b" "c")
                    (("" (assert)
                      (("" (hide -1)
                        (("" (expand "convex?")
                          (("" (skosimp*)
                            (("" (both-sides "+" "H" 1)
                              ((""
                                (assert)
                                ((""
                                  (lemma "triangle")
                                  ((""
                                    (inst
                                     -
                                     "(1-t!1)*(y!1*y + x)"
                                     "t!1*(x!1*y + x)")
                                    ((""
                                      (lemma "abs_mult")
                                      ((""
                                        (inst - "(1-t!1)" "y!1*y + x")
                                        ((""
                                          (replace -1)
                                          ((""
                                            (hide -1)
                                            ((""
                                              (lemma "abs_mult")
                                              ((""
                                                (inst
                                                 -
                                                 "t!1"
                                                 "x!1*y + x")
                                                ((""
                                                  (replace -1)
                                                  ((""
                                                    (hide -1)
                                                    ((""
                                                      (expand
                                                       "abs"
                                                       -1
                                                       2)
                                                      ((""
                                                        (expand
                                                         "abs"
                                                         -1
                                                         3)
                                                        ((""
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((IFF const-decl "[bool, bool -> bool]" booleans 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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (quadratic const-decl "real" quadratic nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (convex? const-decl "bool" convex_functions nil)
    (quad_convex formula-decl nil convex_functions nil)
    (<= const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (both_sides_plus_le1 formula-decl nil real_props nil)
    (both_sides_minus_le1 formula-decl nil 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (triangle formula-decl nil real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (nnreal type-eq-decl nil real_types nil)
    (max_of_convex formula-decl nil convex_functions nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (quad_linear_max_glob_min 0
  (quad_linear_max_glob_min-7 nil 3462720029
   ("" (skeep)
    ((""
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      (("" (label "newquadname" -1)
        (("" (skoletin 1)
          (("" (prop)
            (("" (replace -4)
              (("" (assert)
                (("" (hide -4)
                  ((""
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                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
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (copy -2)
                        (("2" (hide -3)
                          (("2"
                            (case "quadratic(a,b,c)(v) >= abs(v*y + x) - H")
                            (("1" (expand "max" -2)
                              (("1"
                                (assert)
                                (("1"
                                  (replace -2)
                                  (("1"
                                    (both-sides "+" "H" -1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (mult-ineq -1 -1)
                                        (("1"
                                          (lemma "sq_rew")
                                          (("1"
                                            (inst - "abs(v*y + x)")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (hide -1)
                                                (("1"
                                                  (lemma "sq_abs")
                                                  (("1"
                                                    (inst - "v*y+x")
                                                    (("1"
                                                      (replace -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (both-sides
                                                           "-"
                                                           "H*H"
                                                           -1)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (case-replace
                                                               "sq(v * y + x) - H * H = newquad(v)")
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 1)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (replace
                                                                 "newquadname"
                                                                 +
                                                                 rl)
                                                                (("2"
                                                                  (hide-all-but
                                                                   1)
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide-all-but (-1 1))
                                          (("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "max" -1)
                              (("2"
                                (assert)
                                (("2"
                                  (replace -1)
                                  (("2"
                                    (both-sides "+" "H" -1)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (mult-eq -1 -1)
                                        (("2"
                                          (lemma "sq_rew")
                                          (("2"
                                            (inst - "abs(v*y+x)")
                                            (("2"
                                              (replace -1)
                                              (("2"
                                                (hide -1)
                                                (("2"
                                                  (lemma "sq_abs")
                                                  (("2"
                                                    (inst - "v*y+x")
                                                    (("2"
                                                      (replace -1)
                                                      (("2"
                                                        (hide -1)
                                                        (("2"
                                                          (both-sides
                                                           -
                                                           "H*H"
                                                           -1)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (case-replace
                                                               "sq(v * y + x) - H * H = newquad(v)")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (replace
                                                                 "newquadname"
                                                                 +
                                                                 rl)
                                                                (("2"
                                                                  (hide-all-but
                                                                   1)
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (sq const-decl "nonneg_real" sq nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (quadratic const-decl "real" quadratic nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (<= const-decl "bool" reals nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (both_sides_minus_ge1 formula-decl nil real_props nil)
    (both_sides_times_pos_ge2 formula-decl nil real_props nil)
    (ge_times_ge_any1 formula-decl nil extra_real_props nil)
    (both_sides_plus_ge1 formula-decl nil real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (y skolem-const-decl "real" convex_functions nil)
    (max_of_strictly_convex formula-decl nil convex_functions nil)
    (nnreal_plus_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (both_sides_plus_le1 formula-decl nil real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (le_times_le_any1 formula-decl nil extra_real_props nil)
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (both_sides_minus_le1 formula-decl nil real_props nil)
    (sq_abs formula-decl nil sq nil) (sq_rew formula-decl nil sq 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)
    (strictly_convex_unique_min formula-decl nil convex_functions nil)
    (pos_times_lt formula-decl nil real_props nil)
    (quad_strictly_convex formula-decl nil convex_functions nil)
    (sq_nz_pos application-judgement "posreal" sq nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil)
  (quad_linear_max_glob_min-6 nil 3462719997
   (";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
    (skeep)
    ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
        (label "newquadname" -1)
        ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
          (skoletin 1)
          ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
            (prop)
            ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
              (replace -1)
              ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
                (assert)
                ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
                  (hide -1)
                  ((";;; Proof quad_linear_max_glob_min-5 for formula convex_functions.quad_linear_max_glob_min"
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil)))))
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                nil)))))))))))))))))))))))))))))))))))))))))
                                                                       ("2"
                                                                        (hide
                                                                         (2
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil)))))
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2"
                                        (grind)
                                        nil)))))))))))))))))))
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))))))))))))))))
                       ("2"
                        (case "quadratic(a,b,c)(v) >= abs(v*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(v*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "v*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(v * y + x) - H * H = newquad(v)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(v*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "v*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(v * y + x) - H * H = newquad(v)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    ";;; developed with shostak decision procedures")
   nil nil)
  (quad_linear_max_glob_min-5 nil 3462719917
   ("" (skeep)
    ((""
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      (("" (label "newquadname" -1)
        (("" (skoletin 1)
          (("" (prop)
            (("" (replace -1)
              (("" (assert)
                (("" (hide -1)
                  ((""
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil)))))
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                nil)))))))))))))))))))))))))))))))))))))))))
                                                                       ("2"
                                                                        (hide
                                                                         (2
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil)))))
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2"
                                        (grind)
                                        nil)))))))))))))))))))
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))))))))))))))))
                       ("2"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (quad_linear_max_glob_min-4 nil 3462719891
   (";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
    (skeep)
    ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
        (label "newquadname" -1)
        ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
          (skoletin 1)
          ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
            (prop)
            ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
              (replace -1)
              ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
                (assert)
                ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
                  (hide -1)
                  ((";;; Proof quad_linear_max_glob_min-3 for formula convex_functions.quad_linear_max_glob_min"
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil)))))
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                nil)))))))))))))))))))))))))))))))))))))))))
                                                                       ("2"
                                                                        (hide
                                                                         (2
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil)))))
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2"
                                        (grind)
                                        nil)))))))))))))))))))
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))))))))))))))))
                       ("2"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    ";;; developed with shostak decision procedures")
   nil nil)
  (quad_linear_max_glob_min-3 nil 3462719613
   ("" (skeep)
    ((""
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      (("" (label "newquadname" -1)
        (("" (skoletin 1)
          (("" (prop)
            (("" (replace -1)
              (("" (assert)
                (("" (hide -1)
                  ((""
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil)))))
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                nil)))))))))))))))))))))))))))))))))))))))))
                                                                       ("2"
                                                                        (hide
                                                                         (2
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil)))))
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2"
                                        (grind)
                                        nil)))))))))))))))))))
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))))))))))))))))
                       ("2" (expand "max" -1)
                        (("2" (assert)
                          (("2" (replace -1)
                            (("2" (both-sides "+" "H" -1)
                              (("2"
                                (assert)
                                (("2"
                                  (mult-eq -1 -1)
                                  (("2"
                                    (lemma "sq_rew")
                                    (("2"
                                      (inst - "abs(w*y+x)")
                                      (("2"
                                        (replace -1)
                                        (("2"
                                          (hide -1)
                                          (("2"
                                            (lemma "sq_abs")
                                            (("2"
                                              (inst - "w*y+x")
                                              (("2"
                                                (replace -1)
                                                (("2"
                                                  (hide -1)
                                                  (("2"
                                                    (both-sides
                                                     -
                                                     "H*H"
                                                     -1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case-replace
                                                         "sq(w * y + x) - H * H = newquad(w)")
                                                        (("1"
                                                          (assert)
                                                          nil)
                                                         ("2"
                                                          (replace
                                                           "newquadname"
                                                           +
                                                           rl)
                                                          (("2"
                                                            (hide-all-but
                                                             1)
                                                            (("2"
                                                              (grind)
                                                              nil)))))))))))))))))))))))))))))))))))))))
                       ("2" (copy -2)
                        (("2" (hide -3)
                          (("2" (expand "max" -2)
                            (("2" (assert)
                              (("2"
                                (replace -2)
                                (("2"
                                  (both-sides "+" "H" -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (mult-ineq -1 -1)
                                      (("1"
                                        (lemma "sq_rew")
                                        (("1"
                                          (inst - "abs(w*y + x)")
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma "sq_abs")
                                                (("1"
                                                  (inst - "w*y+x")
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (both-sides
                                                         "-"
                                                         "H*H"
                                                         -1)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (case-replace
                                                             "sq(w * y + x) - H * H = newquad(w)")
                                                            (("1"
                                                              (expand
                                                               "max"
                                                               1)
                                                              (("1"
                                                                (assert)
                                                                nil)))
                                                             ("2"
                                                              (replace
                                                               "newquadname"
                                                               +
                                                               rl)
                                                              (("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (grind)
                                                                  nil)))))))))))))))))))))))))))
                                       ("2"
                                        (hide-all-but (-1 1))
                                        (("2"
                                          (grind)
                                          nil))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (quad_linear_max_glob_min-2 nil 3462719584
   (";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
    (skeep)
    ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
        (label "newquadname" -1)
        ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
          (skoletin 1)
          ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
            (prop)
            ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
              (replace -1)
              ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
                (assert)
                ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
                  (hide -1)
                  ((";;; Proof quad_linear_max_glob_min-1 for formula convex_functions.quad_linear_max_glob_min"
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil)))))
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                nil)))))))))))))))))))))))))))))))))))))))))
                                                                       ("2"
                                                                        (hide
                                                                         (2
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil)))))
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2"
                                        (grind)
                                        nil)))))))))))))))))))
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil)))
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil)))))))))))))))
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil)))))))))))))))))))))))))))))))))))))))))
                       ("2" (expand "max" -1)
                        (("2" (assert)
                          (("2" (replace -1)
                            (("2" (both-sides "+" "H" -1)
                              (("2"
                                (assert)
                                (("2"
                                  (mult-eq -1 -1)
                                  (("2"
                                    (lemma "sq_rew")
                                    (("2"
                                      (inst - "abs(w*y+x)")
                                      (("2"
                                        (replace -1)
                                        (("2"
                                          (hide -1)
                                          (("2"
                                            (lemma "sq_abs")
                                            (("2"
                                              (inst - "w*y+x")
                                              (("2"
                                                (replace -1)
                                                (("2"
                                                  (hide -1)
                                                  (("2"
                                                    (both-sides
                                                     -
                                                     "H*H"
                                                     -1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case-replace
                                                         "sq(w * y + x) - H * H = newquad(w)")
                                                        (("1"
                                                          (assert)
                                                          nil)
                                                         ("2"
                                                          (replace
                                                           "newquadname"
                                                           +
                                                           rl)
                                                          (("2"
                                                            (hide-all-but
                                                             1)
                                                            (("2"
                                                              (grind)
                                                              nil)))))))))))))))))))))))))))))))))))))))
                       ("2" (copy -2)
                        (("2" (hide -3)
                          (("2" (expand "max" -2)
                            (("2" (assert)
                              (("2"
                                (replace -2)
                                (("2"
                                  (both-sides "+" "H" -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (mult-ineq -1 -1)
                                      (("1"
                                        (lemma "sq_rew")
                                        (("1"
                                          (inst - "abs(w*y + x)")
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma "sq_abs")
                                                (("1"
                                                  (inst - "w*y+x")
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (both-sides
                                                         "-"
                                                         "H*H"
                                                         -1)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (case-replace
                                                             "sq(w * y + x) - H * H = newquad(w)")
                                                            (("1"
                                                              (expand
                                                               "max"
                                                               1)
                                                              (("1"
                                                                (assert)
                                                                nil)))
                                                             ("2"
                                                              (replace
                                                               "newquadname"
                                                               +
                                                               rl)
                                                              (("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (grind)
                                                                  nil)))))))))))))))))))))))))))
                                       ("2"
                                        (hide-all-but (-1 1))
                                        (("2"
                                          (grind)
                                          nil))))))))))))))))))))))))))))))))))))))
    ";;; developed with shostak decision procedures")
   nil nil)
  (quad_linear_max_glob_min-1 nil 3462716302
   ("" (skeep)
    ((""
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      (("" (label "newquadname" -1)
        (("" (skoletin 1)
          (("" (prop)
            (("" (replace -1)
              (("" (assert)
                (("" (hide -1)
                  ((""
                    (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                    (("1" (prop)
                      (("1" (lemma "quad_strictly_convex")
                        (("1" (copy -1)
                          (("1" (inst - "a" "b" "c")
                            (("1"
                              (inst - "sq(y)" "2*x*y" "sq(x) - sq(H)")
                              (("1"
                                (replace "newquadname")
                                (("1"
                                  (lemma "max_of_strictly_convex")
                                  (("1"
                                    (inst
                                     -
                                     "quadratic(a, b, c)"
                                     "newquad")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "strictly_convex_unique_min")
                                        (("1"
                                          (inst
                                           -
                                           "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                           "v"
                                           "w")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (replace -5)
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst - "z!1")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "max"
                                                                 -6)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "max"
                                                               -5)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (both-sides
                                                                   "+"
                                                                   "H"
                                                                   -5)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (mult-ineq
                                                                       -5
                                                                       -5)
                                                                      (("1"
                                                                        (lemma
                                                                         "sq_rew")
                                                                        (("1"
                                                                          (copy
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "H")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "abs(z!1*y+x)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "sq_abs")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -1
                                                                                           "z!1*y+x")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sq"
                                                                                                 -1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (both-sides
                                                                                                   "-"
                                                                                                   "sq(H)"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           ("newquadname"
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "newquadname"
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               "newquadname")
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                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
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9))
                                                                        (("2"
                                                                          (prop)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             2)
                                                                            (("1"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1
                                                                               1)
                                                                              (("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but (1 2 3 4 5 6))
                                (("2"
                                  (expand "sq")
                                  (("2"
                                    (lemma "pos_times_lt")
                                    (("2"
                                      (inst - "y" "y")
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (prop)
                      (("1"
                        (case "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                        (("1" (expand "max" -2)
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (both-sides "+" "H" -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (mult-ineq -1 -1)
                                    (("1"
                                      (lemma "sq_rew")
                                      (("1"
                                        (inst - "abs(w*y + x)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma "sq_abs")
                                              (("1"
                                                (inst - "w*y+x")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (both-sides
                                                       "-"
                                                       "H*H"
                                                       -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (expand
                                                             "max"
                                                             1)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "max" -1)
                          (("2" (assert)
                            (("2" (replace -1)
                              (("2"
                                (both-sides "+" "H" -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (mult-eq -1 -1)
                                    (("2"
                                      (lemma "sq_rew")
                                      (("2"
                                        (inst - "abs(w*y+x)")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (lemma "sq_abs")
                                              (("2"
                                                (inst - "w*y+x")
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (both-sides
                                                       -
                                                       "H*H"
                                                       -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case-replace
                                                           "sq(w * y + x) - H * H = newquad(w)")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             "newquadname"
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (copy -2)
                        (("2" (hide -3) (("2" (postpone) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil))
 (quad_linear_max_loc_min 0
  (quad_linear_max_loc_min-1 nil 3462722775
   ("" (skeep)
    ((""
      (name "newquad" "quadratic(sq(y), 2 * (x * y), sq(x) - sq(H))")
      (("" (label "newquadname" -1)
        (("" (skoletin 1)
          (("" (prop)
            (("" (label "Aw" -1)
              (("" (label "Bw" -2)
                (("" (label "Av" -3)
                  (("" (label "Bv" -4)
                    (("" (hide ("Aw" "Bw" "Av" "Bv"))
                      (("" (replace -4)
                        (("" (assert)
                          (("" (hide -4)
                            ((""
                              (case "max(quadratic(a,b,c)(w),newquad(w)) = 0 AND max(quadratic(a,b,c)(v),newquad(v)) = 0")
                              (("1"
                                (prop)
                                (("1"
                                  (lemma "quad_strictly_convex")
                                  (("1"
                                    (copy -1)
                                    (("1"
                                      (inst - "a" "b" "c")
                                      (("1"
                                        (inst
                                         -
                                         "sq(y)"
                                         "2*x*y"
                                         "sq(x) - sq(H)")
                                        (("1"
                                          (replace "newquadname")
                                          (("1"
                                            (lemma
                                             "max_of_strictly_convex")
                                            (("1"
                                              (inst
                                               -
                                               "quadratic(a, b, c)"
                                               "newquad")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (lemma
                                                   "strictly_conv_uniq_intv_min")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "A"
                                                     "B"
                                                     "(LAMBDA (z): max(quadratic(a, b, c)(z), newquad(z)))"
                                                     "v"
                                                     "w")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (reveal
                                                         ("Aw"
                                                          "Bw"
                                                          "Av"
                                                          "Bv"))
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide
                                                             ("Aw"
                                                              "Bw"
                                                              "Av"
                                                              "Bv"))
                                                            (("1"
                                                              (replace
                                                               -4)
                                                              (("1"
                                                                (replace
                                                                 -5)
                                                                (("1"
                                                                  (skosimp*)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "z!1")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (hide
                                                                           -1)
                                                                          (("1"
                                                                            (hide
                                                                             -1)
                                                                            (("1"
                                                                              (hide
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (case
                                                                                   "quadratic(a, b, c)(z!1) >= abs(z!1 * y + x) - H")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "max"
                                                                                       -6)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (expand
                                                                                     "max"
                                                                                     -5)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (both-sides
                                                                                         "+"
                                                                                         "H"
                                                                                         -5)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (mult-ineq
                                                                                             -5
                                                                                             -5)
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "sq_rew")
                                                                                              (("1"
                                                                                                (copy
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -1
                                                                                                   "H")
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (hide
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -1
                                                                                                         "abs(z!1*y+x)")
                                                                                                        (("1"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (lemma
                                                                                                               "sq_abs")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -1
                                                                                                                 "z!1*y+x")
                                                                                                                (("1"
                                                                                                                  (replace
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (hide
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "sq"
                                                                                                                       -1
                                                                                                                       2)
                                                                                                                      (("1"
                                                                                                                        (both-sides
                                                                                                                         "-"
                                                                                                                         "sq(H)"
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (case-replace
                                                                                                                               "y * y * z!1 * z!1 - sq(H) + 2 * (x * y * z!1) + x * x = newquad(z!1)")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (hide-all-but
                                                                                                                                 ("newquadname"
                                                                                                                                  1))
                                                                                                                                (("2"
                                                                                                                                  (replace
                                                                                                                                   "newquadname"
                                                                                                                                   +
                                                                                                                                   rl)
                                                                                                                                  (("2"
                                                                                                                                    (hide
                                                                                                                                     "newquadname")
                                                                                                                                    (("2"
                                                                                                                                      (grind)
                                                                                                                                      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
                                                                                                3
                                                                                                4
                                                                                                5
                                                                                                6
                                                                                                7
                                                                                                8
                                                                                                9))
                                                                                              (("2"
                                                                                                (prop)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "abs"
                                                                                                   1
                                                                                                   2)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "abs"
                                                                                                     1
                                                                                                     1)
                                                                                                    (("1"
                                                                                                      (propax)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (expand
                                                                                                   "abs"
                                                                                                   1
                                                                                                   1)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "abs"
                                                                                                     1
                                                                                                     1)
                                                                                                    (("2"
                                                                                                      (propax)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide-all-but (1 2 3 4 5 6))
                                          (("2"
                                            (expand "sq")
                                            (("2"
                                              (lemma "pos_times_lt")
                                              (("2"
                                                (inst - "y" "y")
                                                (("2" (grind) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (prop)
                                (("1"
                                  (case
                                   "quadratic(a,b,c)(w) >= abs(w*y + x) - H")
                                  (("1"
                                    (expand "max" -2)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (replace -2)
                                        (("1"
                                          (both-sides "+" "H" -1)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (mult-ineq -1 -1)
                                              (("1"
                                                (lemma "sq_rew")
                                                (("1"
                                                  (inst
                                                   -
                                                   "abs(w*y + x)")
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (lemma
                                                         "sq_abs")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "w*y+x")
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (hide -1)
                                                              (("1"
                                                                (both-sides
                                                                 "-"
                                                                 "H*H"
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case-replace
                                                                     "sq(w * y + x) - H * H = newquad(w)")
                                                                    (("1"
                                                                      (expand
                                                                       "max"
                                                                       1)
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (replace
                                                                       "newquadname"
                                                                       +
                                                                       rl)
                                                                      (("2"
                                                                        (hide-all-but
                                                                         1)
                                                                        (("2"
                                                                          (grind)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide-all-but (-1 1))
                                                (("2" (grind) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "max" -1)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (replace -1)
                                        (("2"
                                          (both-sides "+" "H" -1)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (mult-eq -1 -1)
                                              (("2"
                                                (lemma "sq_rew")
                                                (("2"
                                                  (inst - "abs(w*y+x)")
                                                  (("2"
                                                    (replace -1)
                                                    (("2"
                                                      (hide -1)
                                                      (("2"
                                                        (lemma
                                                         "sq_abs")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "w*y+x")
                                                          (("2"
                                                            (replace
                                                             -1)
                                                            (("2"
                                                              (hide -1)
                                                              (("2"
                                                                (both-sides
                                                                 -
                                                                 "H*H"
                                                                 -1)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (case-replace
                                                                     "sq(w * y + x) - H * H = newquad(w)")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (replace
                                                                       "newquadname"
                                                                       +
                                                                       rl)
                                                                      (("2"
                                                                        (hide-all-but
                                                                         1)
                                                                        (("2"
                                                                          (grind)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (copy -2)
                                  (("2"
                                    (hide -3)
                                    (("2"
                                      (case
                                       "quadratic(a,b,c)(v) >= abs(v*y + x) - H")
                                      (("1"
                                        (expand "max" -2)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (replace -2)
                                            (("1"
                                              (both-sides "+" "H" -1)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (mult-ineq -1 -1)
                                                  (("1"
                                                    (lemma "sq_rew")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "abs(v*y + x)")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (lemma
                                                             "sq_abs")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "v*y+x")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (both-sides
                                                                     "-"
                                                                     "H*H"
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (case-replace
                                                                         "sq(v * y + x) - H * H = newquad(v)")
                                                                        (("1"
                                                                          (expand
                                                                           "max"
                                                                           1)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (replace
                                                                           "newquadname"
                                                                           +
                                                                           rl)
                                                                          (("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "max" -1)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (replace -1)
                                            (("2"
                                              (both-sides "+" "H" -1)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (mult-eq -1 -1)
                                                  (("2"
                                                    (lemma "sq_rew")
                                                    (("2"
                                                      (inst
                                                       -
                                                       "abs(v*y+x)")
                                                      (("2"
                                                        (replace -1)
                                                        (("2"
                                                          (hide -1)
                                                          (("2"
                                                            (lemma
                                                             "sq_abs")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "v*y+x")
                                                              (("2"
                                                                (replace
                                                                 -1)
                                                                (("2"
                                                                  (hide
                                                                   -1)
                                                                  (("2"
                                                                    (both-sides
                                                                     -
                                                                     "H*H"
                                                                     -1)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (case-replace
                                                                         "sq(v * y + x) - H * H = newquad(v)")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (replace
                                                                           "newquadname"
                                                                           +
                                                                           rl)
                                                                          (("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (sq const-decl "nonneg_real" sq nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (quadratic const-decl "real" quadratic nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (<= const-decl "bool" reals nil)
    (sq_nz_pos application-judgement "posreal" sq nil)
    (quad_strictly_convex formula-decl nil convex_functions nil)
    (pos_times_lt formula-decl nil real_props nil)
    (strictly_conv_uniq_intv_min formula-decl nil convex_functions 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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sq_rew formula-decl nil sq nil) (sq_abs formula-decl nil sq nil)
    (both_sides_minus_le1 formula-decl nil real_props nil)
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (le_times_le_any1 formula-decl nil extra_real_props nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (both_sides_plus_le1 formula-decl nil real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (nnreal_plus_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (max_of_strictly_convex formula-decl nil convex_functions nil)
    (y skolem-const-decl "real" convex_functions nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (both_sides_plus_ge1 formula-decl nil real_props nil)
    (ge_times_ge_any1 formula-decl nil extra_real_props nil)
    (both_sides_times_pos_ge2 formula-decl nil real_props nil)
    (both_sides_minus_ge1 formula-decl nil real_props nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (power_of_convex_TCC1 0
  (power_of_convex_TCC1-1 nil 3465293778 ("" (subtype-tcc) nil nil)
   ((convex? const-decl "bool" convex_functions nil)
    (/= const-decl "boolean" notequal nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil))
 (power_of_convex 0
  (power_of_convex-1 nil 3465293781
   ("" (induct "k")
    (("1" (skeep)
      (("1" (expand "^")
        (("1" (expand "expt")
          (("1" (expand "convex?" 1) (("1" (propax) nil nil)) nil))
          nil))
        nil))
      nil)
     ("2" (skeep)
      (("2" (skeep)
        (("2" (inst - "f")
          (("2" (expand "^")
            (("2" (expand "expt" +)
              (("2" (name "h" "LAMBDA (x): expt(f(x),j)")
                (("2"
                  (case-replace
                   "(LAMBDA (x): f(x) * expt(f(x), j)) = f*h")
                  (("1" (hide -1)
                    (("1" (assert)
                      (("1" (replace -4)
                        (("1" (replace -1)
                          (("1" (label "hname" -1)
                            (("1" (label "hconv" -2)
                              (("1"
                                (label "fconv" -3)
                                (("1"
                                  (label "ge0" -4)
                                  (("1"
                                    (label "final" 1)
                                    (("1"
                                      (case "forall (x): h(x) >= 0")
                                      (("1"
                                        (label "hge0" -1)
                                        (("1"
                                          (case "j > 0")
                                          (("1"
                                            (label "jgt0" -1)
                                            (("1"
                                              (expand "convex?")
                                              (("1"
                                                (skeep)
                                                (("1"
                                                  (inst - "x" "y" "t")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "x"
                                                     "y"
                                                     "t")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand "*" +)
                                                        (("1"
                                                          (copy "ge0")
                                                          (("1"
                                                            (copy
                                                             "hge0")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "t*x-t*y+y")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "t*x-t*y+y")
                                                                (("1"
                                                                  (mult-ineq
                                                                   -6
                                                                   -7)
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (hide
                                                                       -2)
                                                                      (("1"
                                                                        (case
                                                                         "(t - t * t) * (h(x) - h(y)) * (f(y) - f(x)) <= 0")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (name
                                                                           "X"
                                                                           "(t-t*t)")
                                                                          (("2"
                                                                            (label
                                                                             "Xname"
                                                                             -1)
                                                                            (("2"
                                                                              (name
                                                                               "Y"
                                                                               "(h(x) - h(y))")
                                                                              (("2"
                                                                                (label
                                                                                 "Yname"
                                                                                 -1)
                                                                                (("2"
                                                                                  (name
                                                                                   "Z"
                                                                                   "(f(y) - f(x))")
                                                                                  (("2"
                                                                                    (label
                                                                                     "Zname"
                                                                                     -1)
                                                                                    (("2"
                                                                                      (replace
                                                                                       "Xname")
                                                                                      (("2"
                                                                                        (replace
                                                                                         "Yname")
                                                                                        (("2"
                                                                                          (replace
                                                                                           "Zname")
                                                                                          (("2"
                                                                                            (lemma
                                                                                             "neg_times_le")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "X"
                                                                                               "Y*Z")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (flatten)
                                                                                                  (("2"
                                                                                                    (hide
                                                                                                     2)
                                                                                                    (("2"
                                                                                                      (split)
                                                                                                      (("1"
                                                                                                        (replace
                                                                                                         "Xname"
                                                                                                         +
                                                                                                         rl)
                                                                                                        (("1"
                                                                                                          (both-sides
                                                                                                           "+"
                                                                                                           "t*t"
                                                                                                           1)
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (div-by
                                                                                                               1
                                                                                                               "t")
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (case
                                                                                                         "forall (xr,yr: real): f(xr) >= f(yr) IFF h(xr) >= h(yr)")
                                                                                                        (("1"
                                                                                                          (inst-cp
                                                                                                           -1
                                                                                                           "x"
                                                                                                           "y")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "y"
                                                                                                             "x")
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "Y>= 0")
                                                                                                              (("1"
                                                                                                                (label
                                                                                                                 "Ycase"
                                                                                                                 -1)
                                                                                                                (("1"
                                                                                                                  (case
                                                                                                                   "Z<=0")
                                                                                                                  (("1"
                                                                                                                    (lemma
                                                                                                                     "neg_times_le")
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "Y"
                                                                                                                       "Z")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (case
                                                                                                                 "Y<= 0")
                                                                                                                (("1"
                                                                                                                  (label
                                                                                                                   "Ycase"
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (case
                                                                                                                     "Z>=0")
                                                                                                                    (("1"
                                                                                                                      (lemma
                                                                                                                       "neg_times_le")
                                                                                                                      (("1"
                                                                                                                        (inst
                                                                                                                         -
                                                                                                                         "Y"
                                                                                                                         "Z")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide
                                                                                                           (2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6))
                                                                                                          (("2"
                                                                                                            (skeep)
                                                                                                            (("2"
                                                                                                              (case
                                                                                                               "f(yr) > 0 AND f(xr) > 0")
                                                                                                              (("1"
                                                                                                                (flatten)
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "both_sides_expt_pos_ge")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "j"
                                                                                                                     "f(xr)"
                                                                                                                     "f(yr)")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "^"
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           "hname"
                                                                                                                           +
                                                                                                                           rl)
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil)
                                                                                                                     ("3"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (case
                                                                                                                 "f(yr) = 0 or f(xr) = 0")
                                                                                                                (("1"
                                                                                                                  (inst-cp
                                                                                                                   "ge0"
                                                                                                                   "xr")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     "ge0"
                                                                                                                     "yr")
                                                                                                                    (("1"
                                                                                                                      (split
                                                                                                                       -1)
                                                                                                                      (("1"
                                                                                                                        (replace
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           "hname"
                                                                                                                           +
                                                                                                                           rl)
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "expt"
                                                                                                                               2
                                                                                                                               2)
                                                                                                                              (("1"
                                                                                                                                (replace
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (lemma
                                                                                                                                   "nnreal_expt")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "j"
                                                                                                                                     "f(xr)")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (replace
                                                                                                                         -1)
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (replace
                                                                                                                             "hname"
                                                                                                                             +
                                                                                                                             rl)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (replace
                                                                                                                                 -1)
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "expt"
                                                                                                                                   1
                                                                                                                                   1)
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (case
                                                                                                                                       "f(yr) = 0")
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -1)
                                                                                                                                        (("1"
                                                                                                                                          (expand
                                                                                                                                           "expt"
                                                                                                                                           1
                                                                                                                                           2)
                                                                                                                                          (("1"
                                                                                                                                            (propax)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (lemma
                                                                                                                                           "nnreal_expt")
                                                                                                                                          (("2"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "j"
                                                                                                                                             "f(yr)")
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              (("2"
                                                                                                                                                (lemma
                                                                                                                                                 "expt_pos_aux")
                                                                                                                                                (("2"
                                                                                                                                                  (inst
                                                                                                                                                   -
                                                                                                                                                   "j"
                                                                                                                                                   "f(yr)")
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (flatten)
                                                                                                                  (("2"
                                                                                                                    (inst-cp
                                                                                                                     "ge0"
                                                                                                                     "xr")
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       "ge0"
                                                                                                                       "yr")
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (case "j = 0")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (expand "expt")
                                                (("1"
                                                  (replace
                                                   "hname"
                                                   +
                                                   rl)
                                                  (("1"
                                                    (expand "*" +)
                                                    (("1"
                                                      (expand
                                                       "convex?")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skeep)
                                        (("2"
                                          (inst - "x")
                                          (("2"
                                            (replace "hname" + rl)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (lemma "nnreal_expt")
                                                (("2"
                                                  (inst - "j" "f(x)")
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (replace -1 + rl)
                    (("2" (expand "*" +) (("2" (propax) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((* const-decl "[T -> real]" real_fun_ops nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (> const-decl "bool" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals 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_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (le_times_le_any1 formula-decl nil extra_real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (both_sides_plus_le1 formula-decl nil real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (times_div_cancel1 formula-decl nil extra_real_props nil)
    (div_simp formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (both_sides_expt_pos_ge formula-decl nil exponentiation nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (yr skolem-const-decl "real" convex_functions nil)
    (xr skolem-const-decl "real" convex_functions nil)
    (f skolem-const-decl "[real -> real]" convex_functions nil)
    (nnreal_expt judgement-tcc nil exponentiation nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnreal type-eq-decl nil real_types nil)
    (expt_pos_aux formula-decl nil exponentiation nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (neg_times_le formula-decl nil real_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (expt def-decl "real" exponentiation nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (convex? const-decl "bool" convex_functions nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil))
 (power_of_strictly_convex_TCC1 0
  (power_of_strictly_convex_TCC1-1 nil 3465301524
   ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)
    (strictly_convex? const-decl "bool" convex_functions nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil))
 (power_of_strictly_convex 0
  (power_of_strictly_convex-3 nil 3465301633
   ("" (induct "k")
    (("1" (skeep)
      (("1" (expand "^")
        (("1" (expand "expt")
          (("1" (expand "expt")
            (("1" (expand "strictly_convex?") (("1" (propax) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skeep)
      (("2" (skeep)
        (("2" (inst - "f")
          (("2" (expand "^")
            (("2" (expand "expt" +)
              (("2" (name "h" "LAMBDA (x): expt(f(x),1+j)")
                (("2"
                  (case-replace
                   "(LAMBDA (x): f(x) * expt(f(x), 1+j)) = f*h")
                  (("1" (hide -1)
                    (("1" (assert)
                      (("1" (replace -4)
                        (("1" (replace -1)
                          (("1" (label "hname" -1)
                            (("1" (label "hconv" -2)
                              (("1"
                                (label "fconv" -3)
                                (("1"
                                  (label "ge0" -4)
                                  (("1"
                                    (label "final" 1)
                                    (("1"
                                      (case "forall (x): h(x) >= 0")
                                      (("1"
                                        (label "hge0" -1)
                                        (("1"
                                          (expand "strictly_convex?")
                                          (("1"
                                            (skeep)
                                            (("1"
                                              (inst - "x" "y" "t")
                                              (("1"
                                                (inst - "x" "y" "t")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "*" +)
                                                    (("1"
                                                      (copy "ge0")
                                                      (("1"
                                                        (copy "hge0")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "t*x-t*y+y")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "t*x-t*y+y")
                                                            (("1"
                                                              (mult-ineq
                                                               -5
                                                               -6)
                                                              (("1"
                                                                (hide
                                                                 -2)
                                                                (("1"
                                                                  (hide
                                                                   -2)
                                                                  (("1"
                                                                    (case
                                                                     "(t - t * t) * (h(x) - h(y)) * (f(y) - f(x)) <= 0")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (name
                                                                       "X"
                                                                       "(t-t*t)")
                                                                      (("2"
                                                                        (label
                                                                         "Xname"
                                                                         -1)
                                                                        (("2"
                                                                          (name
                                                                           "Y"
                                                                           "(h(x) - h(y))")
                                                                          (("2"
                                                                            (label
                                                                             "Yname"
                                                                             -1)
                                                                            (("2"
                                                                              (name
                                                                               "Z"
                                                                               "(f(y) - f(x))")
                                                                              (("2"
                                                                                (label
                                                                                 "Zname"
                                                                                 -1)
                                                                                (("2"
                                                                                  (replace
                                                                                   "Xname")
                                                                                  (("2"
                                                                                    (replace
                                                                                     "Yname")
                                                                                    (("2"
                                                                                      (replace
                                                                                       "Zname")
                                                                                      (("2"
                                                                                        (lemma
                                                                                         "neg_times_le")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "X"
                                                                                           "Y*Z")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (split)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     "Xname"
                                                                                                     +
                                                                                                     rl)
                                                                                                    (("1"
                                                                                                      (both-sides
                                                                                                       "+"
                                                                                                       "t*t"
                                                                                                       1)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (div-by
                                                                                                           1
                                                                                                           "t")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (case
                                                                                                     "forall (xr,yr: real): f(xr) >= f(yr) IFF h(xr) >= h(yr)")
                                                                                                    (("1"
                                                                                                      (inst-cp
                                                                                                       -1
                                                                                                       "x"
                                                                                                       "y")
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "y"
                                                                                                         "x")
                                                                                                        (("1"
                                                                                                          (case
                                                                                                           "Y>= 0")
                                                                                                          (("1"
                                                                                                            (label
                                                                                                             "Ycase"
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "Z<=0")
                                                                                                              (("1"
                                                                                                                (lemma
                                                                                                                 "neg_times_le")
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "Y"
                                                                                                                   "Z")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (case
                                                                                                             "Y<= 0")
                                                                                                            (("1"
                                                                                                              (label
                                                                                                               "Ycase"
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (case
                                                                                                                 "Z>=0")
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "neg_times_le")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "Y"
                                                                                                                     "Z")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       (2
                                                                                                        3
                                                                                                        4
                                                                                                        5
                                                                                                        6))
                                                                                                      (("2"
                                                                                                        (skeep)
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "f(yr) > 0 AND f(xr) > 0")
                                                                                                          (("1"
                                                                                                            (flatten)
                                                                                                            (("1"
                                                                                                              (lemma
                                                                                                               "both_sides_expt_pos_ge")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "1+j"
                                                                                                                 "f(xr)"
                                                                                                                 "f(yr)")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "^"
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (replace
                                                                                                                       "hname"
                                                                                                                       +
                                                                                                                       rl)
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil)
                                                                                                                 ("3"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (case
                                                                                                             "f(yr) = 0 or f(xr) = 0")
                                                                                                            (("1"
                                                                                                              (inst-cp
                                                                                                               "ge0"
                                                                                                               "xr")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 "ge0"
                                                                                                                 "yr")
                                                                                                                (("1"
                                                                                                                  (split
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (replace
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (replace
                                                                                                                       "hname"
                                                                                                                       +
                                                                                                                       rl)
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "expt"
                                                                                                                           2
                                                                                                                           2)
                                                                                                                          (("1"
                                                                                                                            (replace
                                                                                                                             -1)
                                                                                                                            (("1"
                                                                                                                              (lemma
                                                                                                                               "nnreal_expt")
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "1+j"
                                                                                                                                 "f(xr)")
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (replace
                                                                                                                     -1)
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (replace
                                                                                                                         "hname"
                                                                                                                         +
                                                                                                                         rl)
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (replace
                                                                                                                             -1)
                                                                                                                            (("2"
                                                                                                                              (expand
                                                                                                                               "expt"
                                                                                                                               1
                                                                                                                               1)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (case
                                                                                                                                   "f(yr) = 0")
                                                                                                                                  (("1"
                                                                                                                                    (replace
                                                                                                                                     -1)
                                                                                                                                    (("1"
                                                                                                                                      (expand
                                                                                                                                       "expt"
                                                                                                                                       1
                                                                                                                                       2)
                                                                                                                                      (("1"
                                                                                                                                        (propax)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (lemma
                                                                                                                                       "nnreal_expt")
                                                                                                                                      (("2"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "1+j"
                                                                                                                                         "f(yr)")
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          (("2"
                                                                                                                                            (lemma
                                                                                                                                             "expt_pos_aux")
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "1+j"
                                                                                                                                               "f(yr)")
                                                                                                                                              (("2"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (flatten)
                                                                                                              (("2"
                                                                                                                (inst-cp
                                                                                                                 "ge0"
                                                                                                                 "xr")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   "ge0"
                                                                                                                   "yr")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skeep)
                                        (("2"
                                          (inst - "x")
                                          (("2"
                                            (replace "hname" + rl)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (lemma "nnreal_expt")
                                                (("2"
                                                  (inst - "1+j" "f(x)")
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (replace -1 + rl)
                    (("2" (expand "*" +) (("2" (propax) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((* const-decl "[T -> real]" real_fun_ops nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (< const-decl "bool" reals nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (lt_times_lt_any1 formula-decl nil extra_real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (both_sides_plus_le1 formula-decl nil real_props nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (div_simp formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (times_div_cancel1 formula-decl nil extra_real_props nil)
    (both_sides_expt_pos_ge formula-decl nil exponentiation nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (yr skolem-const-decl "real" convex_functions nil)
    (xr skolem-const-decl "real" convex_functions nil)
    (f skolem-const-decl "[real -> real]" convex_functions nil)
    (nnreal_expt judgement-tcc nil exponentiation nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnreal type-eq-decl nil real_types nil)
    (expt_pos_aux formula-decl nil exponentiation nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (neg_times_le formula-decl nil real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (<= const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (expt def-decl "real" exponentiation nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (strictly_convex? const-decl "bool" convex_functions nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (power_of_strictly_convex-2 nil 3465301614
   ("" (induct "k")
    (("1" (skeep)
      (("1" (expand "^")
        (("1" (expand "expt")
          (("1" (expand "convex?" 1) (("1" (propax) nil)))))))))
     ("2" (skeep)
      (("2" (skeep)
        (("2" (inst - "f")
          (("2" (expand "^")
            (("2" (expand "expt" +)
              (("2" (name "h" "LAMBDA (x): expt(f(x),1+j)")
                (("2"
                  (case-replace
                   "(LAMBDA (x): f(x) * expt(f(x), 1+j)) = f*h")
                  (("1" (hide -1)
                    (("1" (assert)
                      (("1" (replace -4)
                        (("1" (replace -1)
                          (("1" (label "hname" -1)
                            (("1" (label "hconv" -2)
                              (("1"
                                (label "fconv" -3)
                                (("1"
                                  (label "ge0" -4)
                                  (("1"
                                    (label "final" 1)
                                    (("1"
                                      (case "forall (x): h(x) >= 0")
                                      (("1"
                                        (label "hge0" -1)
                                        (("1"
                                          (case "1+j > 0")
                                          (("1"
                                            (label "1+jgt0" -1)
                                            (("1"
                                              (expand "convex?")
                                              (("1"
                                                (skeep)
                                                (("1"
                                                  (inst - "x" "y" "t")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "x"
                                                     "y"
                                                     "t")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand "*" +)
                                                        (("1"
                                                          (copy "ge0")
                                                          (("1"
                                                            (copy
                                                             "hge0")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "t*x-t*y+y")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "t*x-t*y+y")
                                                                (("1"
                                                                  (mult-ineq
                                                                   -6
                                                                   -7)
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (hide
                                                                       -2)
                                                                      (("1"
                                                                        (case
                                                                         "(t - t * t) * (h(x) - h(y)) * (f(y) - f(x)) <= 0")
                                                                        (("1"
                                                                          (assert)
                                                                          nil)
                                                                         ("2"
                                                                          (name
                                                                           "X"
                                                                           "(t-t*t)")
                                                                          (("2"
                                                                            (label
                                                                             "Xname"
                                                                             -1)
                                                                            (("2"
                                                                              (name
                                                                               "Y"
                                                                               "(h(x) - h(y))")
                                                                              (("2"
                                                                                (label
                                                                                 "Yname"
                                                                                 -1)
                                                                                (("2"
                                                                                  (name
                                                                                   "Z"
                                                                                   "(f(y) - f(x))")
                                                                                  (("2"
                                                                                    (label
                                                                                     "Zname"
                                                                                     -1)
                                                                                    (("2"
                                                                                      (replace
                                                                                       "Xname")
                                                                                      (("2"
                                                                                        (replace
                                                                                         "Yname")
                                                                                        (("2"
                                                                                          (replace
                                                                                           "Zname")
--> --------------------

--> maximum size reached

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

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

¤ Dauer der Verarbeitung: 1.113 Sekunden  (vorverarbeitet am  2026-05-02) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


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