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


SSL ln_approx.prf

  Interaktion und
PortierbarkeitLisp
 

(ln_approx
 (ln_le2_bounds_TCC1 0
  (ln_le2_bounds_TCC1-1 nil 3296313954 ("" (grind) 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_plus_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)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (ln_le2_bounds 0
  (ln_le2_bounds-1 nil 3296309969
   ("" (expand "ln_le2_lb")
    (("" (expand "ln_le2_ub")
      (("" (skosimp*)
        (("" (lift-if)
          (("" (prop)
            (("1" (assertnil nil) ("2" (assertnil nil)
             ("3" (lemma "ln_taylors" ("xgm1" "x!1" "n" "2*n!1"))
              (("1" (skosimp*)
                (("1" (typepred "c!1")
                  (("1" (assert)
                    (("1" (hide -1 -3 -4)
                      (("1" (replace -2)
                        (("1" (hide -2)
                          (("1" (flatten)
                            (("1"
                              (lemma "expt_plus"
                               ("n0x" "x!1/-c!1" "i" "1" "j" "2*n!1"))
                              (("1"
                                (rewrite "expt_x1")
                                (("1"
                                  (lemma
                                   "expt_times"
                                   ("n0x"
                                    "x!1/-c!1"
                                    "i"
                                    "2"
                                    "j"
                                    "n!1"))
                                  (("1"
                                    (case "(x!1 / -c!1) ^ 2 > 0")
                                    (("1"
                                      (lemma
                                       "expt_pos"
                                       ("px"
                                        "(x!1 / -c!1) ^ 2"
                                        "i"
                                        "n!1"))
                                      (("1"
                                        (case
                                         "((x!1 / -c!1) ^ (1 + 2 * n!1)) / (1 + 2 * n!1) < 0")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (hide 2)
                                          (("2"
                                            (rewrite
                                             "div_mult_pos_lt1"
                                             1)
                                            (("2"
                                              (lemma
                                               "posreal_times_posreal_is_posreal"
                                               ("px"
                                                "x!1"
                                                "py"
                                                "(x!1 / -c!1) ^ (2 * n!1)"))
                                              (("1"
                                                (lemma
                                                 "both_sides_div_neg_lt1"
                                                 ("nz" "-c!1"))
                                                (("1"
                                                  (inst
                                                   -
                                                   "x!1 * (x!1 / -c!1) ^ (2 * n!1)"
                                                   "0")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (replace -6)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2" (assertnil nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (lemma
                                         "both_sides_div_neg_lt1"
                                         ("nz"
                                          "-c!1"
                                          "y"
                                          "0"
                                          "x"
                                          "x!1"))
                                        (("1"
                                          (lemma
                                           "negreal_times_negreal_is_posreal"
                                           ("nx"
                                            "x!1/-c!1"
                                            "ny"
                                            "x!1/-c!1"))
                                          (("1"
                                            (assert)
                                            (("1"
                                              (expand "^" 1)
                                              (("1"
                                                (expand "expt")
                                                (("1"
                                                  (expand "expt")
                                                  (("1"
                                                    (expand "expt")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil)
                                         ("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assertnil nil))
              nil)
             ("4" (lemma "ln_taylors" ("xgm1" "x!1" "n" "1+2*n!1"))
              (("1" (skosimp*)
                (("1" (replace -1)
                  (("1" (typepred "c!1")
                    (("1" (assert)
                      (("1" (hide -1 -3 -4)
                        (("1" (flatten)
                          (("1" (hide -3)
                            (("1"
                              (case "0<((x!1 / -c!1) ^ (2 + 2 * n!1)) / (2 + 2 * n!1)")
                              (("1" (assertnil nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (lemma
                                   "expt_times"
                                   ("n0x"
                                    "x!1/-c!1"
                                    "i"
                                    "2"
                                    "j"
                                    "1+n!1"))
                                  (("2"
                                    (lemma
                                     "expt_pos"
                                     ("px"
                                      "(x!1 / -c!1) ^ 2"
                                      "i"
                                      "1+n!1"))
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "posreal_div_posreal_is_posreal"
                                         ("px"
                                          "(x!1 / -c!1) ^ (2 + 2 * n!1)"
                                          "py"
                                          "2 + 2*n!1"))
                                        (("1" (assertnil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide -1 2)
                                      (("2"
                                        (lemma
                                         "both_sides_div_neg_lt1"
                                         ("nz"
                                          "-c!1"
                                          "y"
                                          "0"
                                          "x"
                                          "x!1"))
                                        (("1"
                                          (assert)
                                          (("1"
                                            (lemma
                                             "negreal_times_negreal_is_posreal"
                                             ("nx"
                                              "x!1/-c!1"
                                              "ny"
                                              "x!1/-c!1"))
                                            (("1"
                                              (expand "^")
                                              (("1"
                                                (expand "expt")
                                                (("1"
                                                  (expand "expt")
                                                  (("1"
                                                    (expand "expt")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assertnil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ln_le2_ub const-decl "real" ln_approx nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posreal_div_posreal_is_posreal judgement-tcc nil real_types nil)
    (Gt_m1 type-eq-decl nil ln_series nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (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)
    (ln_taylors formula-decl nil ln_series 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (between type-eq-decl nil taylors "analysis/")
    (expt_plus formula-decl nil exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (expt_times formula-decl nil exponentiation nil)
    (negreal_times_negreal_is_posreal judgement-tcc nil real_types nil)
    (expt def-decl "real" exponentiation nil)
    (expt_pos formula-decl nil exponentiation nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (negreal nonempty-type-eq-decl nil real_types nil)
    (nonpos_real nonempty-type-eq-decl nil real_types nil)
    (<= const-decl "bool" reals nil)
    (both_sides_div_neg_lt1 formula-decl nil real_props nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (expt_x1 formula-decl nil exponentiation nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props 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)
    (ln_le2_lb const-decl "real" ln_approx nil))
   shostak))
 (ln_gt1_lb_TCC1 0
  (ln_gt1_lb_TCC1-1 nil 3321024764 ("" (subtype-tcc) nil nilnil nil))
 (ln_gt1_ub_increasing 0
  (ln_gt1_ub_increasing-1 nil 3558254741
   ("" (skeep)
    (("" (expand "ln_gt1_ub")
      (("" (case "log_nat(xgt1,2)`1 <= log_nat(ygt1,2)`1")
        (("1" (case "log_nat(xgt1,2)`1 < log_nat(ygt1,2)`1")
          (("1" (hide -2)
            (("1" (copy -1)
              (("1" (case "NOT ln_le2_ub(n, 1)>0")
                (("1" (hide 2)
                  (("1" (expand "ln_le2_ub")
                    (("1" (lemma "ln_le2_bounds")
                      (("1" (inst - "n" "1")
                        (("1" (assert)
                          (("1" (flatten)
                            (("1" (expand "ln_le2_ub")
                              (("1"
                                (case "ln(2) > 0")
                                (("1" (assertnil nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (lemma "ln_le2_bounds")
                                    (("2"
                                      (inst - "6" "1")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (hide -2)
                                            (("2"
                                              (expand "ln_le2_lb")
                                              (("2"
                                                (expand "ln_estimate")
                                                (("2"
                                                  (grind :exclude "ln")
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (mult-by -2 "ln_le2_ub(n, 1)")
                  (("2" (assert)
                    (("2" (name "nx" "log_nat(xgt1,2)`1")
                      (("2" (name "sx" "log_nat(xgt1,2)`2")
                        (("2" (replace -1)
                          (("2" (replace -2)
                            (("2" (name "ny" "log_nat(ygt1,2)`1")
                              (("2"
                                (replace -1)
                                (("2"
                                  (name "sy" "log_nat(ygt1,2)`2")
                                  (("2"
                                    (replace -1)
                                    (("2"
                                      (typepred "sx")
                                      (("2"
                                        (typepred "sy")
                                        (("2"
                                          (replace -8)
                                          (("2"
                                            (replace -10)
                                            (("2"
                                              (case
                                               "ln_le2_ub(n,sx-1)<=ln_le2_ub(n,1) AND ln_le2_ub(n,0) <= ln_le2_ub(n,sy-1)")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (case "nx+1<=ny")
                                                  (("1"
                                                    (mult-by
                                                     -1
                                                     "ln_le2_ub(n,1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case
                                                         "ln_le2_ub(n,0) = 0")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (expand
                                                             "ln_le2_ub")
                                                            (("2"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "ln_le2_ub")
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lift-if)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (split +)
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (flatten)
                                                              (("2"
                                                                (lemma
                                                                 "ln_estimate_increasing_odd")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "n"
                                                                   "sx-1"
                                                                   "1")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (lift-if)
                                                      (("2"
                                                        (ground)
                                                        (("2"
                                                          (lemma
                                                           "ln_estimate_increasing_odd")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "n"
                                                             "0"
                                                             "sy-1")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (case
                                                                 "ln_estimate(0,1+2*n) = 0")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide-all-but
                                                                   1)
                                                                  (("2"
                                                                    (expand
                                                                     "ln_estimate")
                                                                    (("2"
                                                                      (rewrite
                                                                       "sigma_restrict_eq_0")
                                                                      (("1"
                                                                        (hide
                                                                         2)
                                                                        (("1"
                                                                          (skosimp*)
                                                                          (("1"
                                                                            (lift-if)
                                                                            (("1"
                                                                              (ground)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         2)
                                                                        (("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)
           ("2" (case "log_nat(xgt1,2)`1 = log_nat(ygt1,2)`1")
            (("1" (replace -1 :dir rl)
              (("1" (case "log_nat(xgt1,2)`2 <= log_nat(ygt1,2)`2")
                (("1" (expand "ln_le2_ub")
                  (("1" (assert)
                    (("1" (lemma "ln_estimate_increasing_odd")
                      (("1"
                        (inst - "n" "log_nat(xgt1, 2)`2 - 1"
                         "log_nat(ygt1, 2)`2 - 1")
                        (("1" (assert)
                          (("1" (case "ln_estimate(0,1+2*n) = 0")
                            (("1" (assert)
                              (("1"
                                (lift-if)
                                (("1"
                                  (assert)
                                  (("1"
                                    (lift-if)
                                    (("1" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide 2)
                              (("2"
                                (hide-all-but 1)
                                (("2"
                                  (expand "ln_estimate")
                                  (("2"
                                    (rewrite "sigma_restrict_eq_0")
                                    (("1"
                                      (hide 2)
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (lift-if)
                                          (("1" (ground) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assert)
                  (("2" (hide (2 3))
                    (("2" (hide -2)
                      (("2" (typepred "log_nat(xgt1,2)`2")
                        (("2" (typepred "log_nat(ygt1,2)`2")
                          (("2" (replace -7 :dir rl)
                            (("2" (mult-by 1 "2^log_nat(xgt1,2)`1")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (typepred "log_nat(xgt1,2)`2")
            (("2" (typepred "log_nat(ygt1,2)`2")
              (("2" (assert)
                (("2" (copy -7)
                  (("2" (replace -7 -1)
                    (("2" (replace -4 -1)
                      (("2" (mult-by -1 "2^(-log_nat(ygt1,2)`1)")
                        (("2" (assert)
                          (("2" (lemma "expt_plus")
                            (("2" (rewrite -1 :dir rl)
                              (("2"
                                (rewrite -1 :dir rl)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (mult-by -1 "1/log_nat(xgt1,2)`2")
                                    (("1"
                                      (case
                                       "log_nat(ygt1,2)`2/log_nat(xgt1,2)`2 < 2")
                                      (("1"
                                        (case
                                         "FORALL (nn:nat): 2^(nn+1) >= 2")
                                        (("1"
                                          (inst
                                           -
                                           "(-log_nat(ygt1, 2)`1) + log_nat(xgt1, 2)`1-1")
                                          (("1" (assertnil nil))
                                          nil)
                                         ("2"
                                          (hide-all-but 1)
                                          (("2"
                                            (induct "nn")
                                            (("1" (grind) nil nil)
                                             ("2"
                                              (skeep)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "^")
                                                  (("2"
                                                    (expand "expt" +)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2" (cross-mult 1) nil nil))
                                      nil)
                                     ("2" (cross-mult 1) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_exp application-judgement "posint" exponentiation nil)
    (ln_gt1_ub const-decl "real" ln_approx nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nzreal_times_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (xgt1 skolem-const-decl "{x: posreal | x > 1}" ln_approx nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (expt_plus formula-decl nil exponentiation nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (posrat_exp application-judgement "posrat" exponentiation nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (n skolem-const-decl "nat" ln_approx nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (minus_even_is_even application-judgement "even_int" integers nil)
    (zero_hat formula-decl nil exponent_props "reals/")
    (ln_estimate_increasing_odd formula-decl nil ln_series nil)
    (ln_le2_bounds formula-decl nil ln_approx 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)
    (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)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ln_le2_lb const-decl "real" ln_approx nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_expt application-judgement "int" exponentiation nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (sigma def-decl "real" sigma "reals/")
    (expt def-decl "real" exponentiation nil)
    (ln_estimate const-decl "real" ln_series nil)
    (ln const-decl "real" ln_exp nil)
    (ln_le2_ub const-decl "real" ln_approx nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (<= const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (above nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (^ const-decl "real" exponentiation nil)
    (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]" log_nat
     "reals/")
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil))
   shostak))
 (ln_gt1_lb_increasing 0
  (ln_gt1_lb_increasing-1 nil 3558280348
   ("" (skeep)
    (("" (case "n = 0")
      (("1" (replace -1) (("1" (grind) nil nil)) nil)
       ("2" (label "npos" 1)
        (("2" (hide "npos")
          (("2" (expand "ln_gt1_lb")
            (("2" (case "log_nat(xgt1,2)`1 <= log_nat(ygt1,2)`1")
              (("1" (case "log_nat(xgt1,2)`1 < log_nat(ygt1,2)`1")
                (("1" (hide -2)
                  (("1" (copy -1)
                    (("1" (case "NOT ln_le2_lb(n, 1)>0")
                      (("1" (hide 2)
                        (("1" (lemma "ln_estimate_error_bound")
                          (("1" (expand "ln_le2_lb")
                            (("1" (inst - "2*n" "1")
                              (("1"
                                (assert)
                                (("1"
                                  (case "n > 0")
                                  (("1"
                                    (case "ln(2) >1/(1+2*n)")
                                    (("1"
                                      (hide (-4 -5))
                                      (("1"
                                        (grind
                                         :exclude
                                         ("ln" "ln_estimate"))
                                        nil
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but (-1 1))
                                      (("2"
                                        (case
                                         "ln(2) > 1/3 AND FORALL (k:nat): 1/(1+2*(k+1)) <= 1/3")
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (inst - "n-1")
                                            (("1" (assertnil nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (split)
                                          (("1"
                                            (hide 2)
                                            (("1"
                                              (hide-all-but 1)
                                              (("1"
                                                (lemma "ln_le2_bounds")
                                                (("1"
                                                  (inst - "6" "1")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (hide -2)
                                                        (("1"
                                                          (expand
                                                           "ln_le2_lb")
                                                          (("1"
                                                            (expand
                                                             "ln_estimate")
                                                            (("1"
                                                              (grind
                                                               :exclude
                                                               "ln")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide-all-but 1)
                                            (("2"
                                              (skeep)
                                              (("2"
                                                (cross-mult 1)
                                                nil
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (reveal "npos")
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (mult-by -2 "ln_le2_lb(n, 1)")
                        (("2" (assert)
                          (("2" (name "nx" "log_nat(xgt1,2)`1")
                            (("2" (name "sx" "log_nat(xgt1,2)`2")
                              (("2"
                                (replace -1)
                                (("2"
                                  (replace -2)
                                  (("2"
                                    (name "ny" "log_nat(ygt1,2)`1")
                                    (("2"
                                      (replace -1)
                                      (("2"
                                        (name "sy" "log_nat(ygt1,2)`2")
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (typepred "sx")
                                            (("2"
                                              (typepred "sy")
                                              (("2"
                                                (replace -8)
                                                (("2"
                                                  (replace -10)
                                                  (("2"
                                                    (case
                                                     "ln_le2_lb(n,sx-1)<=ln_le2_lb(n,1) AND ln_le2_lb(n,0) <= ln_le2_lb(n,sy-1)")
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (case
                                                         "nx+1<=ny")
                                                        (("1"
                                                          (mult-by
                                                           -1
                                                           "ln_le2_lb(n,1)")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (case
                                                               "ln_le2_lb(n,0) = 0")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (expand
                                                                   "ln_le2_lb")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (expand
                                                         "ln_le2_lb")
                                                        (("2"
                                                          (split)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (lift-if)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (split
                                                                   +)
                                                                  (("1"
                                                                    (propax)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (flatten)
                                                                    (("2"
                                                                      (lemma
                                                                       "ln_estimate_increasing_even")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "n"
                                                                         "sx-1"
                                                                         "1")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("2"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (expand
                                                                           "abs")
                                                                          (("3"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (lift-if)
                                                            (("2"
                                                              (ground)
                                                              (("2"
                                                                (lemma
                                                                 "ln_estimate_increasing_even")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "n"
                                                                   "0"
                                                                   "sy-1")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (case
                                                                       "ln_estimate(0,2*n) = 0")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil)
                                                                       ("2"
                                                                        (hide-all-but
                                                                         1)
                                                                        (("2"
                                                                          (expand
                                                                           "ln_estimate")
                                                                          (("2"
                                                                            (rewrite
                                                                             "sigma_restrict_eq_0")
                                                                            (("1"
                                                                              (hide
                                                                               2)
                                                                              (("1"
                                                                                (skosimp*)
                                                                                (("1"
                                                                                  (lift-if)
                                                                                  (("1"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (grind)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "abs")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("3"
                                                                    (assert)
                                                                    (("3"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("3"
                                                                        (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)
                 ("2" (case "log_nat(xgt1,2)`1 = log_nat(ygt1,2)`1")
                  (("1" (replace -1 :dir rl)
                    (("1"
                      (case "log_nat(xgt1,2)`2 <= log_nat(ygt1,2)`2")
                      (("1" (expand "ln_le2_lb")
                        (("1" (assert)
                          (("1" (lemma "ln_estimate_increasing_even")
                            (("1"
                              (inst - "n" "log_nat(xgt1, 2)`2 - 1"
                               "log_nat(ygt1, 2)`2 - 1")
                              (("1"
                                (assert)
                                (("1"
                                  (case "ln_estimate(0,2*n) = 0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (lift-if)
                                          (("1" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (hide-all-but 1)
                                      (("2"
                                        (expand "ln_estimate")
                                        (("2"
                                          (rewrite
                                           "sigma_restrict_eq_0")
                                          (("1"
                                            (hide 2)
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (ground)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (assert)
                                (("2"
                                  (hide (2 3))
                                  (("2"
                                    (expand "abs")
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil)
                               ("3"
                                (expand "abs")
                                (("3" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (hide (2 3))
                          (("2" (hide -2)
                            (("2" (typepred "log_nat(xgt1,2)`2")
                              (("2"
                                (typepred "log_nat(ygt1,2)`2")
                                (("2"
                                  (replace -7 :dir rl)
                                  (("2"
                                    (mult-by 1 "2^log_nat(xgt1,2)`1")
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (typepred "log_nat(xgt1,2)`2")
                  (("2" (typepred "log_nat(ygt1,2)`2")
                    (("2" (assert)
                      (("2" (copy -7)
                        (("2" (replace -7 -1)
                          (("2" (replace -4 -1)
                            (("2" (mult-by -1 "2^(-log_nat(ygt1,2)`1)")
                              (("2"
                                (assert)
                                (("2"
                                  (lemma "expt_plus")
                                  (("2"
                                    (rewrite -1 :dir rl)
                                    (("2"
                                      (rewrite -1 :dir rl)
                                      (("2"
                                        (hide -1)
                                        (("2"
                                          (mult-by
                                           -1
                                           "1/log_nat(xgt1,2)`2")
                                          (("1"
                                            (case
                                             "log_nat(ygt1,2)`2/log_nat(xgt1,2)`2 < 2")
                                            (("1"
                                              (case
                                               "FORALL (nn:nat): 2^(nn+1) >= 2")
                                              (("1"
                                                (inst
                                                 -
                                                 "(-log_nat(ygt1, 2)`1) + log_nat(xgt1, 2)`1-1")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide-all-but 1)
                                                (("2"
                                                  (induct "nn")
                                                  (("1"
                                                    (grind)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skeep)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand "^")
                                                        (("2"
                                                          (expand
                                                           "expt"
                                                           +)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (cross-mult 1)
                                              nil
                                              nil))
                                            nil)
                                           ("2"
                                            (cross-mult 1)
                                            nil
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (expt def-decl "real" exponentiation nil)
    (^ const-decl "real" exponentiation nil)
    (sigma def-decl "real" sigma "reals/")
    (ln_estimate const-decl "real" ln_series nil)
    (ln_le2_lb const-decl "real" ln_approx nil)
    (ln_gt1_lb const-decl "real" ln_approx nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (posint_exp application-judgement "posint" exponentiation nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]" log_nat
     "reals/")
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (above nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil) (<= const-decl "bool" reals nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (ln_estimate_error_bound formula-decl nil ln_series 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)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_expt application-judgement "int" exponentiation nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (ln_le2_bounds formula-decl nil ln_approx nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (times_div2 formula-decl nil real_props nil)
    (odd_times_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (n skolem-const-decl "nat" ln_approx nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (ln const-decl "real" ln_exp nil)
    (expt_1i formula-decl nil exponentiation nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (ln_estimate_increasing_even formula-decl nil ln_series nil)
    (absle1 type-eq-decl nil ln_series nil)
    (sx skolem-const-decl
     "{y | y < 2 AND xgt1 = 2 ^ log_nat(xgt1, 2)`1 * y}" ln_approx nil)
    (xgt1 skolem-const-decl "{x: posreal | x > 1}" ln_approx nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (nzrat_abs_is_pos application-judgement "{r: posrat | r >= q}"
     real_defs nil)
    (ygt1 skolem-const-decl "{x: posreal | x > 1}" ln_approx nil)
    (sy skolem-const-decl
     "{y | y < 2 AND ygt1 = 2 ^ log_nat(ygt1, 2)`1 * y}" ln_approx nil)
    (zero_hat formula-decl nil exponent_props "reals/")
    (minus_even_is_even application-judgement "even_int" integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (posrat_exp application-judgement "posrat" exponentiation nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (expt_plus formula-decl nil exponentiation nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (nzreal_times_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil))
   nil))
 (ln_gt1_bounds_TCC1 0
  (ln_gt1_bounds_TCC1-1 nil 3296313957 ("" (grind) 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_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))
   shostak))
 (ln_gt1_bounds_TCC2 0
  (ln_gt1_bounds_TCC2-1 nil 3296313957 ("" (grind) 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_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))
   shostak))
 (ln_gt1_bounds 0
  (ln_gt1_bounds-2 nil 3321025214
   ("" (skosimp*)
    (("" (expand "ln_gt1_lb")
      (("" (expand "ln_gt1_ub")
        (("" (typepred "log_nat(x!1,2)`2")
          (("1" (name-replace "m" "log_nat(x!1,2)`1")
            (("1" (name-replace "y" "log_nat(x!1,2)`2")
              (("1" (replaces -3)
                (("1" (rewrite "ln_mult")
                  (("1" (rewrite "ln_expt")
                    (("1" (lemma "ln_le2_bounds")
                      (("1" (inst -1 "n!1" "1")
                        (("1" (assert)
                          (("1" (flatten)
                            (("1" (case "m=0")
                              (("1"
                                (replaces -1)
                                (("1"
                                  (rewrite "expt_x0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lemma "ln_le2_bounds")
                                      (("1"
                                        (inst -1 "n!1" "y-1")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (mult-by -1 "m")
                                (("2"
                                  (mult-by -2 "m")
                                  (("2"
                                    (case "y=1")
                                    (("1"
                                      (replaces -1)
                                      (("1"
                                        (rewrite "ln_1")
                                        (("1"
                                          (expand "ln_le2_lb")
                                          (("1"
                                            (expand "ln_le2_ub")
                                            (("1" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (lemma "ln_le2_bounds")
                                      (("2"
                                        (inst -1 "n!1" "y-1")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (flatten)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_exp application-judgement "posint" exponentiation nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (ln_gt1_lb const-decl "real" ln_approx nil)
    (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]" log_nat
     "reals/")
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (above nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (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)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (ln_mult formula-decl nil ln_exp nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (ln_le2_bounds formula-decl nil ln_approx nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (ln_le2_ub const-decl "real" ln_approx nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers 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)
    (ln_1 formula-decl nil ln_exp nil)
    (m skolem-const-decl "nat" ln_approx nil)
    (ln const-decl "real" ln_exp nil)
    (ln_le2_lb const-decl "real" ln_approx nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (ln_expt formula-decl nil ln_exp nil)
    (integer nonempty-type-from-decl nil integers nil)
    (ln_gt1_ub const-decl "real" ln_approx nil))
   nil))
 (ln_lb_TCC1 0
  (ln_lb_TCC1-1 nil 3296503304
   ("" (skosimp)
    (("" (rewrite "div_mult_pos_gt1") (("" (assertnil nil)) nil))
    nil)
   ((div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (ln_lb_TCC2 0
  (ln_lb_TCC2-1 nil 3296503304 ("" (grind) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (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_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))
   shostak))
 (ln_lb_increasing 0
  (ln_lb_increasing-1 nil 3558342713
   ("" (skeep)
    (("" (expand "ln_lb")
      ((""
        (case "FORALL (xx:posreal): (xx>1 IMPLIES ln_gt1_ub(n, xx) >= 0)")
        (("1" (case "px<1 IFF 1/px >1")
          (("1" (case "py<1 IFF 1/py >1")
            (("1" (case "1/py <= 1/px")
              (("1" (inst-cp - "px")
                (("1" (inst-cp - "py")
                  (("1" (inst-cp - "1/px")
                    (("1" (inst - "1/py")
                      (("1"
                        (case "FORALL (xx:posreal): (xx>1 IMPLIES ln_gt1_lb(n, xx) >= 0)")
                        (("1" (inst-cp - "px")
                          (("1" (inst-cp - "py")
                            (("1" (inst-cp - "1/px")
                              (("1"
                                (inst - "1/py")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (lift-if)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (split +)
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (split +)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "ln_gt1_ub_increasing")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "n"
                                                           "1/py"
                                                           "1/px")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split +)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (flatten)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split +)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (split +)
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (flatten)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (lemma
                                                           "ln_gt1_lb_increasing")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "n"
                                                             "px"
                                                             "py")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide-all-but 1)
                          (("2" (skeep)
                            (("2" (expand "ln_gt1_lb")
                              (("2"
                                (case
                                 "ln_le2_lb(n,1)>=0 AND ln_le2_lb(n,0) = 0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (mult-by -1 "log_nat(xx,2)`1")
                                    (("1"
                                      (expand "ln_le2_lb")
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (ground)
                                          (("1"
                                            (lemma
                                             "ln_estimate_increasing_even")
                                            (("1"
                                              (inst
                                               -
                                               "n"
                                               "0"
                                               "log_nat(xx, 2)`2 - 1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "ln_estimate(0, 2*n) = 0")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (expand
                                                       "ln_estimate")
                                                      (("2"
                                                        (rewrite
                                                         "sigma_restrict_eq_0")
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide-all-but 1)
                                                (("2"
                                                  (typepred
                                                   "log_nat(xx,2)`2")
                                                  (("2"
                                                    (grind
                                                     :exclude
                                                     "log_nat")
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (assert)
                                                (("3"
                                                  (expand "abs")
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (expand "ln_le2_lb")
                                    (("2"
                                      (lemma
                                       "ln_estimate_increasing_even")
                                      (("2"
                                        (inst - "n" "0" "1")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (case
                                             "ln_estimate(0, 2*n) = 0")
                                            (("1" (assertnil nil)
                                             ("2"
                                              (hide-all-but 1)
                                              (("2"
                                                (expand "ln_estimate")
                                                (("2"
                                                  (rewrite
                                                   "sigma_restrict_eq_0")
                                                  (("1"
                                                    (hide 2)
                                                    (("1"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2)
                                          (("2" (grind) nil nil))
                                          nil)
                                         ("3"
                                          (hide 2)
                                          (("3" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (cross-mult 1) (("2" (assertnil nil)) nil))
              nil)
             ("2" (hide-all-but 1)
              (("2" (ground)
                (("1" (cross-mult 1) nil nil)
                 ("2" (cross-mult -1) nil nil))
                nil))
              nil))
            nil)
           ("2" (hide-all-but 1)
            (("2" (ground)
              (("1" (cross-mult 1) nil nil)
               ("2" (cross-mult -1) nil nil))
              nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (hide-all-but 1)
            (("2" (skeep)
              (("2" (expand "ln_gt1_ub")
                (("2" (case "ln_le2_ub(n,1)>=0 AND ln_le2_ub(n,0) = 0")
                  (("1" (flatten)
                    (("1" (mult-by -1 "log_nat(xx,2)`1")
                      (("1" (expand "ln_le2_ub")
                        (("1" (lift-if)
                          (("1" (ground)
                            (("1" (lemma "ln_estimate_increasing_odd")
                              (("1"
                                (inst - "n" "0" "log_nat(xx, 2)`2 - 1")
                                (("1"
                                  (assert)
                                  (("1"
                                    (case "ln_estimate(0, 1+2*n) = 0")
                                    (("1" (assertnil nil)
                                     ("2"
                                      (hide-all-but 1)
                                      (("2"
                                        (expand "ln_estimate")
                                        (("2"
                                          (rewrite
                                           "sigma_restrict_eq_0")
                                          (("1"
                                            (hide 2)
                                            (("1" (grind) nil nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide-all-but 1)
                    (("2" (expand "ln_le2_ub")
                      (("2" (lemma "ln_estimate_increasing_odd")
                        (("2" (inst - "n" "0" "1")
                          (("2" (assert)
                            (("2" (case "ln_estimate(0, 1+2*n) = 0")
                              (("1" (assertnil nil)
                               ("2"
                                (hide-all-but 1)
                                (("2"
                                  (expand "ln_estimate")
                                  (("2"
                                    (rewrite "sigma_restrict_eq_0")
                                    (("1"
                                      (hide 2)
                                      (("1" (grind) nil nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ln_lb const-decl "real" ln_approx nil)
    (ln_le2_ub const-decl "real" ln_approx nil)
    (ln_estimate_increasing_odd formula-decl nil ln_series nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals 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)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (<= const-decl "bool" reals nil)
    (posint_exp application-judgement "posint" exponentiation nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (nzrat_abs_is_pos application-judgement "{r: posrat | r >= q}"
     real_defs 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)
    (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)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs 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)
    (xx skolem-const-decl "posreal" ln_approx nil)
    (absle1 type-eq-decl nil ln_series nil)
    (ln_estimate const-decl "real" ln_series nil)
    (subrange type-eq-decl nil integers nil)
    (zero_hat formula-decl nil exponent_props "reals/")
    (minus_even_is_even application-judgement "even_int" integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (ln_estimate_increasing_even formula-decl nil ln_series nil)
    (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]" log_nat
     "reals/")
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil integers nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (ln_le2_lb const-decl "real" ln_approx nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (ln_gt1_ub_increasing formula-decl nil ln_approx nil)
    (ln_gt1_lb_increasing formula-decl nil ln_approx nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ln_gt1_lb const-decl "real" ln_approx nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (times_div2 formula-decl nil real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types 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)
    (>= 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)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (ln_gt1_ub const-decl "real" ln_approx nil))
   shostak))
 (ln_ub_increasing 0
  (ln_ub_increasing-1 nil 3558348180
   ("" (skeep)
    (("" (expand "ln_ub")
      ((""
        (case "FORALL (xx:posreal): (xx>1 IMPLIES ln_gt1_ub(n, xx) >= 0)")
        (("1" (case "px<1 IFF 1/px >1")
          (("1" (case "py<1 IFF 1/py >1")
            (("1" (case "1/py <= 1/px")
              (("1" (inst-cp - "px")
                (("1" (inst-cp - "py")
                  (("1" (inst-cp - "1/px")
                    (("1" (inst - "1/py")
                      (("1"
                        (case "FORALL (xx:posreal): (xx>1 IMPLIES ln_gt1_lb(n, xx) >= 0)")
                        (("1" (inst-cp - "px")
                          (("1" (inst-cp - "py")
                            (("1" (inst-cp - "1/px")
                              (("1"
                                (inst - "1/py")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (lift-if)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (split +)
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (split +)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "ln_gt1_lb_increasing")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "n"
                                                           "1/py"
                                                           "1/px")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split +)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (flatten)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split +)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (split +)
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (flatten)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (lemma
                                                           "ln_gt1_ub_increasing")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "n"
                                                             "px"
                                                             "py")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide-all-but 1)
                          (("2" (skeep)
                            (("2" (expand "ln_gt1_lb")
                              (("2"
                                (case
                                 "ln_le2_lb(n,1)>=0 AND ln_le2_lb(n,0) = 0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (mult-by -1 "log_nat(xx,2)`1")
                                    (("1"
                                      (expand "ln_le2_lb")
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (ground)
                                          (("1"
                                            (lemma
                                             "ln_estimate_increasing_even")
                                            (("1"
                                              (inst
                                               -
                                               "n"
                                               "0"
                                               "log_nat(xx, 2)`2 - 1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "ln_estimate(0, 2*n) = 0")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (expand
                                                       "ln_estimate")
                                                      (("2"
                                                        (rewrite
                                                         "sigma_restrict_eq_0")
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide-all-but 1)
                                                (("2"
                                                  (typepred
                                                   "log_nat(xx,2)`2")
                                                  (("2"
                                                    (grind
                                                     :exclude
                                                     "log_nat")
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (assert)
                                                (("3"
                                                  (expand "abs")
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (expand "ln_le2_lb")
                                    (("2"
                                      (lemma
                                       "ln_estimate_increasing_even")
                                      (("2"
                                        (inst - "n" "0" "1")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (case
                                             "ln_estimate(0, 2*n) = 0")
                                            (("1" (assertnil nil)
                                             ("2"
                                              (hide-all-but 1)
                                              (("2"
                                                (expand "ln_estimate")
                                                (("2"
                                                  (rewrite
                                                   "sigma_restrict_eq_0")
                                                  (("1"
                                                    (hide 2)
                                                    (("1"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2)
                                          (("2" (grind) nil nil))
                                          nil)
                                         ("3"
                                          (hide 2)
                                          (("3" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (cross-mult 1) (("2" (assertnil nil)) nil))
              nil)
             ("2" (hide-all-but 1)
              (("2" (ground)
                (("1" (cross-mult 1) nil nil)
                 ("2" (cross-mult -1) nil nil))
                nil))
              nil))
            nil)
           ("2" (hide-all-but 1)
            (("2" (ground)
              (("1" (cross-mult 1) nil nil)
               ("2" (cross-mult -1) nil nil))
              nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (hide-all-but 1)
            (("2" (skeep)
              (("2" (expand "ln_gt1_ub")
                (("2" (case "ln_le2_ub(n,1)>=0 AND ln_le2_ub(n,0) = 0")
                  (("1" (flatten)
                    (("1" (mult-by -1 "log_nat(xx,2)`1")
                      (("1" (expand "ln_le2_ub")
                        (("1" (lift-if)
                          (("1" (ground)
                            (("1" (lemma "ln_estimate_increasing_odd")
                              (("1"
                                (inst - "n" "0" "log_nat(xx, 2)`2 - 1")
                                (("1"
                                  (assert)
                                  (("1"
                                    (case "ln_estimate(0, 1+2*n) = 0")
                                    (("1" (assertnil nil)
                                     ("2"
                                      (hide-all-but 1)
                                      (("2"
                                        (expand "ln_estimate")
                                        (("2"
                                          (rewrite
                                           "sigma_restrict_eq_0")
                                          (("1"
                                            (hide 2)
                                            (("1" (grind) nil nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide-all-but 1)
                    (("2" (expand "ln_le2_ub")
                      (("2" (lemma "ln_estimate_increasing_odd")
                        (("2" (inst - "n" "0" "1")
                          (("2" (assert)
                            (("2" (case "ln_estimate(0, 1+2*n) = 0")
                              (("1" (assertnil nil)
                               ("2"
                                (hide-all-but 1)
                                (("2"
                                  (expand "ln_estimate")
                                  (("2"
                                    (rewrite "sigma_restrict_eq_0")
                                    (("1"
                                      (hide 2)
                                      (("1" (grind) nil nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ln_ub const-decl "real" ln_approx nil)
    (ln_le2_ub const-decl "real" ln_approx nil)
    (ln_estimate_increasing_odd formula-decl nil ln_series nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals 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)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (<= const-decl "bool" reals nil)
    (posint_exp application-judgement "posint" exponentiation nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (nzrat_abs_is_pos application-judgement "{r: posrat | r >= q}"
     real_defs 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)
    (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)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs 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)
    (xx skolem-const-decl "posreal" ln_approx nil)
    (absle1 type-eq-decl nil ln_series nil)
    (ln_estimate const-decl "real" ln_series nil)
    (subrange type-eq-decl nil integers nil)
    (zero_hat formula-decl nil exponent_props "reals/")
    (minus_even_is_even application-judgement "even_int" integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (ln_estimate_increasing_even formula-decl nil ln_series nil)
    (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]" log_nat
     "reals/")
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil integers nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (ln_le2_lb const-decl "real" ln_approx nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (ln_gt1_lb_increasing formula-decl nil ln_approx nil)
    (ln_gt1_ub_increasing formula-decl nil ln_approx nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ln_gt1_lb const-decl "real" ln_approx nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (times_div2 formula-decl nil real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types 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)
    (>= 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)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (ln_gt1_ub const-decl "real" ln_approx nil))
   nil))
 (ln_bounds 0
  (ln_bounds-1 nil 3296503392
   ("" (expand "ln_ub")
    (("" (expand "ln_lb")
      (("" (skosimp*)
        (("" (case-replace "px!1 < 1")
          (("1" (lemma "ln_gt1_bounds" ("x" "1/px!1" "n" "n!1"))
            (("1"
              (lemma "div_mult_pos_lt2" ("py" "px!1" "x" "1" "z" "1"))
              (("1" (assert)
                (("1" (flatten)
                  (("1" (lemma "ln_div" ("px" "1" "py" "px!1"))
                    (("1" (rewrite "ln_1")
                      (("1"
                        (lemma "both_sides_times_neg_lt1" ("nz" "-1"))
                        (("1"
                          (inst-cp - "ln(px!1)"
                           "-ln_gt1_ub(n!1, 1 / px!1)")
                          (("1"
                            (inst - "-ln_gt1_lb(n!1, 1 / px!1)"
                             "ln(px!1)")
                            (("1" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (case-replace "px!1=1")
            (("1" (rewrite "ln_1") (("1" (assertnil nil)) nil)
             ("2" (assert)
              (("2" (lemma "ln_gt1_bounds" ("n" "n!1" "x" "px!1"))
                (("2" (assert)
                  (("2" (flatten) (("2" (assertnil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ln_lb const-decl "real" ln_approx 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)
    (< const-decl "bool" reals 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)
    (div_mult_pos_lt2 formula-decl nil real_props nil)
    (ln_1 formula-decl nil ln_exp nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (ln_gt1_ub const-decl "real" ln_approx nil)
    (ln const-decl "real" ln_exp nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (ln_gt1_lb const-decl "real" ln_approx nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (negreal nonempty-type-eq-decl nil real_types nil)
    (nonpos_real nonempty-type-eq-decl nil real_types nil)
    (<= const-decl "bool" reals nil)
    (both_sides_times_neg_lt1 formula-decl nil real_props nil)
    (ln_div formula-decl nil ln_exp nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (ln_gt1_bounds formula-decl nil ln_approx nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (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 "[T, T -> boolean]" equalities nil)
    (ln_ub const-decl "real" ln_approx nil))
   shostak))
 (floor_eq_log_nat_ge_1_TCC1 0
  (floor_eq_log_nat_ge_1_TCC1-1 nil 3543148487
   ("" (subtype-tcc) nil nilnil nil))
 (floor_eq_log_nat_ge_1_TCC2 0
  (floor_eq_log_nat_ge_1_TCC2-1 nil 3543148487
   ("" (skeep)
    (("" (typepred "np")
      (("" (lemma "exp_ln")
        (("" (inst?)
          (("" (replace -4)
            (("" (rewrite "exp_0") (("" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (exp_0 formula-decl nil ln_exp nil)
    (exp_ln formula-decl nil ln_exp nil))
   nil))
 (floor_eq_log_nat_ge_1 0
  (floor_eq_log_nat_ge_1-1 nil 3543148360
   ("" (skeep)
    (("" (typepred "xp")
      (("" (typepred "np")
        (("" (hide -1)
          (("" (invoke (name "lp" "%1") (! 1 1 1))
            (("" (replace -1)
              (("" (label "lpname" -1)
                (("" (case "lp >= 0")
                  (("1" (invoke (name "mm" "%1") (! 1 1))
                    (("1" (replace -1)
                      (("1" (case "mm >= 0")
                        (("1" (label "mmname" -2)
                          (("1" (invoke (name "nn" "%1") (! 1 2))
                            (("1" (replace -1)
                              (("1"
                                (label "nnname" -1)
                                (("1"
                                  (lemma "log_nat_bounds")
                                  (("1"
                                    (case
                                     "np ^ mm <= xp AND xp < np ^ (mm + 1)")
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (replace "nnname")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (case "mm > nn")
                                              (("1"
                                                (lemma
                                                 "both_sides_expt_gt1_lt_aux")
                                                (("1"
                                                  (inst
                                                   -
                                                   "np"
                                                   "nn"
                                                   "mm-1")
                                                  (("1"
                                                    (expand "^")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (case "nn=mm-1")
                                                    (("1"
                                                      (replace -1)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (case "nn > mm")
                                                  (("1"
                                                    (lemma
                                                     "both_sides_expt_gt1_lt_aux")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "np"
                                                       "mm"
                                                       "nn-1")
                                                      (("1"
                                                        (expand "^")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide -1)
                                      (("2"
                                        (hide -1)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (lemma "floor_def")
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (replace "mmname")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (lemma
                                                     "ln_strict_increasing")
                                                    (("2"
                                                      (split +)
                                                      (("1"
                                                        (expand
                                                         "strict_increasing?")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "xp"
                                                           "np^mm")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (lemma
                                                               "ln_expt")
                                                              (("1"
                                                                (inst?)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (case
                                                                     "ln(np) > 0")
                                                                    (("1"
                                                                      (case
                                                                       "mm > lp")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil)
                                                                       ("2"
                                                                        (expand
                                                                         "lp"
                                                                         +)
                                                                        (("2"
                                                                          (cross-mult
                                                                           1)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (lemma
                                                                       "ln_gt_0")
                                                                      (("2"
                                                                        (inst?)
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (lemma
                                                         "ln_increasing")
                                                        (("2"
                                                          (expand
                                                           "increasing?")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "np^(mm+1)"
                                                             "xp")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (lemma
                                                                 "ln_expt")
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (replace
                                                                     -1)
                                                                    (("2"
                                                                      (hide
                                                                       -1)
                                                                      (("2"
                                                                        (case
                                                                         "1+mm <= lp")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (expand
                                                                           "lp"
                                                                           +)
                                                                          (("2"
                                                                            (case
                                                                             "ln(np) > 0")
                                                                            (("1"
                                                                              (cross-mult
                                                                               1)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (lemma
                                                                               "ln_gt_0")
                                                                              (("2"
                                                                                (inst?)
                                                                                (("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)
                         ("2" (assertnil nil))
                        nil))
                      nil))
                    nil)
                   ("2" (case "ln(np) > 0")
                    (("1" (expand "lp" +)
                      (("1" (cross-mult 1)
                        (("1" (lemma "ln_ge_0")
                          (("1" (inst?) (("1" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil)
                     ("2" (lemma "ln_gt_0")
                      (("2" (inst?) (("2" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (log_nat_bounds formula-decl nil log_nat "reals/")
    (ln_expt formula-decl nil ln_exp nil)
    (ln_gt_0 formula-decl nil ln_exp nil)
    (div_mult_pos_gt2 formula-decl nil extra_real_props nil)
    (np skolem-const-decl "{np: posnat | np > 1}" ln_approx nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (strict_increasing? const-decl "bool" real_fun_preds "reals/")
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (ln_increasing formula-decl nil ln_exp nil)
    (ln_strict_increasing formula-decl nil ln_exp nil)
    (floor_def formula-decl nil floor_ceil nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (lp skolem-const-decl "real" ln_approx nil)
    (mm skolem-const-decl "{i | i <= lp & lp < 1 + i}" ln_approx nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (both_sides_expt_gt1_lt_aux formula-decl nil exponentiation nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (posrat_exp application-judgement "posrat" exponentiation nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (above nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]" log_nat
     "reals/")
    (integer nonempty-type-from-decl nil integers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (floor const-decl "{i | i <= x & x < i + 1}" floor_ceil nil)
    (ln_ge_0 formula-decl nil ln_exp nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (ln const-decl "real" ln_exp nil)
    (posreal nonempty-type-eq-decl nil real_types 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 "boolean" notequal nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (posint_exp application-judgement "posint" exponentiation nil))
   nil)))


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

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

*Bot Zugriff






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge