# Proofs

proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "majority_same")
   (expand "vec2seq" + 2)
   (expand "majority_value_set")
   (expand "is_majority?")
   (case "empty?(e!1)")
   (("1"
     (prop)
     (("1"
       (invoke (case "empty?(%1)") (! -1 l 2 1))
       (("1" (use "empty_card[below(N)]") (assert))
        ("2"
         (expand "empty?")
         (skosimp*)
         (expand "member")
         (expand "uniform_nodes")
         (flatten)
         (inst?))))
      ("2"
       (use "empty_card[below(card(e!1))]")
       (assert)
       (use "empty_card[below(N)]")
       (assert)
       (expand "empty?")
       (skosimp*))))
    ("2"
     (invoke (case-replace "%1 = %2") (! 2 r 1 2) (! 2 l 1 2))
     (("1" (prop))
      ("2"
       (hide 3)
       (rewrite "card_eq_bij")
       (inst + "m(e!1)")
       (("1"
         (expand "restrict")
         (expand "bijective?")
         (prop)
         (("1"
           (expand "injective?")
           (skosimp* t)
           (expand "uniform")
           (expand "vec2seq")
           (assert)
           (typepred "m(e!1)")
           (expand "bijective?")
           (expand "injective?")
           (flatten)
           (inst - "x1!1" "x2!1")
           (assert))
          ("2"
           (expand "surjective?")
           (skosimp* t)
           (expand "uniform_nodes")
           (flatten)
           (typepred "m(e!1)")
           (("1"
             (expand "bijective?")
             (flatten)
             (expand "surjective?")
             (inst?)
             (skosimp*)
             (inst?)
             (expand "uniform")
             (expand "vec2seq")
             (assert))
            ("2" (propax))))))
        ("2"
         (skosimp* t)
         (expand "uniform")
         (expand "uniform_nodes")
         (expand "vec2seq")
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand* "majority_value_set" "majority_subset?")
   (prop)
   (invoke (then (case "%1 <= %2") (assert)) (! -1 l 2) (! 1 l 2))
   (rewrite "card_subset[below(N)]")
   (hide 3 2 -1)
   (auto-rewrite-defs)
   (assert)
   (skosimp*)
   (inst?)
   (inst?)
   (prop))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "majority_correct?")
   (skosimp*)
   (expand "majority?" -)
   (inst?)
   (rewrite "simple_majority_subset")
   (use "uniform_majority")
   (prop)
   (hide -2 2)
   (lemma "correct_uniform")
   (inst?)
   (assert)
   (inst - "sent!1" "src_set!1")
   (prop))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (use "majority_at_destination")
   (prop)
   (expand "majority_vote")
   (rewrite "majority_validity"))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "all_symmetric?")
   (skosimp*)
   (expand "majority_vote")
   (lemma "enabled_agree")
   (inst - _ "d1!1" "d2!1" _ _)
   (inst?)
   (assert)
   (replace -1 :hide? t)
   (use "agreement_generation")
   (assert)
   (expand "enabled_symmetric?")
   (expand "exact_single_denotation?")
   (skosimp*)
   (inst?)
   (expand "enabled_within?")
   (expand "subset?")
   (expand "member")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "dst_set!1")
   (hide -1)
   (expand* "empty?" "member")
   (skosimp*)
   (inst + "majority_vote(mf!1)(rcvd!1, check!1)(x!1)")
   (expand "uniform?")
   (skosimp*)
   (use "agreement_generation_alt")
   (assert))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "majority_validity")
   (inst - _ _ _ _ _ _ "v!1")
   (inst?)
   (inst?)
   (prop)
   (("1"
     (replace -1 :hide? t)
     (expand "majority_correct_element?")
     (skosimp*)
     (expand "exact_correct_denotation?")
     (inst?)
     (assert)
     (expand "uniform?")
     (inst?)
     (assert)
     (expand "enabled_within?")
     (expand "subset?")
     (expand "member")
     (inst?)
     (assert))
    ("2"
     (expand "majority_correct_element?")
     (skosimp*)
     (expand "majority_correct?")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (use "majority_at_destination")
   (assert)
   (rewrite "is_majority")
   (expand "majority_exists?")
   (expand "maj_exists")
   (inst?))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_stage
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (use "agreement_generation")
   (assert)
   (prop)
   (hide 2)
   (expand "all_symmetric?")
   (rewrite "exists_not")
   (expand "symmetric_source?")
   (inst - 0)
   (("1" (skosimp*) (inst?) (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (induct "k")
   (("1" (skosimp*) (assert))
    ("2"
     (skosimp*)
     (assert)
     (inst?)
     (inst?)
     (inst?)
     (inst?)
     (assert)
     (prop)
     (("1"
       (hide-all-but (1 -1))
       (expand "protocol")
       (skosimp*)
       (inst?)
       (assert))
      ("2"
       (hide-all-but (1 -2))
       (expand "majority_correct?")
       (skosimp*)
       (inst?)
       (assert))
      ("3"
       (hide-all-but (1 -3))
       (expand "enabled_within?")
       (skosimp*)
       (inst?)
       (assert))
      ("4"
       (hide 2)
       (expand "majority_correct?")
       (expand "enabled_within?")
       (expand "protocol")
       (inst?)
       (inst - "j!2")
       (inst?)
       (assert)
       (expand "majority_vote")
       (replace -1 :hide? t)
       (use "consensus_validity[N(j!2), N(1 + j!2), T]")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "exists_all_symmetric?")
   (expand "exists_all_symmetric?")
   (skosimp*)
   (case "EXISTS v: uniform?[N(1 + i!1), T](sent!1(1 + i!1), v)(common_check!1(1 + i!1))")
   (("1"
     (skosimp*)
     (inst?)
     (lemma "consensus_validity")
     (inst - _ _ "i!1+1" "j!1+k!1-(i!1+1)" _ _ _ _)
     (("1"
       (assert)
       (inst?)
       (inst?)
       (inst?)
       (inst?)
       (assert)
       (rewrite "majority_correct_rw")
       (prop)
       (("1"
         (hide-all-but (1 -2))
         (expand "protocol")
         (skosimp*)
         (inst?)
         (assert))
        ("2"
         (hide-all-but (1 -7))
         (expand "enabled_within?")
         (skosimp*)
         (inst?)
         (assert))))
      ("2" (assert))))
    ("2"
     (hide 2 -5)
     (expand "protocol")
     (inst?)
     (assert)
     (replace -1)
     (expand "majority_vote" +)
     (use "agreement_generation[N(i!1), N(i!1 + 1), T]")
     (assert))))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "protocol")
   (inst?)
   (assert)
   (replace -1 :hide? t)
   (expand "majority_vote")
   (use "faulty_source[N(j!1), N(1 + j!1), T]")
   (assert)
   (expand "enabled_within?")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "majority_correct?")
   (expand "enabled_within?")
   (inst?)
   (inst?)
   (assert)
   (lemma "sources_disagree[N(j!1 + 1), N(j!1 + 2), T]")
   (inst?)
   (inst?)
   (inst?)
   (assert)
   (expand "protocol")
   (inst?)
   (assert)
   (replace -1 :hide? t)
   (expand "majority_vote")
   (use "asymmetric_source[N(j!1), N(j!1 + 1), T]")
   (assert)
   (ground))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_integration
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (replace -1 :hide? t)
   (expand "protocol")
   (rewrite "majority_correct_rw")
   (use "quorum_correct_integration")
   (assert)
   (use "consensus_validity")
   (assert)
   (rewrite "majority_correct_rw")
   (expand "enabled_within?")
   (skosimp*)
   (expand "conforms")
   (use "scheduled_conform[N(i!1), N(1+i!1), T]"))


proof_type: f_proof
decl_type: formula
library: fault_tolerance
theory: majority_integration
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (replace -1 :hide? t)
   (expand "protocol")
   (expand "exists_all_symmetric?")
   (use "all_symmetric_integration")
   (assert)
   (use "agreement_generation")
   (assert)
   (expand "exists_all_symmetric?" -1)
   (prop)
   (expand "enabled_within?")
   (skosimp*)
   (expand "conforms")
   (use "scheduled_conform[N(i!1), N(1+i!1), T]"))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (judgement-tcc)
   (case-replace
    "expt(radix, Prec(b!1)) / radix=expt(radix, Prec(b!1)-1)")
   (("1" (grind-reals))
    ("2" (hide 2) (rewrite "expt_minus_aux") (rewrite "expt_x1_aux"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (judgement-tcc)
   (lemma "both_sides_expt_gt1_ge_aux")
   (inst -1 "radix" "Prec(b!1)-1" "0")
   (grind-reals)
   (rewrite "expt_x1_aux" -1)
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "^")
   (expand "Fexpt")
   (expand "FtoR")
   (lemma "mult_expt")
   (case "n = 0")
   (("1" (replace -1) (hide -) (grind))
    ("2"
     (inst - "n" _ _)
     (expand "^" - 1)
     (rewrite -1)
     (("1"
       (lemma "expt_times")
       (inst - "Fexp(f)" "n" "radix")
       (replace -1 :dir rl)
       (hide -)
       (expand "^" + 2)
       (assert))
      ("2" (flatten) (replace -1) (expand "expt") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "mod")
   (name "k" "floor(radix/i)")
   (case "k = radix/i")
   (("1"
     (expand "FDivInt")
     (replace -1 :dir rl)
     (expand "FtoR")
     (lemma "expt_plus")
     (inst - "Fexp(f)-1" "1" "radix")
     (assert))
    ("2" (assert) (replace -1) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "^^")
   (case "radix=0")
   (("1" (assert))
    ("2"
     (assert)
     (case-replace "-(ln(r) / ln(radix)) * ln(radix) = -ln(r)")
     (("1" (hide -1) (rewrite "exp_neg") (rewrite "exp_ln"))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "^")
   (case "e1 >= 0")
   (("1" (grind-reals) (rewrite "hathat_nat") (expand "^") (propax))
    ("2"
     (grind-reals)
     (lemma "hathat_diff")
     (inst -1 "radix" "-e1" "0")
     (case-replace "0--e1=e1")
     (("1"
       (rewrite -2)
       (rewrite "hathat_nat")
       (expand "^")
       (grind-reals))
      ("2" (hide -1 2 3) (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (skosimp*)
     (expand "Fcanonic?")
     (split)
     (("1"
       (case "Fnormal?(b)(Fopp(f))")
       (("1" (assert))
        ("2"
         (hide 2)
         (expand* "Fnormal?" "Fbounded?" "Fopp")
         (flatten)
         (split)
         (("1"
           (case-replace "abs(-(Fnum(f)))=abs(Fnum(f))")
           (hide -1 -2 -3 2)
           (expand "abs")
           (grind-reals))
          ("2" (propax))
          ("3"
           (case-replace "abs(radix * -(Fnum(f)))=abs(radix * Fnum(f))")
           (hide -1 -2 -3 2)
           (expand "abs")
           (grind-reals)
           (("1"
             (case "-(radix * (Fnum(f))) > 0")
             (("1" (grind-reals)) ("2" (hide -1) (cancel-by 1 "radix"))))
            ("2" (flip-ineq 2) (hide 2) (cancel-by 1 "radix"))))))))
      ("2"
       (case "Fsubnormal?(b)(Fopp(f))")
       (("1" (assert))
        ("2"
         (hide 2)
         (expand* "Fopp" "Fsubnormal?" "Fbounded?")
         (flatten)
         (split)
         (("1"
           (case-replace "abs(-(Fnum(f)))=abs(Fnum(f))")
           (hide -1 -2 -3 -4 2)
           (expand "abs")
           (grind-reals))
          ("2" (propax)) ("3" (propax))
          ("4"
           (case-replace "abs(radix * -(Fnum(f)))=abs(radix * Fnum(f))")
           (hide -1 -2 -3 -4 2)
           (expand "abs")
           (grind-reals)
           (("1" (flip-ineq -1) (cancel-by 1 "radix"))
            ("2" (flip-ineq 2) (hide 2) (cancel-by 1 "radix"))))))))))
    ("2"
     (skosimp*)
     (expand "Fcanonic?")
     (split)
     (("1"
       (case "Fnormal?(b)(f)")
       (("1" (assert))
        ("2"
         (hide 2)
         (expand* "Fnormal?" "Fopp" "Fbounded?")
         (flatten)
         (split)
         (("1"
           (case-replace "abs(Fnum(f))=abs(-(Fnum(f)))")
           (hide -1 -2 -3 2)
           (expand "abs")
           (grind-reals))
          ("2" (propax))
          ("3"
           (case-replace
            "abs(radix * (Fnum(f)))=abs(radix * -(Fnum(f)))")
           (hide -1 -2 -3 2)
           (expand "abs")
           (grind-reals)
           (("1" (flip-ineq -2) (cancel-by 1 "radix"))
            ("2" (flip-ineq 1) (cancel-by 1 "radix"))))))))
      ("2"
       (case " Fsubnormal?(b)(f)")
       (("1" (assert))
        ("2"
         (hide 2)
         (expand* "Fsubnormal?" "Fopp" "Fbounded?")
         (flatten)
         (split)
         (("1"
           (case-replace "abs(Fnum(f))=abs(-(Fnum(f)))")
           (hide -1 -2 -3 -4 2)
           (expand "abs")
           (grind-reals))
          ("2" (propax)) ("3" (propax))
          ("4"
           (case-replace
            "abs(radix * (Fnum(f)))=abs(radix * -(Fnum(f)))")
           (hide -1 -2 -3 -4 2)
           (expand "abs")
           (grind-reals)
           (("1" (flip-ineq -2) (cancel-by 1 "radix"))
            ("2" (flip-ineq 1) (cancel-by 1 "radix"))))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?")
   (split)
   (("1" (flatten)) ("2" (flatten))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fpred")
   (grind-reals)
   (("1"
     (expand "Fcanonic?" 1 1)
     (case "Fnormal?(b)((# Fnum := -(vNum(b) / radix), Fexp := 1 + Fexp(f) #))")
     (("1" (assert))
      ("2"
       (hide 2)
       (expand* "Fnormal?" "Fbounded?")
       (split)
       (("1"
         (expand "abs" 1 1)
         (lift-if)
         (split 1)
         (("1" (flatten) (real-props :simple? t) (cancel-by 1 "vNum(b)"))
          ("2" (flatten) (field 2))))
        ("2" (grind)) ("3" (grind))))
      ("3"
       (hide -1 -2 2)
       (rewrite "integers.closed_neg")
       (rewrite "radix_div_vNum"))))
    ("2"
     (hide -1 -2 1)
     (case "Fnormal?(b)((# Fnum := vNum(b) - 1, Fexp := Fexp(f) - 1 #))")
     (("1" (expand "Fcanonic?") (assert))
      ("2"
       (hide 2)
       (expand* "Fnormal?" "Fbounded?")
       (split)
       (("1" (expand "abs" 1 1) (grind-reals))
        ("2"
         (case "vNum(b) * radix - radix >=0")
         (("1"
           (expand "abs" 1 1)
           (grind-reals)
           (isolate 1 r 1)
           (case "vNum(b) >= radix")
           (("1"
             (case "vNum(b) + radix <= vNum(b) * 2")
             (("1"
               (case "vNum(b) * 2 <= vNum(b) * radix")
               (("1" (grind-reals))
                ("2" (hide -1 -2 -3 -4 2) (cancel-by 1 "vNum(b)"))))
              ("2" (hide -2 -3 2) (grind-reals))))
            ("2"
             (hide -1 -2 2)
             (case "integer_pred(vNum(b) / radix)")
             (("1"
               (case "vNum(b)>=1")
               (("1"
                 (grind-reals)
                 (lemma "div_simple")
                 (inst -1 "vNum(b)" "radix")
                 (grind-reals)
                 (cancel-by 1 "radix")
                 (grind-reals)
                 (hide 1 -3 -2 -1)
                 (case "k!1 >= 1 OR k!1 <=0")
                 (("1"
                   (split)
                   (("1" (propax))
                    ("2"
                     (case "k!1 * radix <= 0")
                     (("1" (grind-reals)) ("2" (grind-reals))))))
                  ("2" (grind-reals))))
                ("2" (assert))))
              ("2" (assert) (rewrite "radix_div_vNum"))))))
          ("2" (hide -1 2) (cancel-by 1 "radix"))))))))
    ("3"
     (flip-ineq 2)
     (case "abs(radix*(Fnum(f) - 1))< vNum(b) OR abs(radix*(Fnum(f) - 1)) >= vNum(b)")
     (("1"
       (split)
       (("1"
         (case "Fsubnormal?(b)((# Fnum := Fnum(f) - 1, Fexp := Fexp(f) #))")
         (("1" (expand "Fcanonic?") (assert))
          ("2"
           (hide 2 3)
           (expand* "Fsubnormal?" "Fbounded?")
           (split)
           (("1"
             (mult-by 1 "radix")
             (case-replace
              "abs(Fnum(f) - 1) * radix=abs(radix * (Fnum(f) - 1))")
             (("1"
               (case " vNum(b) <=vNum(b) * radix")
               (("1" (grind-reals))
                ("2"
                 (hide -1 -2 -3 -4 2)
                 (div-by 1 "vNum(b)")
                 (assert))))
              ("2"
               (hide -1 -2 -3 2)
               (rewrite "abs_mult")
               (expand "abs" 1 2)
               (grind-reals))))
            ("2"
             (case "Fbounded?(b)(f)")
             (("1" (expand "Fbounded?") (flatten))
              ("2" (rewrite "FcanonicBounded"))))
            ("3"
             (case "Fbounded?(b)(f)")
             (("1" (expand "Fbounded?") (flatten) (grind-reals))
              ("2" (rewrite "FcanonicBounded"))))
            ("4" (grind-reals))))))
        ("2"
         (case "Fnormal?(b)((# Fnum := Fnum(f) - 1, Fexp := Fexp(f) #))")
         (("1" (expand "Fcanonic?") (assert))
          ("2"
           (hide 3)
           (expand* "Fnormal?" "Fbounded?")
           (split)
           (("1"
             (case "Fbounded?(b)(f)")
             (("1"
               (expand "Fbounded?")
               (flatten)
               (hide -2 -3 -4 -5)
               (expand* "abs")
               (grind-reals))
              ("2" (rewrite "FcanonicBounded"))))
            ("2"
             (case "Fbounded?(b)(f)")
             (("1" (expand "Fbounded?") (flatten))
              ("2" (rewrite "FcanonicBounded"))))
            ("3" (hide -2 -3 2) (grind-reals))))))))
      ("2" (hide -1 -2 2 3) (grind-reals))))
    ("4"
     (case "Fbounded?(b)(f)")
     (("1"
       (expand "Fbounded?")
       (flatten)
       (split-ineq -2)
       (("1"
         (case "abs(radix*(Fnum(f) - 1))< vNum(b) OR abs(radix*(Fnum(f) - 1)) >= vNum(b)")
         (("1"
           (split)
           (("1"
             (case "Fsubnormal?(b)((# Fnum := Fnum(f) - 1, Fexp := Fexp(f) #))")
             (("1" (expand "Fcanonic?") (assert))
              ("2"
               (hide 4)
               (expand* "Fsubnormal?" "Fbounded?")
               (split)
               (("1"
                 (case " abs(Fnum(f) - 1) <= abs(radix * (Fnum(f) - 1))")
                 (("1" (grind-reals))
                  ("2"
                   (rewrite "abs_mult")
                   (expand "abs" 1 2)
                   (div-by 1 "abs(Fnum(f) - 1)")
                   (assert))))
                ("2" (grind-reals))))))
            ("2"
             (case "Fnormal?(b)((# Fnum := Fnum(f) - 1, Fexp := Fexp(f) #))")
             (("1" (expand "Fcanonic?") (assert))
              ("2"
               (hide 4)
               (expand* "Fnormal?" "Fbounded?")
               (split)
               (("1" (hide -1 -2 -4 -4 3) (expand* "abs") (grind-reals))
                ("2" (grind-reals))))))))
          ("2" (grind-reals))))
        ("2"
         (case "Fnormal?(b)((# Fnum := Fnum(f) - 1, Fexp := Fexp(f) #))")
         (("1" (expand "Fcanonic?") (assert))
          ("2"
           (hide 5)
           (case "Fnormal?(b)(f)")
           (("1"
             (expand* "Fnormal?" "Fbounded?")
             (split)
             (("1" (hide -1 -3 -4 2 4) (expand* "abs") (grind-reals))
              ("2"
               (hide -3 -4 2)
               (expand* "abs")
               (grind-reals)
               (("1"
                 (case "Fnum(f) <=0")
                 (("1" (grind-reals))
                  ("2"
                   (case "Fnum(f) < 1")
                   (("1" (grind-reals))
                    ("2"
                     (mult-by 1 "radix")
                     (hide -2 2 3 4 5 6)
                     (grind-reals))))))
                ("2"
                 (case "vNum(b) = radix * Fnum(f) OR vNum(b) < radix * Fnum(f)")
                 (("1"
                   (split)
                   (("1" (assert))
                    ("2"
                     (hide -2 1 3 4 5)
                     (div-by -1 "radix")
                     (div-by 1 "radix")
                     (case-replace
                      "(Fnum(f) * radix - radix) / radix=Fnum(f)-1")
                     (("1"
                       (hide -1)
                       (lemma "div_simple")
                       (inst -1 "vNum(b)" "radix")
                       (case "(EXISTS (k:int): vNum(b) = k * radix)")
                       (("1"
                         (skosimp*)
                         (case-replace "vNum(b) / radix=k!1")
                         (("1" (hide -1 -2 -3) (grind-reals))
                          ("2" (grind-reals))))
                        ("2" (grind-reals) (rewrite "radix_div_vNum"))))
                      ("2" (field))))))
                  ("2" (grind-reals))))))))
            ("2"
             (hide 2 4 5)
             (expand "Fcanonic?")
             (split)
             (("1" (propax))
              ("2" (expand "Fsubnormal?") (propax))))))))))
      ("2" (rewrite "FcanonicBounded"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (b: Format, x: nnreal):
                        x >= radix ^ (-dExp(b) - 1) * vNum(b) IMPLIES
                         floor(ln(x * radix / vNum(b)) / ln(radix)) =
                          log_nat(x * radix ^ (1 + dExp(b) - Prec(b)), radix)`1 - dExp(b)")
   (("1"
     (skeep)
     (inst - "b" "x")
     (("1" (assert))
      ("2"
       (expand "vNum")
       (typepred "radix^(Prec(b)-dExp(b)-1)")
       (("1" (assert)) ("2" (assert))))))
    ("2"
     (hide 2)
     (skeep)
     (expand "vNum")
     (rewrite "expt_plus" :dir rl)
     (name "yy" "x*radix^(dExp(b) - Prec(b) + 1)")
     (case "NOT yy>=1")
     (("1"
       (hide 2)
       (expand "yy" +)
       (mult-by 1 "radix ^ (Prec(b) - 1 + -dExp(b))")
       (lemma "expt_plus")
       (inst - "1 + dExp(b) - Prec(b)" "Prec(b) - 1 + -dExp(b)" "radix")
       (assert))
      ("2"
       (case "NOT x = yy*radix ^ (Prec(b) - 1 + -dExp(b))")
       (("1"
         (hide 2)
         (expand "yy" +)
         (rewrite "expt_plus" :dir rl)
         (assert))
        ("2"
         (replace -1 +)
         (rewrite "ln_div")
         (("1"
           (case "radix ^ (Prec(b) - 1 + -dExp(b)) * radix = radix ^ (Prec(b) + -dExp(b))")
           (("1"
             (replace -1)
             (hide -1)
             (rewrite "ln_mult")
             (rewrite "expt_plus" +)
             (rewrite "ln_mult")
             (assert)
             (case "(ln(radix ^ -dExp(b)) + ln(yy)) / ln(radix) = (ln(yy)/ln(radix))-dExp(b)")
             (("1"
               (replace -1)
               (hide -1)
               (lemma "floor_eq_log_nat_ge_1")
               (inst - "yy" "radix")
               (case "floor((ln(yy) / ln(radix)) - dExp(b)) = floor(ln(yy) / ln(radix)) - dExp(b)")
               (("1" (assert))
                ("2"
                 (hide-all-but 1)
                 (lemma "floor_plus_int")
                 (inst - "-dExp(b)" "ln(yy)/ln(radix)")
                 (assert))))
              ("2"
               (case "ln(radix^(-dExp(b)))/ln(radix) = -dExp(b)")
               (("1" (assert))
                ("2" (hide (2 3)) (cross-mult 1) (rewrite "ln_expt"))))))
            ("2"
             (hide 2)
             (lemma "expt_plus")
             (inst - "Prec(b)-1+-dExp(b)" "1" "radix")
             (expand "^" - 3)
             (expand "expt")
             (expand "expt")
             (assert))))
          ("2"
           (hide 2)
           (lemma "posreal_times_posreal_is_posreal")
           (inst?))))))))
    ("3"
     (hide 2)
     (skeep)
     (expand "vNum")
     (mult-by 1 "radix ^ (Prec(b) - 1 + -dExp(b))")
     (lemma "expt_plus")
     (inst - "1 + dExp(b) - Prec(b)" "Prec(b) - 1 + -dExp(b)" "radix")
     (assert)
     (replace -1 :dir rl)
     (lemma "expt_plus")
     (inst - "Prec(b)" "-dExp(b)-1" "radix")
     (assert))
    ("4" (hide 2) (skeep) (assert))
    ("5"
     (hide 2)
     (skeep)
     (assert)
     (lemma "exp_ln")
     (inst?)
     (replace -3)
     (assert))
    ("6"
     (hide 2)
     (skeep)
     (cross-mult 1)
     (assert)
     (lemma "posreal_times_posreal_is_posreal")
     (inst?)
     (assert))
    ("7" (hide 2) (skeep) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (decompose-equality)
   (decompose-equality)
   (expand "RND_aux")
   (expand "RND_aux_alt")
   (lift-if)
   (ground)
   (lemma "RND_log_compute")
   (inst - "x!1" "x!2")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "0 <= e1")
   (("1"
     (case "e1 <= 0")
     (("1" (grind))
      ("2" (rewrite "Exp_increq_2") (rewrite "expt_x0") (assert))))
    ("2" (rewrite "Exp_increq_2") (rewrite "expt_x0") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "e1 <= e2")
   (("1"
     (case "e2 <= e1")
     (("1" (grind)) ("2" (rewrite "Exp_increq_2"))))
    ("2" (rewrite "Exp_increq_2"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1" (grind-reals) (rewrite "expt_x1"))
    ("2" (rewrite "expt_x1") (grind-reals))
    ("3"
     (skeep)
     (split 1)
     (("1"
       (skosimp*)
       (rewrite "expt_plus")
       (rewrite "expt_x1")
       (grind-reals)
       (rewrite "odd_times_odd_is_odd"))
      ("2"
       (skosimp*)
       (rewrite "expt_plus")
       (rewrite "expt_x1")
       (lemma "even_or_odd")
       (inst -1 "radix")
       (flatten)
       (case "even?(radix)")
       (("1"
         (hide -2 -3 1)
         (lemma "even_iff_not_odd")
         (inst -1 "(radix ^ (1 + j)) * radix")
         (flatten)
         (case "even?((radix ^ (1 + j)) * radix)")
         (("1" (assert)) ("2" (rewrite "int_times_even_is_even"))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1" (grind-reals) (rewrite "expt_x1"))
    ("2" (grind-reals) (rewrite "expt_x1"))
    ("3"
     (skeep)
     (rewrite 1 "expt_plus")
     (("1"
       (rewrite "expt_plus" :subst ("n0x" "radix" "i" "j+1" "j" "1"))
       (rewrite "expt_x1")
       (split 1)
       (("1"
         (skosimp*)
         (split -2)
         (("1" (rewrite "even_times_int_is_even")) ("2" (propax))))
        ("2"
         (skosimp*)
         (case-replace "1+j=j+1")
         (("1"
           (hide -1)
           (case-replace
            "even?((radix ^ (j + 1)) * radix)=NOT odd?((radix ^ (1 + j)) * radix)")
           (("1"
             (case-replace "even?(radix)=NOT odd?(radix)")
             (("1"
               (rewrite "odd_times_odd_is_odd")
               (lemma "odd_or_even_int" :subst ("x" "radix ^ (1 + j)"))
               (assert))
              ("2"
               (lemma "even_iff_not_odd" :subst ("x" "radix"))
               (grind-reals))))
            ("2"
             (case-replace "1+j=j+1")
             (("1"
               (lemma "even_iff_not_odd" :subst
                ("x" "((radix ^ (j + 1)) * radix)"))
               (grind-reals))
              ("2" (assert))))))
          ("2" (assert))))))
      ("2"
       (skosimp*)
       (hide 2)
       (case-replace "even?(radix)=NOT odd?(radix)")
       (("1"
         (case-replace "even?(radix^(1+j))=NOT odd?(radix^(1+j))")
         (("1"
           (case "odd?(radix ^ (1 + j))")
           (("1"
             (case-replace "even?(radix^(2+j))=NOT odd?(radix^(2+j))")
             (("1"
               (case-replace "2+j=1+(1+j)")
               (("1"
                 (rewrite "expt_plus")
                 (rewrite "expt_x1")
                 (rewrite "odd_times_odd_is_odd"))
                ("2" (assert))))
              ("2"
               (lemma "even_iff_not_odd" :subst ("x" "radix ^ (2 + j)"))
               (grind-reals))))
            ("2" (assert))))
          ("2"
           (lemma "even_iff_not_odd" :subst ("x" "radix ^ (1 + j)"))
           (grind-reals))))
        ("2"
         (lemma "even_iff_not_odd" :subst ("x" "radix"))
         (grind-reals))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fplus" "FtoR")
   (rewrite "expt_div" :dir rl)
   (rewrite "expt_div" :dir rl)
   (field))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "associative?")
   (skeep)
   (expand "Fplus" + 2)
   (assert)
   (expand "min")
   (assert)
   (lift-if)
   (ground)
   (("1"
     (expand "Fplus" + 3)
     (expand "min")
     (lift-if)
     (split +)
     (("1"
       (flatten)
       (assert)
       (expand "Fplus" + 1)
       (expand "min")
       (assert)
       (expand "Fplus" + 1)
       (expand "min")
       (assert)
       (lemma "expt_plus")
       (inst - "Fexp(x)-Fexp(y)" "Fexp(y)-Fexp(z)" "radix")
       (assert))
      ("2"
       (flatten)
       (assert)
       (expand "Fplus" 2 1)
       (expand "min")
       (assert)
       (expand "Fplus" 2 1)
       (expand "min")
       (assert))))
    ("2"
     (expand "Fplus" 2 3)
     (expand "min")
     (lift-if)
     (ground)
     (("1"
       (expand "Fplus" 1 1)
       (expand "min")
       (lift-if)
       (ground)
       (("1"
         (expand "Fplus")
         (assert)
         (expand "min")
         (assert)
         (lemma "expt_plus")
         (inst - "Fexp(x)-Fexp(z)" "Fexp(y)-Fexp(x)" "radix")
         (assert))
        ("2"
         (assert)
         (expand "Fplus")
         (expand "min")
         (assert)
         (lemma "expt_plus")
         (inst - "Fexp(y)-Fexp(z)" "Fexp(z)-Fexp(x)" "radix")
         (assert))))
      ("2"
       (expand "Fplus" 2 1)
       (expand "min")
       (assert)
       (expand "Fplus" 2 1)
       (expand "min")
       (assert)
       (lemma "expt_plus")
       (inst - "Fexp(y)-Fexp(x)" "Fexp(z)-Fexp(y)" "radix")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fminus" "FtoR")
   (rewrite "expt_div" :dir rl)
   (rewrite "expt_div" :dir rl)
   (field))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind)
   (decompose-equality)
   (expand "divides")
   (expand "divides")
   (inst + "1")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "i")
   (("1"
     (assert)
     (skeep)
     (expand "FDivKexpt")
     (assert)
     (assert)
     (expand "FtoR")
     (assert))
    ("2"
     (skeep)
     (skeep)
     (case "NOT FORALL (zd:nat): integer_pred((radix ^ (zd)) / (k ^ (zd)))")
     (("1"
       (hide (-1 2))
       (induct "zd")
       (("1" (grind))
        ("2"
         (skolem 1 "rk")
         (flatten)
         (case "FORALL (ik,jk:int): integer_pred(ik*jk)")
         (("1"
           (inst - "(radix ^ rk) / (k ^ rk)" "radix/k")
           (("1" (expand "^") (expand "expt" +) (assert))
            ("2"
             (hide-all-but 1)
             (typepred "k")
             (expand "mod")
             (case "floor(radix/k) = radix/k")
             (("1" (assert) (replace -1 :dir rl) (assert))
              ("2" (flatten) (assert))))))
          ("2" (hide-all-but 1) (grind))))))
      ("2"
       (label "hyp1" -1)
       (hide "hyp1")
       (inst - "f" "k")
       (expand "FDivKexpt")
       (mult-by 1 "k")
       (("1"
         (case "FtoR(f) / k ^ (1 + j) * k = FtoR(f)/k^j")
         (("1"
           (replace -1)
           (hide -1)
           (replace -1 :dir rl)
           (hide -1)
           (lemma "float_int_def")
           (inst - "k")
           (case "FORALL (aa:real): aa*k = aa*FtoR(float_int(k))")
           (("1"
             (rewrite -1)
             (("1"
               (hide -1)
               (lemma "FmultCorrect")
               (rewrite -1 :dir rl)
               (("1"
                 (hide -1)
                 (assert)
                 (expand "FtoR")
                 (expand "Fmult")
                 (real-props)
                 (assert)
                 (expand "float_int")
                 (case "k^(1+j) = k*(k^j)")
                 (("1"
                   (replace -1)
                   (hide -1)
                   (lemma "expt_plus")
                   (inst-cp - "1+j" "Fexp(f)-1-j" "radix")
                   (assert)
                   (mult-by -2 "Fnum(f) * (k ^ j)")
                   (replace -1 :dir rl)
                   (hide -1)
                   (assert)
                   (inst - "Fexp(f)-j" "j" "radix")
                   (mult-by -1 "Fnum(f) * (k ^ j)")
                   (replace -1 :dir rl)
                   (assert))
                  ("2"
                   (hide-all-but 1)
                   (expand "^")
                   (expand "expt" + 1)
                   (propax))))
                ("2"
                 (reveal "hyp1")
                 (inst?)
                 (assert)
                 (case "FORALL (ik,jk:int): integer_pred(ik*jk)")
                 (("1" (inst?)) ("2" (hide-all-but 1) (grind))))))
              ("2"
               (reveal "hyp1")
               (inst?)
               (assert)
               (case "FORALL (ik,jk:int): integer_pred(ik*jk)")
               (("1" (inst?)) ("2" (hide-all-but 1) (grind))))))
            ("2" (skeep) (lemma "float_int_def") (inst?) (assert))))
          ("2" (expand "^") (expand "expt" + 1) (assert))))
        ("2"
         (reveal "hyp1")
         (inst?)
         (assert)
         (case "FORALL (ik,jk:int): integer_pred(ik*jk)")
         (("1" (inst?)) ("2" (hide-all-but 1) (grind))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fbounded?" "Fopp")
   (flatten)
   (split)
   (("1" (expand "abs") (grind-reals)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fbounded?" "Fabs")
   (flatten)
   (split)
   (("1" (grind-reals)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fcanonic?")
   (split)
   (("1"
     (case "Fnormal?(b)(Fabs(f))")
     (("1" (assert))
      ("2"
       (hide 2)
       (expand "Fnormal?")
       (flatten)
       (split)
       (("1" (rewrite "FabsBounded"))
        ("2" (expand "Fabs") (expand "abs") (grind-reals))))))
    ("2"
     (case "Fsubnormal?(b)(Fabs(f))")
     (("1" (assert))
      ("2"
       (hide 2)
       (expand "Fsubnormal?")
       (flatten)
       (split)
       (("1" (rewrite "FabsBounded")) ("2" (expand "Fabs") (propax))
        ("3" (expand "Fabs") (expand "abs") (grind-reals))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (skosimp*)
     (expand "Fle?")
     (case "FtoR(p) - FtoR(q) <= 0")
     (("1" (assert))
      ("2"
       (rewrite "FminusCorrect" :dir rl)
       (expand "FtoR")
       (grind-reals))))
    ("2"
     (skosimp*)
     (expand "Fle?")
     (case "FtoR(Fminus(p, q)) <= 0")
     (("1" (expand "FtoR") (grind-reals))
      ("2" (rewrite "FminusCorrect") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (skosimp*)
     (expand "Flt?")
     (case "FtoR(Fminus(p, q)) < 0")
     (("1" (rewrite "FminusCorrect") (assert))
      ("2" (expand "FtoR") (grind-reals))))
    ("2"
     (skosimp*)
     (case "FtoR(Fminus(p, q)) < 0")
     (("1" (expand "FtoR") (expand "Flt?") (grind-reals))
      ("2" (rewrite "FminusCorrect") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fmin")
   (lemma "FleCorrect")
   (inst -1 "p" "q")
   (rewrite -1)
   (expand "min")
   (grind-reals))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fmax")
   (lemma "FleCorrect" :subst ("p" "p" "q" "q"))
   (rewrite -1)
   (expand "max")
   (grind-reals))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "FtoR")
   (expand "Fsubnormal?")
   (flatten)
   (decompose-equality)
   (grind-reals))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fnormal?" "Fbounded?" "FtoR")
   (flatten)
   (case-replace "Fexp(p)=Fexp(q)")
   (("1" (decompose-equality) (grind-reals))
    ("2"
     (hide 2)
     (case "Fexp(p)<Fexp(q)+1")
     (("1"
       (case "Fexp(q)<Fexp(p)+1")
       (("1" (hide -3 -4 -5 -6 -7 -8 -9) (grind))
        ("2"
         (hide -1 2)
         (rewrite "Exp_incr_2")
         (hide 2)
         (mult-by 1 "abs(Fnum(q))")
         (case-replace
          "abs(Fnum(q)) * radix ^ Fexp(q)=abs(Fnum(p)) * radix ^ Fexp(p)")
         (("1"
           (rewrite "expt_plus")
           (cancel-by 1 "radix ^ Fexp(p)")
           (rewrite "abs_mult" -8)
           (expand "abs" -8 1)
           (assert))
          ("2"
           (hide 2 -1 -2 -3 -4 -5 -6)
           (wrap-formula -1 "abs")
           (rewrite* ("abs_mult"))
           (expand "abs" -1 (2 4))
           (rewrite* ("abs_mult"))
           (expand "abs" -1 3)
           (assert))))))
      ("2"
       (hide 2)
       (rewrite "Exp_incr_2")
       (hide 2)
       (mult-by 1 "abs(Fnum(p))")
       (case-replace
        "abs(Fnum(p)) * radix ^ Fexp(p)=abs(Fnum(q)) * radix ^ Fexp(q)")
       (("1"
         (rewrite "expt_plus")
         (cancel-by 1 "radix ^ Fexp(q)")
         (rewrite "abs_mult" -5)
         (expand "abs" -5 1)
         (assert))
        ("2"
         (hide-all-but (-7 1))
         (wrap-formula -1 "abs")
         (rewrite* ("abs_mult"))
         (expand "abs" -1 (2 4))
         (rewrite* ("abs_mult"))
         (expand "abs" -1 3)
         (propax))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "abs(FtoR(q)) < abs (FtoR(p))")
   (("1" (assert))
    ("2"
     (expand* "FtoR" "Fnormal?" "Fsubnormal?")
     (flatten)
     (hide -6)
     (rewrite "abs_mult")
     (expand "abs" 1 2)
     (rewrite "abs_mult")
     (expand "abs" 1 3)
     (mult-by 1 "radix")
     (swap-group "abs(Fnum(q))" * "radix ^ (Fexp(q))" "radix" r)
     (swap-group "abs(Fnum(p))" * "radix ^ (Fexp(p))" "radix" r)
     (case "abs(Fnum(q)) * radix < abs(Fnum(p)) * radix"
       "radix ^ Fexp(q) <= radix ^ Fexp(p)")
     (("1" (grind-reals))
      ("2"
       (hide -1 2)
       (expand "Fbounded?")
       (flatten)
       (rewrite -6)
       (rewrite "Exp_increq_1"))
      ("3"
       (hide 2)
       (rewrite "abs_mult" -2)
       (rewrite "abs_mult" -5)
       (expand "abs" -2 1)
       (expand "abs" -5 1)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fcanonic?")
   (split)
   (("1"
     (split)
     (("1" (use "FnormalUnique") (assert))
      ("2" (use "NormalAndSubNormalNotEq") (assert))))
    ("2"
     (split)
     (("1"
       (lemma "NormalAndSubNormalNotEq")
       (inst -1 "b" "q" "p")
       (assert))
      ("2" (use "FsubnormalUnique") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fulp")
   (case-replace "Fnormalize(b)(p)=p")
   (hide 2)
   (lemma "FcanonicUnique")
   (inst -1 "b" "Fnormalize(b)(p)" "p")
   (rewrite -1))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "0<= Fnum(p)")
   (("1"
     (case "0<= Fnum(q)")
     (("1"
       (expand "Fcanonic?")
       (split)
       (("1"
         (split)
         (("1"
           (case "Fexp(p) < Fexp(q)+1")
           (("1" (grind-reals))
            ("2"
             (hide 2)
             (expand* "Fnormal?" "Fbounded?")
             (flatten)
             (hide -2 -3 -4 -5)
             (rewrite "abs_mult" -2)
             (expand* "abs")
             (grind-reals)
             (rewrite "Exp_incr_2")
             (hide 2)
             (mult-by 1 "Fnum(p)")
             (case-replace "radix ^ Fexp(p) * Fnum(p)= FtoR(p)")
             (("1"
               (case "FtoR(q)<radix ^ (1 + Fexp(q)) * Fnum(p)")
               (("1" (grind-reals))
                ("2"
                 (hide 2)
                 (expand "FtoR")
                 (rewrite "expt_plus")
                 (rewrite "expt_x1")
                 (div-by 1 "radix ^ (Fexp(q))")
                 (case-replace
                  "radix * radix ^ Fexp(q) * Fnum(p) / radix ^ (Fexp(q))=radix * Fnum(p)")
                 (("1" (grind-reals)) ("2" (hide 2) (field))))))
              ("2" (expand "FtoR") (grind-reals))))))
          ("2"
           (expand* "Fnormal?" "Fsubnormal?" "Fbounded?")
           (flatten)
           (rewrite "abs_mult")
           (rewrite "abs_mult")
           (expand* "abs")
           (grind-reals)
           (flip-ineq -11)
           (hide 2)
           (case "FtoR(q) < FtoR(p)")
           (("1" (grind-reals))
            ("2"
             (hide 2 -10)
             (expand "FtoR")
             (case "Fnum(q) * radix ^ (Fexp(q)) <= Fnum(q) * radix ^ (Fexp(p))")
             (("1"
               (case "Fnum(q) * radix ^ (Fexp(p)) < Fnum(p) * radix ^ (Fexp(p))")
               (("1"
                 (hide-all-but (-1 -2 1))
                 (name-replace "AA" "Fnum(q) * radix ^ (Fexp(q))")
                 (name-replace "BB" "Fnum(q) * radix ^ (Fexp(p))")
                 (grind-reals))
                ("2"
                 (hide 2)
                 (cancel-by 1 "radix ^ (Fexp(p))")
                 (mult-by 1 "radix")
                 (grind-reals))))
              ("2"
               (cancel-by 1 "Fnum(q)")
               (rewrite "Exp_increq_1"))))))))
        ("2"
         (expand* "Fsubnormal?" "Fnormal?" "Fbounded?")
         (flatten)
         (grind-reals))))
      ("2"
       (hide -1 -2 -3 2)
       (mult-by 1 "radix^Fexp(q)")
       (("1" (expand "FtoR") (grind-reals)) ("2" (grind-reals))))))
    ("2" (hide -1 -2 -4 2) (expand "FtoR") (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "p=Fnormalize(b)(q)")
   (("1" (hide -1 -2 -4) (assert))
    ("2"
     (hide 2)
     (lemma "FcanonicUnique")
     (inst -1 "b" "p" "Fnormalize(b)(q)")
     (rewrite -1))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (case "vNum(b) <= abs(radix * Fnum(p))")
     (("1" (expand* "Fcanonic?" "Fnormal?") (assert))
      ("2" (expand* "Fcanonic?" "Fsubnormal?") (assert))))
    ("2" (expand* "Fcanonic?" "Fnormal?") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fulp")
   (case "Fnormalize(b)(Fopp(f))=Fopp(Fnormalize(b)(f))")
   (("1" (rewrite -1) (expand "Fopp") (propax))
    ("2"
     (rewrite "FcanonicUnique" :subst ("b" "b"))
     (("1"
       (case "FtoR(Fnormalize(b)(Fopp(f)))= FtoR(Fopp(f))")
       (("1"
         (rewrite -1)
         (rewrite "FoppCorrect")
         (rewrite "FoppCorrect")
         (assert))
        ("2" (assert))))
      ("2"
       (lemma "FcanonicOpp")
       (inst -1 "b" "Fnormalize(b)(f)")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fabs")
   (expand "abs")
   (grind-reals)
   (("1"
     (case-replace "(# Fnum := -Fnum(f), Fexp := Fexp(f) #)=Fopp(f)")
     (("1" (rewrite "FulpOpp")) ("2" (expand "Fopp") (propax))))
    ("2"
     (case-replace "(# Fnum := Fnum(f), Fexp := Fexp(f) #)=f")
     (decompose-equality))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "FulpAbs" :dir rl)
   (rewrite "FulpAbs" :dir rl :subst ("f" "q"))
   (rewrite "FulpMonotone")
   (("1" (rewrite "FabsCorrect") (rewrite "FabsCorrect"))
    ("2" (rewrite "FabsCorrect") (assert)) ("3" (rewrite "FabsBounded"))
    ("4" (rewrite "FabsBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "FORALL (b: Format, p: float):
                 Fcanonic?(b)(p) =>
                  (EXISTS (f: (Fbounded?(b))): FtoR(f) = FtoR(p) + Fulp(b)(p))")
   (("1"
     (inst -1 "b" "Fnormalize(b)(p)")
     (split)
     (("1"
       (skosimp*)
       (inst 1 "f!1")
       (case "FtoR(Fnormalize(b)(p))=FtoR(p)")
       (("1"
         (case " Fulp(b)(Fnormalize(b)(p))=Fulp(b)(p)")
         (("1" (assert))
          ("2"
           (hide -1 -2 2)
           (expand "Fulp")
           (rewrite "FcanonicUnique" :subst
            ("b"
             "b"
             "p"
             "Fnormalize(b)(Fnormalize(b)(p))"
             "q"
             "Fnormalize(b)(p)")))))
        ("2" (assert))))
      ("2" (assert))))
    ("2"
     (hide 2 -1)
     (skosimp*)
     (case "Fnum(p!1) = vNum(b!1)-1 OR Fnum(p!1) <= vNum(b!1)-2")
     (("1"
       (split)
       (("1"
         (inst 1 "(# Fnum:=vNum(b!1)/radix, Fexp:=Fexp(p!1)+1 #)")
         (("1"
           (rewrite "FulpCanonic")
           (expand "FtoR")
           (rewrite "expt_plus")
           (rewrite "expt_x1")
           (field))
          ("2"
           (expand "Fbounded?")
           (case "Fbounded?(b!1)(p!1)")
           (("1"
             (expand "Fbounded?")
             (flatten)
             (split)
             (("1"
               (expand "abs")
               (grind-reals)
               (div-by 1 "vNum(b!1)")
               (assert))
              ("2" (assert))))
            ("2" (rewrite "FcanonicBounded"))))
          ("3" (lemma "radix_div_vNum") (inst -1 "b!1"))))
        ("2"
         (inst 1 "(# Fnum:=Fnum(p!1)+1, Fexp:=Fexp(p!1) #)")
         (("1" (rewrite "FulpCanonic") (expand "FtoR") (propax))
          ("2"
           (expand "Fbounded?")
           (case "Fbounded?(b!1)(p!1)")
           (("1"
             (expand "Fbounded?")
             (flatten)
             (split)
             (("1" (expand "abs") (grind-reals)) ("2" (propax))))
            ("2" (rewrite "FcanonicBounded"))))))))
      ("2"
       (case "Fbounded?(b!1)(p!1)")
       (("1" (expand "Fbounded?") (flatten) (grind-reals))
        ("2" (rewrite "FcanonicBounded"))))))
    ("3" (skosimp*) (rewrite "FcanonicBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "FloatPlusUlpBounded")
   (inst -1 "b" "Fopp(p)")
   (split)
   (("1"
     (skosimp*)
     (inst 1 "Fopp(f!1)")
     (("1"
       (rewrite "FoppCorrect")
       (rewrite "FoppCorrect")
       (rewrite -1)
       (case "Fulp(b)(Fopp(p))=Fulp(b)(p)")
       (("1" (assert))
        ("2"
         (hide -1 2)
         (expand "Fulp")
         (case "Fnormalize(b)(Fopp(p))=Fopp(Fnormalize(b)(p))")
         (("1" (rewrite -1) (expand "Fopp") (propax))
          ("2"
           (hide 2)
           (rewrite "FcanonicUnique" :subst ("b" "b"))
           (("1"
             (case "FtoR(Fnormalize(b)(Fopp(p)))=FtoR(Fopp(p))")
             (("1"
               (rewrite -1)
               (rewrite "FoppCorrect")
               (rewrite "FoppCorrect")
               (assert))
              ("2" (assert))))
            ("2"
             (lemma "FcanonicOpp")
             (inst -1 "b" "Fnormalize(b)(p)")
             (assert))))))))
      ("2" (rewrite "FoppBounded"))))
    ("2" (rewrite "FoppBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fpred" "Fsucc")
   (grind-reals)
   (("1"
     (lemma "radix_less_vNum" :subst ("b" "b"))
     (hide -2 -3)
     (field -2))
    ("2" (apply-extensionality :hide? t))
    ("3" (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?" "Fbounded?"))
    ("4"
     (decompose-equality 2)
     (("1" (rewrite "div_cancel4") (grind))
      ("2"
       (rewrite "div_cancel4")
       (replace -2 :dir rl :hide? t)
       (grind))))
    ("5"
     (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?" "Fbounded?")
     (rewrite -2)
     (grind-reals))
    ("6" (decompose-equality 3))
    ("7"
     (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?" "Fbounded?")
     (rewrite -2)
     (grind-reals))
    ("8"
     (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?" "Fbounded?")
     (flatten)
     (case-replace "Fnum(f)=1-(vNum(b) / radix)")
     (("1"
       (hide-all-but -3)
       (rewrite "abs_mult")
       (expand "abs")
       (grind-reals)
       (lemma "radix_less_vNum" :subst ("b" "b"))
       (grind-reals))
      ("2" (assert))))
    ("9" (decompose-equality 3))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "f=Fopp(Fopp(f))")
   (("1"
     (rewrite -1 :target-fnums 1)
     (rewrite "FsuccFoppFpred")
     (rewrite "FpredFoppFsucc" :subst ("f" "(Fpred(b)(Fopp(f)))"))
     (rewrite "FsuccFpred")
     (lemma "FcanonicOpp")
     (grind-reals))
    ("2" (hide -1 2) (expand "Fopp") (decompose-equality))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "Fbounded?" "Fpred")
   (grind-reals)
   (("1" (expand "abs" 1) (field 1) (div-by 1 "vNum(b)") (assert))
    ("2" (expand "abs" 2) (assert)) ("3" (expand "abs") (grind-reals))
    ("4" (expand "abs") (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "Fsucc(b)(f)=Fopp(Fopp(Fsucc(b)(f)))")
   (("1"
     (rewrite "FoppBounded")
     (rewrite "FpredFoppFsucc" :dir rl)
     (rewrite "FpredBounded")
     (rewrite "FoppBounded"))
    ("2" (expand "Fopp") (decompose-equality 1))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "FcanonicOpp")
   (inst-cp -1 "b" "Fsucc(b)(f)")
   (flatten)
   (rewrite -3)
   (hide -2 -3 2)
   (lemma "FpredFoppFsucc")
   (inst -1 "b" "f")
   (case "Fcanonic?(b)(Fpred(b)(Fopp(f)))")
   (("1" (assert))
    ("2"
     (rewrite "FpredCanonic")
     (hide 2 3 -1)
     (inst -1 "b" "f")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "FtoR")
   (div-by -2 "radix ^ (Fexp(p))")
   (case-replace "0 / radix ^ (Fexp(p))=0")
   (("1" (hide -1) (expand "Fpred") (grind-reals)) ("2" (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "0 <=Fnum(p)")
   (("1"
     (case "0 < Fnum(Fsucc(b)(p))")
     (("1" (expand "FtoR" 1) (grind-reals))
      ("2"
       (hide 2)
       (expand "Fsucc")
       (lift-if)
       (split +)
       (("1" (flatten) (cross-mult 1))
        ("2"
         (flatten)
         (split 2)
         (("1" (flatten) (grind)) ("2" (flatten) (assert))))))))
    ("2" (expand "FtoR" -2) (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "FulpCanonic")
   (("1"
     (expand* "FtoR" "Fpred")
     (grind-reals)
     (rewrite "expt_div" :dir rl)
     (rewrite "expt_x1")
     (grind-reals))
    ("2" (rewrite "FpredCanonic"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "f=Fpred(b)(Fsucc(b)(f))")
   (("1"
     (case-replace "FtoR(f)=FtoR(Fpred(b)(Fsucc(b)(f)))")
     (("1"
       (case-replace "Fulp(b)(f)=Fulp(b)(Fpred(b)(Fsucc(b)(f)))")
       (("1"
         (rewrite "FpredDiff")
         (("1" (hide -1 -2 2) (rewrite "FsuccPos"))
          ("2" (rewrite "FsuccCanonic"))))
        ("2" (grind-reals))
        ("3" (rewrite -2 :dir rl) (rewrite "FcanonicBounded"))))
      ("2" (grind-reals))))
    ("2" (rewrite "FpredFsucc"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fpred")
   (grind-reals)
   (("1"
     (expand "FtoR")
     (rewrite "expt_plus")
     (rewrite "expt_x1")
     (rewrite -1)
     (field))
    ("2"
     (expand "FtoR")
     (case-replace "radix ^ (Fexp(f) - 1)=radix ^ (Fexp(f))/radix")
     (("1" (hide -1 -3 1) (field) (grind-reals))
      ("2"
       (hide -1 -2 2 3)
       (lemma "expt_div")
       (inst -1 "Fexp(f)" "1" "radix")
       (rewrite "expt_x1" -1)
       (grind-reals))))
    ("3" (hide 1 2) (expand "FtoR") (grind-reals))
    ("4" (expand "FtoR") (hide 1 2) (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "FtoR(Fpred(b)(p))=FtoR(p)-Fulp(b)(Fpred(b)(p))")
   (("1"
     (case-replace "FtoR(Fpred(b)(q))=FtoR(q)-Fulp(b)(Fpred(b)(q))")
     (("1"
       (rewrite "FulpCanonic")
       (("1"
         (rewrite "FulpCanonic")
         (("1"
           (hide -1 -2)
           (case "0<Fnum(p)")
           (("1"
             (case "0<Fnum(q)")
             (("1"
               (case "Fexp(p) <= Fexp(q)")
               (("1"
                 (expand "Fpred")
                 (grind-reals)
                 (("1"
                   (expand* "FtoR")
                   (rewrite "expt_div" :dir rl)
                   (rewrite "expt_div" :dir rl)
                   (rewrite "expt_x1")
                   (field)
                   (div-by 1 "vNum(b)-1")
                   (case-replace "Fnum(p)=vNum(b)/radix")
                   (("1"
                     (case-replace "Fnum(q)=vNum(b)/radix")
                     (("1"
                       (case-replace
                        "(vNum(b) / radix * (radix ^ Fexp(p)) * radix - (radix ^ Fexp(p))) /
                                                                                                 (vNum(b) - 1)=radix ^ Fexp(p)")
                       (("1"
                         (case-replace
                          "(vNum(b) / radix * (radix ^ Fexp(q)) * radix - (radix ^ Fexp(q))) /
                                                                                                          (vNum(b) - 1)=radix ^ Fexp(q)")
                         (("1" (rewrite "Exp_increq_1")) ("2" (field))))
                        ("2" (field 1))))
                      ("2" (flatten) (grind-reals))))
                    ("2"
                     (expand "Fcanonic?")
                     (split)
                     (("1"
                       (expand "Fnormal?")
                       (flatten)
                       (rewrite "abs_mult" -2)
                       (expand "abs" -2)
                       (mult-by 2 "radix")
                       (field 2))
                      ("2"
                       (case-replace
                        " Fnum(p) * (radix ^ Fexp(p)) * radix - (radix ^ Fexp(p))
                                                                                       = (vNum(b)-1)*radix ^ Fexp(p)")
                       (("1"
                         (case "(vNum(b) - 1) * radix ^ Fexp(p) <= (vNum(b) - 1) * radix ^ Fexp(q)")
                         (("1"
                           (case "(vNum(b) - 1) * radix ^ Fexp(q) <=  Fnum(q) * radix ^ (Fexp(q)) * radix - radix ^ Fexp(q) * radix")
                           (("1" (grind-reals))
                            ("2" (cancel-by 1 "radix ^ Fexp(q)"))))
                          ("2"
                           (hide-all-but (-5 2 3))
                           (case "vNum(b) = radix * Fnum(q) OR vNum(b) < radix * Fnum(q)")
                           (("1"
                             (split)
                             (("1" (grind-reals))
                              ("2"
                               (lemma "radix_div_vNum")
                               (inst -1 "b")
                               (rewrite "div_simple" -1 :dir rl)
                               (skosimp*)
                               (div-by -2 "radix")
                               (case-replace "vNum(b) / radix=k!1")
                               (("1"
                                 (case "k!1 <= Fnum(q)-1")
                                 (("1"
                                   (mult-by -1 "radix")
                                   (grind-reals))
                                  ("2" (grind-reals))))
                                ("2" (grind-reals))))))
                            ("2" (grind-reals))))))
                        ("2"
                         (div-by 1 "vNum(b) - 1")
                         (grind-reals))))))))
                  ("2"
                   (expand "Fcanonic?" -5)
                   (split)
                   (("1"
                     (expand "Fnormal?")
                     (flatten)
                     (rewrite "abs_mult" -2)
                     (expand "abs" -2)
                     (expand "FtoR" 2)
                     (rewrite "expt_div" :dir rl)
                     (rewrite "expt_x1")
                     (mult-by 2 "radix")
                     (field 2)
                     (case-replace
                      " Fnum(p) * (radix ^ Fexp(p)) * radix - (radix ^ Fexp(p))
                                                                 = (vNum(b)-1)*radix ^ Fexp(p)")
                     (("1"
                       (case "(vNum(b) - 1) * radix ^ Fexp(p) <= (vNum(b) - 1) * radix ^ Fexp(q)")
                       (("1"
                         (case "(vNum(b) - 1) * radix ^ Fexp(q) <=  Fnum(q) * radix ^ (Fexp(q)) * radix - radix ^ Fexp(q) * radix")
                         (("1" (grind-reals))
                          ("2"
                           (cancel-by 1 "radix ^ Fexp(q)")
                           (hide-all-but (-5 2 3))
                           (case "vNum(b) = radix * Fnum(q) OR vNum(b) < radix * Fnum(q)")
                           (("1"
                             (split)
                             (("1" (grind-reals))
                              ("2"
                               (lemma "radix_div_vNum")
                               (inst -1 "b")
                               (rewrite "div_simple" -1 :dir rl)
                               (skosimp*)
                               (div-by -2 "radix")
                               (case-replace "vNum(b) / radix=k!1")
                               (("1"
                                 (case "k!1 <= Fnum(q)-1")
                                 (("1"
                                   (mult-by -1 "radix")
                                   (grind-reals))
                                  ("2" (grind-reals))))
                                ("2" (grind-reals))))))
                            ("2" (grind-reals))))))
                        ("2"
                         (div-by 1 "vNum(b) - 1")
                         (rewrite "Exp_increq_1"))))
                      ("2" (grind-reals))))
                    ("2" (expand "Fsubnormal?") (propax))))
                  ("3"
                   (case "Fbounded?(b)(p)")
                   (("1"
                     (expand "Fbounded?")
                     (flatten)
                     (case "-dExp(b) = Fexp(p)")
                     (("1"
                       (expand "abs" -2)
                       (expand "FtoR" 2)
                       (case "(vNum(b)-2)*radix ^ Fexp(p) <= Fnum(q) * radix ^ (Fexp(q)) - radix ^ (Fexp(q) - 1)")
                       (("1"
                         (case "Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p) <= (vNum(b) - 2) * radix ^ Fexp(p)")
                         (("1" (grind-reals))
                          ("2"
                           (div-by 1 "radix ^ (Fexp(p))")
                           (case-replace
                            "(Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p)) / radix ^ (Fexp(p))
                                                       = Fnum(p)-1")
                           (("1" (grind-reals)) ("2" (field 1))))))
                        ("2"
                         (hide 2 3)
                         (case "(vNum(b) - 2) * radix ^ (Fexp(q)-1) <= Fnum(q) * radix ^ (Fexp(q)) - radix ^ (Fexp(q) - 1)")
                         (("1"
                           (case "(vNum(b) - 2) * radix ^ Fexp(p) <=(vNum(b) - 2) * radix ^ (Fexp(q) - 1)")
                           (("1" (grind-reals))
                            ("2"
                             (div-by 1 "vNum(b) - 2")
                             (rewrite "Exp_increq_1"))))
                          ("2"
                           (hide 2)
                           (rewrite "expt_div" :dir rl)
                           (rewrite "expt_x1")
                           (field 1))))))
                      ("2" (grind-reals))))
                    ("2" (rewrite "FcanonicBounded"))))
                  ("4"
                   (case " Fexp(p)=-dExp(b)")
                   (("1"
                     (case " Fexp(q)=-dExp(b)")
                     (("1"
                       (hide 1 2 -3)
                       (expand* "FtoR")
                       (replace -2)
                       (replace -1)
                       (hide -4)
                       (div-by -6 "radix ^ -dExp(b)")
                       (div-by 1 "radix ^ -dExp(b)")
                       (case-replace
                        "(Fnum(p) * radix ^ -dExp(b) - radix ^ -dExp(b)) / radix ^ -dExp(b)
                                               = Fnum(p)-1")
                       (("1"
                         (case-replace
                          "(Fnum(q) * radix ^ -dExp(b) - radix ^ -dExp(b)) / radix ^ -dExp(b)
                                                   = Fnum(q)-1")
                         (("1" (grind-reals)) ("2" (field 1))))
                        ("2" (field 1))))
                      ("2" (grind-reals))))
                    ("2"
                     (case "Fbounded?(b)(p)")
                     (("1" (expand "Fbounded?") (propax))
                      ("2" (rewrite "FcanonicBounded"))))))
                  ("5"
                   (case "Fexp(p) = -dExp(b)")
                   (("1"
                     (hide 1)
                     (split-ineq -2)
                     (case "Fexp(p) < Fexp(q)")
                     (("1"
                       (hide 1)
                       (case "Fbounded?(b)(p)")
                       (("1"
                         (expand "Fbounded?")
                         (expand "abs" -1)
                         (expand "Fcanonic?" -8)
                         (expand* "Fnormal?" "Fsubnormal?")
                         (flatten)
                         (rewrite "abs_mult" -9)
                         (expand "abs" -9)
                         (hide -4)
                         (expand "FtoR" 2)
                         (case "(vNum(b)-2)* radix ^ Fexp(p) <= Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q)")
                         (("1"
                           (case "Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p) <= (vNum(b) - 2) * radix ^ Fexp(p)")
                           (("1" (assert))
                            ("2"
                             (div-by 1 "radix ^ Fexp(p)")
                             (case-replace
                              "(Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p)) / radix ^ Fexp(p)
                                                           = Fnum(p)-1")
                             (("1" (grind-reals)) ("2" (field 1))))))
                          ("2"
                           (hide 3)
                           (case "(vNum(b) - 2) * radix ^ (Fexp(q)-1) <= Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q)")
                           (("1"
                             (case "(vNum(b) - 2) * radix ^ Fexp(p) <= (vNum(b) - 2) * radix ^ (Fexp(q) - 1)")
                             (("1" (assert))
                              ("2"
                               (div-by 1 "vNum(b) - 2")
                               (rewrite "Exp_increq_1"))))
                            ("2"
                             (hide 2)
                             (rewrite "expt_div" :dir rl)
                             (rewrite "expt_x1")
                             (div-by 1 "radix ^ Fexp(q)")
                             (case-replace
                              "(vNum(b) - 2) * (radix ^ Fexp(q) / radix) / radix ^ Fexp(q)
                                                           = (vNum(b) - 2) / radix")
                             (("1"
                               (case-replace
                                "(Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q)) / radix ^ Fexp(q)
                                                               = Fnum(q)-1")
                               (("1"
                                 (grind-reals)
                                 (case "vNum(b)/radix +1 <= Fnum(q)")
                                 (("1"
                                   (hide-all-but (-1 1))
                                   (lemma "radix_less_vNum")
                                   (inst -1 "b")
                                   (mult-by -2 "radix")
                                   (field -1))
                                  ("2"
                                   (lemma "radix_div_vNum")
                                   (inst -1 "b")
                                   (rewrite "div_simple" :dir rl)
                                   (hide -2)
                                   (skosimp*)
                                   (case "k!1 < Fnum(q)")
                                   (("1" (grind-reals) (field 1))
                                    ("2"
                                     (grind-reals)
                                     (div-by -10 "radix")
                                     (div-by 4 "radix")
                                     (grind-reals))))))
                                ("2" (field 1))))
                              ("2" (field 1))))))))
                        ("2" (rewrite "FcanonicBounded"))))
                      ("2" (grind-reals))))
                    ("2"
                     (case "Fbounded?(b)(p)")
                     (("1" (expand "Fbounded?") (flatten) (grind-reals))
                      ("2" (rewrite "FcanonicBounded"))))))
                  ("6"
                   (split-ineq -1)
                   (("1"
                     (expand "FtoR" -8)
                     (expand "Fcanonic?" -6)
                     (expand* "Fnormal?" "Fsubnormal?")
                     (flatten)
                     (rewrite "abs_mult" -7)
                     (expand "abs" -7)
                     (replaces -1 -9)
                     (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?")
                     (flatten)
                     (rewrite "abs_mult" -5)
                     (expand "abs" -5)
                     (div-by -9 "radix ^ (Fexp(q))")
                     (mult-by -9 "radix")
                     (rewrite -10)
                     (hide-all-but (-1 -6 1))
                     (grind-reals))
                    ("2"
                     (case " Fexp(p) < Fexp(q)")
                     (("1"
                       (hide -2 1)
                       (hide 1 -7)
                       (expand "FtoR")
                       (case "(vNum(b)-2)*radix ^ Fexp(p) <= Fnum(q) * radix ^ (Fexp(q)) - radix ^ (Fexp(q) - 1)")
                       (("1"
                         (case "Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p) <=(vNum(b) - 2) * radix ^ Fexp(p)")
                         (("1" (assert))
                          ("2"
                           (div-by 1 "radix ^ Fexp(p)")
                           (case-replace
                            "(Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p)) / radix ^ Fexp(p)=Fnum(p)-1")
                           (("1"
                             (case "Fbounded?(b)(p)")
                             (("1"
                               (expand "Fbounded?")
                               (flatten)
                               (grind-reals))
                              ("2" (rewrite "FcanonicBounded"))))
                            ("2" (field))))))
                        ("2"
                         (case "(vNum(b) - 2) * radix ^ (Fexp(q)-1) <=
                                                                   Fnum(q) * radix ^ (Fexp(q)) - radix ^ (Fexp(q) - 1)")
                         (("1"
                           (case "(vNum(b) - 2) * radix ^ Fexp(p) <= (vNum(b) - 2) * radix ^ (Fexp(q) - 1)")
                           (("1" (assert))
                            ("2"
                             (div-by 1 "(vNum(b) - 2)")
                             (("1" (rewrite "Exp_increq_1"))
                              ("2"
                               (hide-all-but 1)
                               (lemma "radix_less_vNum")
                               (inst -1 "b")
                               (grind-reals))))))
                          ("2"
                           (hide 2 3)
                           (rewrite "expt_div" :dir rl)
                           (rewrite "expt_x1")
                           (div-by 1 "radix ^ Fexp(q)")
                           (case-replace
                            "(vNum(b) - 2) * (radix ^ Fexp(q) / radix) / radix ^ Fexp(q)
                                                        = (vNum(b) - 2)/radix")
                           (("1"
                             (case-replace
                              "(Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q) / radix) /
                                                                  radix ^ Fexp(q)=Fnum(q) -1/radix")
                             (("1" (field 1)) ("2" (field 1))))
                            ("2" (field 1))))))))
                      ("2" (grind-reals))))))
                  ("7"
                   (expand* "FtoR")
                   (case-replace "Fexp(q)=-dExp(b)")
                   (("1"
                     (case-replace "Fexp(p)=-dExp(b)")
                     (("1" (grind-reals))
                      ("2"
                       (case "Fbounded?(b)(p)")
                       (("1" (expand "Fbounded?") (propax))
                        ("2" (rewrite "FcanonicBounded"))))))
                    ("2"
                     (case "Fbounded?(b)(q)")
                     (("1" (expand "Fbounded?") (flatten) (grind-reals))
                      ("2" (rewrite "FcanonicBounded"))))))
                  ("8"
                   (split-ineq -1)
                   (case "Fexp(p) < Fexp(q)")
                   (("1"
                     (hide -2 1)
                     (expand "FtoR" 3)
                     (case "(vNum(b)-2)*radix ^ Fexp(p)<= Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q)")
                     (("1"
                       (case "Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p) <= (vNum(b) - 2) * radix ^ Fexp(p)")
                       (("1" (assert))
                        ("2"
                         (div-by 1 "radix ^ Fexp(p)")
                         (case-replace
                          "(Fnum(p) * radix ^ (Fexp(p)) - radix ^ Fexp(p)) / radix ^ Fexp(p)=Fnum(p)-1")
                         (("1"
                           (case "Fbounded?(b)(p)")
                           (("1"
                             (expand "Fbounded?")
                             (flatten)
                             (expand "abs" -1)
                             (grind-reals))
                            ("2" (rewrite "FcanonicBounded"))))
                          ("2" (field))))))
                      ("2"
                       (case "(vNum(b) - 2) * radix ^ (Fexp(q)-1) <=
                                                               Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q)")
                       (("1"
                         (case "(vNum(b) - 2) * radix ^ Fexp(p) <= (vNum(b) - 2) * radix ^ (Fexp(q) - 1)")
                         (("1" (assert))
                          ("2"
                           (div-by 1 "vNum(b) - 2")
                           (("1" (rewrite "Exp_increq_1"))
                            ("2"
                             (lemma "radix_less_vNum")
                             (inst -1 "b")
                             (grind-reals))))))
                        ("2"
                         (hide 2 5)
                         (rewrite "expt_div" :dir rl)
                         (rewrite "expt_x1")
                         (div-by 1 "radix ^ Fexp(q)")
                         (case-replace
                          "(vNum(b) - 2) * (radix ^ Fexp(q) / radix) / radix ^ Fexp(q)
                                                    = (vNum(b) - 2)/radix")
                         (("1"
                           (case-replace
                            "(Fnum(q) * radix ^ (Fexp(q)) - radix ^ Fexp(q)) / radix ^ Fexp(q)
                                                       = Fnum(q)-1")
                           (("1"
                             (case "vNum(b)/radix +1 <= Fnum(q)")
                             (("1"
                               (mult-by -1 "radix")
                               (mult-by 1 "radix")
                               (field))
                              ("2"
                               (lemma "radix_div_vNum")
                               (inst -1 "b")
                               (rewrite "div_simple" :dir rl)
                               (skosimp*)
                               (case "k!1 < Fnum(q)")
                               (("1" (grind-reals))
                                ("2"
                                 (hide -2 -3 2 3)
                                 (expand "Fcanonic?" -6)
                                 (expand* "Fnormal?" "Fsubnormal?")
                                 (split)
                                 (("1"
                                   (flatten)
                                   (rewrite "abs_mult" -2)
                                   (expand "abs" -2)
                                   (hide-all-but (-2 -3 1 3))
                                   (rewrite -2)
                                   (div-by -1 "radix")
                                   (div-by 2 "radix")
                                   (grind-reals))
                                  ("2"
                                   (flatten)
                                   (case "Fbounded?(b)(p)")
                                   (("1"
                                     (expand "Fbounded?")
                                     (flatten)
                                     (grind-reals))
                                    ("2"
                                     (rewrite "FcanonicBounded"))))))))))
                            ("2" (field 1))))
                          ("2" (field 1))))))))
                    ("2" (grind-reals))))))
                ("2"
                 (hide 2)
                 (lemma "Lexico")
                 (inst -1 "b" "p" "q")
                 (assert))))
              ("2"
               (case "0<FtoR(q)")
               (("1" (expand "FtoR" -1) (grind-reals))
                ("2" (grind-reals))))))
            ("2" (expand "FtoR" -3) (grind-reals))))
          ("2" (rewrite "FpredCanonic"))))
        ("2" (rewrite "FpredCanonic"))))
      ("2" (rewrite "FpredDiff" :dir rl) (assert))
      ("3" (rewrite "FcanonicBounded") (rewrite "FpredCanonic"))))
    ("2" (rewrite "FpredDiff" :dir rl) (assert))
    ("3" (rewrite "FcanonicBounded") (rewrite "FpredCanonic"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "FtoR(Fsucc(b)(p))=FtoR(p)+Fulp(b)(p)")
   (("1"
     (case-replace "FtoR(Fsucc(b)(q))=FtoR(q)+Fulp(b)(q)")
     (("1"
       (case "Fulp(b)(p) <=Fulp(b)(q)")
       (("1" (grind-reals))
        ("2"
         (hide -1 -2 2)
         (rewrite "FulpCanonic")
         (rewrite "FulpCanonic")
         (rewrite "Exp_increq_1")
         (lemma "Lexico")
         (inst -1 "b" "p" "q")
         (rewrite -1))))
      ("2" (rewrite "FsuccDiff" :dir rl) (assert))
      ("3" (rewrite "FcanonicBounded"))))
    ("2" (rewrite "FsuccDiff" :dir rl) (assert))
    ("3" (rewrite "FcanonicBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (skosimp)
     (case "0 < FtoR(p)")
     (("1" (rewrite "FpredLe_aux"))
      ("2"
       (flip-ineq 1)
       (case "FtoR(q)<=0")
       (("1"
         (neg-formula 1)
         (rewrite "FoppCorrect" :dir rl)
         (rewrite "FoppCorrect" :dir rl)
         (rewrite "FsuccFoppFpred" :dir rl)
         (rewrite "FsuccFoppFpred" :dir rl)
         (rewrite "FpredLe_aux2")
         (("1"
           (rewrite "FoppCorrect")
           (rewrite "FoppCorrect")
           (grind-reals))
          ("2" (rewrite "FoppCorrect") (grind-reals))
          ("3" (lemma "FcanonicOpp") (inst -1 "b" "p") (assert))
          ("4" (lemma "FcanonicOpp") (inst -1 "b" "q") (assert))))
        ("2"
         (flip-ineq 1)
         (case "0 <= FtoR(Fpred(b)(q))")
         (("1"
           (grind-reals)
           (case "FtoR(Fpred(b)(p)) <= FtoR(p)")
           (("1" (assert))
            ("2" (lemma "FpredLt") (inst -1 "b" "p") (grind-reals))))
          ("2" (rewrite "FpredPos"))))))))
    ("2"
     (skosimp)
     (case "0 <= FtoR(Fpred(b)(p))")
     (("1"
       (case-replace "FtoR(q)=FtoR(Fsucc(b)(Fpred(b)(q)))")
       (("1"
         (case-replace "FtoR(p)=FtoR(Fsucc(b)(Fpred(b)(p)))")
         (("1"
           (rewrite "FpredLe_aux2")
           (("1" (rewrite "FpredCanonic"))
            ("2" (rewrite "FpredCanonic"))))
          ("2" (rewrite "FsuccFpred"))))
        ("2" (rewrite "FsuccFpred"))))
      ("2"
       (flip-ineq 1)
       (case "0 <= FtoR(Fpred(b)(q))")
       (("1"
         (case "FtoR(p) <= 0")
         (("1"
           (case "FtoR(Fpred(b)(q))<= FtoR(q)")
           (("1" (assert))
            ("2" (lemma "FpredLt") (inst -1 "b" "q") (assert))))
          ("2" (flip-ineq -2) (flip-ineq 2) (rewrite "FpredPos"))))
        ("2"
         (flip-ineq 1)
         (neg-formula 1)
         (rewrite "FoppCorrect" :dir rl)
         (rewrite "FoppCorrect" :dir rl)
         (case-replace "Fopp(q)=Fpred(b)(Fsucc(b)(Fopp(q)))")
         (("1"
           (case-replace "Fopp(p)=Fpred(b)(Fsucc(b)(Fopp(p)))")
           (("1"
             (rewrite "FsuccFoppFpred")
             (rewrite "FsuccFoppFpred")
             (lemma "FpredLe_aux")
             (inst -1 "b" "Fopp(Fpred(b)(q))" "Fopp(Fpred(b)(p))")
             (rewrite -1)
             (("1"
               (rewrite "FoppCorrect")
               (rewrite "FoppCorrect")
               (grind-reals))
              ("2" (rewrite "FoppCorrect") (grind-reals))
              ("3"
               (lemma "FcanonicOpp")
               (inst -1 "b" "Fpred(b)(p)")
               (flatten)
               (rewrite -1)
               (rewrite "FpredCanonic"))
              ("4"
               (lemma "FcanonicOpp")
               (inst -1 "b" "Fpred(b)(q)")
               (flatten)
               (rewrite -1)
               (rewrite "FpredCanonic"))))
            ("2"
             (rewrite "FpredFsucc")
             (lemma "FcanonicOpp")
             (inst -1 "b" "p")
             (assert))))
          ("2"
           (rewrite "FpredFsucc")
           (lemma "FcanonicOpp")
           (inst -1 "b" "q")
           (assert))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "FpredLe")
   (inst -1 "b" "Fsucc(b)(p)" "Fsucc(b)(q)")
   (rewrite "FpredFsucc")
   (rewrite "FpredFsucc")
   (rewrite -1)
   (("1" (assert)) ("2" (rewrite "FsuccCanonic"))
    ("3" (rewrite "FsuccCanonic"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "Fexp(p) = Fexp(q) OR Fexp(p) < Fexp(q)")
   (("1"
     (split)
     (("1"
       (expand "FtoR" -5)
       (case-replace "Fexp(p) = Fexp(q)")
       (div-by -5 "radix ^ Fexp(q)")
       (case "(Fnum(q)-1)*radix^(Fexp(q)) <= FtoR(Fpred(b)(q))")
       (("1"
         (case " FtoR(p) <= (Fnum(q) - 1) * radix ^ (Fexp(q))")
         (("1" (grind-reals))
          ("2"
           (expand "FtoR" 1)
           (replaces -2 1)
           (div-by 1 "radix ^ Fexp(q)")
           (case-replace
            "(Fnum(q) * radix ^ (Fexp(q)) - radix ^ (Fexp(q))) / radix ^ Fexp(q)=Fnum(q)-1")
           (("1" (grind-reals)) ("2" (grind-reals))))))
        ("2"
         (hide 2)
         (case "0<Fnum(q)")
         (("1"
           (expand "Fpred")
           (grind-reals)
           (("1"
             (expand "FtoR")
             (rewrite "expt_div" :dir rl)
             (rewrite "expt_x1")
             (rewrite -2 :dir rl)
             (grind-reals)
             (div-by 1 "radix ^ Fexp(q)")
             (assert))
            ("2" (expand "FtoR") (grind-reals))
            ("3" (expand "FtoR") (grind-reals))))
          ("2"
           (case "0 <= Fnum(p)")
           (("1" (grind-reals))
            ("2" (expand "FtoR" -4) (grind-reals))))))
        ("3" (grind-reals))))
      ("2"
       (case "(vNum(b)-1)*radix^(Fexp(q)-1) <= FtoR(Fpred(b)(q))")
       (("1"
         (case "FtoR(p) <= (vNum(b) - 1) * radix ^ (Fexp(q) - 1)")
         (("1" (grind-reals))
          ("2"
           (hide -1 -4 -6 2)
           (expand "FtoR" 1)
           (case "Fnum(p) * radix ^ (Fexp(p)) <= Fnum(p) * radix ^ (Fexp(q)-1)")
           (("1"
             (case "Fnum(p) * radix ^ (Fexp(q) - 1) <= vNum(b) * radix ^ (Fexp(q) - 1) - radix ^ (Fexp(q) - 1)")
             (("1" (grind-reals))
              ("2"
               (hide 2 -1 -4)
               (div-by 1 "radix ^ (Fexp(q) - 1)")
               (case-replace
                "(vNum(b) * radix ^ (Fexp(q) - 1) - radix ^ (Fexp(q) - 1)) /
                        radix ^ (Fexp(q) - 1)=vNum(b)-1")
               (("1"
                 (case "Fbounded?(b)(p)")
                 (("1"
                   (expand "Fbounded?")
                   (flatten)
                   (hide -2 -3 -4 -5)
                   (grind-reals))
                  ("2" (rewrite "FcanonicBounded"))))
                ("2" (hide-all-but 1) (field))))))
            ("2"
             (hide -2 2)
             (case "0 <= Fnum(p)")
             (("1" (cancel-by 1 "Fnum(p)") (rewrite "Exp_increq_1"))
              ("2" (hide -1 2) (expand "FtoR") (grind-reals))))))))
        ("2"
         (hide 2)
         (case "0<Fnum(q)")
         (("1"
           (expand* "FtoR" "Fpred")
           (grind-reals)
           (("1"
             (hide 2)
             (case "Fbounded?(b)(p)")
             (("1" (expand "Fbounded?") (propax))
              ("2" (rewrite "FcanonicBounded"))))
            ("2"
             (rewrite "expt_div" :dir rl)
             (rewrite "expt_x1")
             (div-by 2 "radix ^ Fexp(q)")
             (case-replace
              "(vNum(b) * (radix ^ Fexp(q) / radix) - radix ^ Fexp(q) / radix) /
                     radix ^ Fexp(q)=(vNum(b)-1)/radix")
             (("1"
               (case-replace
                "(Fnum(q) * radix ^ Fexp(q) - radix ^ Fexp(q)) / radix ^ Fexp(q)
                 = Fnum(q)-1")
               (("1"
                 (hide -1 -2)
                 (expand "Fcanonic?" -4)
                 (split)
                 (("1"
                   (expand "Fnormal?")
                   (flatten)
                   (rewrite "abs_mult" -2)
                   (expand "abs" -2)
                   (hide -1 -4 -5 -6 -7)
                   (case "vNum(b) < radix * Fnum(q)")
                   (("1"
                     (case "integer_pred(vNum(b) / radix)")
                     (("1"
                       (div-by -2 "radix")
                       (case "(vNum(b) - 1) / radix <= vNum(b) / radix")
                       (("1"
                         (case "vNum(b) / radix <= Fnum(q) - 1")
                         (("1" (grind-reals))
                          ("2"
                           (hide -1 -4 -5 2 3)
                           (lemma "div_simple")
                           (case "(EXISTS (k:int): vNum(b) = k * radix)")
                           (("1"
                             (skosimp*)
                             (case-replace "vNum(b) / radix=k!1")
                             (("1" (grind-reals)) ("2" (grind-reals))))
                            ("2" (grind-reals))))))
                        ("2" (grind-reals))))
                      ("2" (grind-reals) (rewrite "radix_div_vNum"))))
                    ("2" (grind-reals))))
                  ("2"
                   (expand "Fsubnormal?")
                   (flatten)
                   (case "Fbounded?(b)(p)")
                   (("1" (expand "Fbounded?" -1) (flatten) (grind-reals))
                    ("2" (rewrite "FcanonicBounded"))))))
                ("2" (field))))
              ("2" (field))))))
          ("2"
           (mult-by 1 "radix ^ (Fexp(q))")
           (expand "FtoR")
           (grind-reals))))
        ("3" (grind-reals))))))
    ("2"
     (case "Fexp(p) <= Fexp(q)")
     (("1" (grind-reals))
      ("2" (hide 2 3) (lemma "Lexico") (inst -1 "b" "p" "q") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "0 <= FtoR(p)")
   (("1" (rewrite "FpredProp_aux"))
    ("2"
     (flip-ineq 1)
     (case "0 < FtoR(q)")
     (("1"
       (case "0 <=  FtoR(Fpred(b)(q))")
       (("1" (grind-reals)) ("2" (rewrite "FpredPos"))))
      ("2"
       (flip-ineq 1)
       (lemma "FsuccLe")
       (inst -1 "b" "p" "Fpred(b)(q)")
       (case "FtoR(Fsucc(b)(p)) <= FtoR(Fsucc(b)(Fpred(b)(q)))")
       (("1" (assert) (rewrite "FpredCanonic"))
        ("2"
         (hide -1 2)
         (rewrite "FsuccFpred")
         (neg-formula 1)
         (rewrite "FoppCorrect" :dir rl)
         (rewrite "FoppCorrect" :dir rl)
         (rewrite "FpredFoppFsucc" :dir rl)
         (rewrite "FpredProp_aux")
         (("1" (rewrite "FoppCorrect") (rewrite "FoppCorrect") (assert))
          ("2" (rewrite "FoppCorrect") (assert))
          ("3" (lemma "FcanonicOpp") (inst -1 "b" "p") (assert))
          ("4" (lemma "FcanonicOpp") (inst -1 "b" "q") (assert))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (neg-formula 1)
   (rewrite "FoppCorrect" :dir rl)
   (rewrite "FoppCorrect" :dir rl)
   (rewrite "FpredFoppFsucc" :dir rl)
   (rewrite "FpredLt"))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "q=Fpred(b)(Fsucc(b)(q))")
   (("1"
     (replace -1 1)
     (rewrite "FpredProp")
     (("1"
       (hide 2)
       (flip-ineq 1)
       (flip-ineq -5)
       (lemma "FsuccLe")
       (inst -1 "b" "q" "p")
       (assert))
      ("2" (rewrite "FsuccCanonic")) ("3" (rewrite "FsuccCanonic"))))
    ("2" (rewrite "FpredFsucc"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fsucc")
   (grind-reals)
   (("1"
     (expand "FtoR")
     (div-by 1 "radix ^ (Fexp(p))")
     (div-by -1 "radix ^ (Fexp(p))")
     (div-by -3 "radix ^ (Fexp(p))")
     (rewrite "expt_plus")
     (case-replace
      " Fnum(q) * radix ^ (Fexp(q)) / radix ^ (Fexp(p))= Fnum(q) * radix ^ (Fexp(q)-Fexp(p))")
     (("1"
       (hide -1)
       (case-replace
        " vNum(b) / radix * (radix * radix ^ Fexp(p)) / radix ^ (Fexp(p))=vNum(b)")
       (("1"
         (hide -1)
         (copy -3)
         (rewrite -3)
         (lemma "int_expt")
         (inst -1 "Fexp(q) - Fexp(p)" "radix")
         (expand "^")
         (case "integer_pred(Fnum(q) * expt(radix, (Fexp(q) - Fexp(p))))")
         (("1" (hide -5 -6 -2) (rewrite "FsuccZleEq_aux"))
          ("2" (assert))))
        ("2" (field 1))))
      ("2" (rewrite "expt_div" :dir rl) (field 1))))
    ("2"
     (hide 1)
     (expand "FtoR")
     (rewrites -2)
     (div-by -1 "radix ^ (Fexp(p))")
     (div-by -3 "radix ^ (Fexp(p))")
     (div-by 1 "radix ^ (Fexp(p))")
     (case-replace
      "Fnum(q) * radix ^ (Fexp(q)) / radix ^ (Fexp(p))=Fnum(q) * radix ^ (Fexp(q)-Fexp(p))")
     (("1"
       (hide -1)
       (rewrite "expt_div" :dir rl :subst ("j" "1"))
       (case-replace
        "-(vNum(b) - 1) * (radix ^ Fexp(p) / radix) / radix ^ (Fexp(p))=(-vNum(b)+1)/radix")
       (("1"
         (hide -1)
         (field -3)
         (rewrite "FsuccZleEq_aux")
         (("1" (expand "^") (propax))
          ("2" (mult-by 1 "radix") (assert))))
        ("2" (field 1))))
      ("2" (rewrite "expt_div" :dir rl) (field 1))))
    ("3"
     (hide 1 2)
     (expand "FtoR")
     (div-by 1 "radix ^ (Fexp(p))")
     (div-by -1 "radix ^ (Fexp(p))")
     (div-by -2 "radix ^ (Fexp(p))")
     (case-replace
      " Fnum(q) * radix ^ (Fexp(q)) / radix ^ (Fexp(p))=Fnum(q) * radix ^ (Fexp(q)-Fexp(p))")
     (("1"
       (hide -1)
       (case-replace
        "(radix ^ Fexp(p) + Fnum(p) * radix ^ Fexp(p)) / radix ^ (Fexp(p))=
                                   Fnum(p)+1")
       (("1" (hide -1) (rewrite "FsuccZleEq_aux") (expand "^") (propax))
        ("2" (field 1))))
      ("2" (rewrite "expt_div" :dir rl) (field 1))))
    ("4"
     (hide 1 2)
     (expand "FtoR")
     (div-by 1 "radix ^ (Fexp(p))")
     (div-by -1 "radix ^ (Fexp(p))")
     (div-by -2 "radix ^ (Fexp(p))")
     (case-replace
      "(radix ^ Fexp(p) + Fnum(p) * radix ^ Fexp(p)) / radix ^ (Fexp(p))=
                         Fnum(p)+1")
     (("1"
       (case-replace
        " Fnum(q) * radix ^ (Fexp(q)) / radix ^ (Fexp(p))=Fnum(q) * radix ^ (Fexp(q)-Fexp(p))")
       (("1"
         (hide -1 -2)
         (rewrite "FsuccZleEq_aux")
         (expand "^")
         (propax))
        ("2" (rewrite "expt_div" :dir rl) (field 1))))
      ("2" (field 1))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "vNum(b)=radix^Prec(b)")
   (("1"
     (replace -1)
     (lemma "expt_odd")
     (inst-cp -1 "Prec(b)-2")
     (("1"
       (flatten)
       (case-replace "radix ^ Prec(b) / radix=radix ^ (Prec(b) - 2 + 1)")
       (("1"
         (assert)
         (hide -3)
         (lemma "expt_odd")
         (inst -1 "Prec(b)-1")
         (flatten)
         (lemma "even_iff_odd_succ")
         (inst -1 "radix ^ Prec(b) - 1")
         (grind-reals))
        ("2" (assert) (rewrite "expt_div" :dir rl) (rewrite "expt_x1"))
        ("3" (assert))))
      ("2" (assert))))
    ("2" (expand "vNum") (propax)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fsucc")
   (grind-reals)
   (("1" (rewrite "EvenFsuccOdd_aux"))
    ("2"
     (rewrite "minus_odd_is_odd")
     (hide 2 3)
     (lemma "EvenFsuccOdd_aux")
     (inst -1 "b")
     (lemma "odd_iff_not_even")
     (inst -1 "vNum(b) - 1")
     (case "NOT even?(vNum(b) - 1)")
     (("1" (assert))
      ("2"
       (case "odd?(vNum(b) / radix)")
       (("1"
         (case "even?(vNum(b) / radix)")
         (("1"
           (hide-all-but (-1 -2))
           (lemma "even_or_odd")
           (inst -1 "vNum(b) / radix")
           (("1" (assert)) ("2" (lemma "radix_div_vNum") (inst -1 "b"))))
          ("2"
           (div-by -7 "radix")
           (replace -7 -6)
           (hide-all-but (-6 1))
           (lemma "minus_even_is_even")
           (case "vNum(b) / radix=-(-(vNum(b) / radix))")
           (("1"
             (replaces -1 1)
             (rewrite -1)
             (assert)
             (lemma "radix_div_vNum")
             (inst -1 "b")
             (rewrite "integers.closed_neg"))
            ("2" (assert))))))
        ("2" (assert)) ("3" (lemma "radix_div_vNum") (inst -1 "b"))))))
    ("3" (lemma "even_iff_odd_succ") (inst -1 " Fnum(p)") (assert))
    ("4" (lemma "even_iff_odd_succ") (inst -1 " Fnum(p)") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "vNum")
   (case-replace "radix ^ Prec(b) / radix=radix ^ (Prec(b)-1)")
   (("1"
     (case "even?(radix ^ Prec(b))")
     (("1"
       (lemma "expt_even")
       (inst-cp -1 "Prec(b)-2")
       (("1" (inst -1 "Prec(b)-1") (("1" (grind-reals)) ("2" (assert))))
        ("2" (assert))))
      ("2"
       (lemma "odd_iff_even_succ")
       (inst -1 "radix ^ Prec(b) - 1")
       (grind-reals))))
    ("2" (rewrite "expt_div" :dir rl) (rewrite "expt_x1"))
    ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fsucc")
   (grind-reals)
   (("1" (rewrite "OddFsuccEven_aux"))
    ("2"
     (lemma "OddFsuccEven_aux")
     (rewrite "minus_even_is_even")
     (case "odd?((vNum(b) / radix))")
     (("1"
       (hide -4 2 3)
       (case-replace "even?((vNum(b) - 1))= NOT odd?((vNum(b) - 1))")
       (("1"
         (case-replace
          "odd?((vNum(b) / radix))=NOT even?((vNum(b) / radix))")
         (("1" (inst? -4) (assert))
          ("2"
           (lemma "odd_iff_not_even" :subst ("x" "(vNum(b) / radix)"))
           (grind-reals))))
        ("2"
         (lemma "even_iff_not_odd" :subst ("x" "(vNum(b) - 1)"))
         (grind-reals))))
      ("2"
       (div-by -4 "radix")
       (replace -4 -3)
       (hide-all-but (-3 1))
       (case "(vNum(b) / radix)=-(-(vNum(b) / radix))")
       (("1"
         (replaces -1 1)
         (rewrite "minus_odd_is_odd")
         (rewrite "integers.closed_neg"))
        ("2" (assert))))
      ("3" (lemma "radix_div_vNum") (inst -1 "b"))))
    ("3" (lemma "odd_iff_even_succ" :subst ("x" "Fnum(p)")) (assert))
    ("4" (lemma "odd_iff_even_succ" :subst ("x" "Fnum(p)")) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand* "isMin?" "isMax?")
   (skeep)
   (rewrite "FoppCorrect")
   (split)
   (("1" (grind-reals))
    ("2"
     (skosimp*)
     (case "FtoR(Fopp(f!1)) <= FtoR(p)")
     (("1" (rewrite "FoppCorrect") (grind-reals))
      ("2"
       (hide 2)
       (rewrite -4)
       (("1" (rewrite "FoppCorrect") (grind-reals))
        ("2" (rewrite "FoppBounded"))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand* "isMin?" "isMax?")
   (skeep)
   (rewrite "FoppCorrect")
   (split)
   (("1" (grind-reals))
    ("2"
     (skosimp*)
     (case "FtoR(p) <= FtoR(Fopp(f!1))")
     (("1" (rewrite "FoppCorrect") (grind-reals))
      ("2"
       (rewrite -4)
       (("1" (rewrite "FoppCorrect") (grind-reals))
        ("2" (rewrite "FoppBounded"))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Closest?")
   (skosimp*)
   (inst -2 "Fopp(f!1)")
   (("1"
     (rewrite "FoppCorrect")
     (rewrite "FoppCorrect")
     (expand "abs")
     (grind-reals))
    ("2" (rewrite "FoppBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "RoundedMode?")
   (expand "MinOrMax?")
   (flatten)
   (inst -4 "r!1" "f!1")
   (split)
   (("1"
     (expand "isMin?")
     (flatten)
     (inst -2 "(# Fnum:=0, Fexp:=0 #)")
     (("1" (expand "FtoR") (grind-reals))
      ("2" (expand "Fbounded?") (expand "abs") (grind-reals))))
    ("2" (expand "isMax?") (flatten) (grind-reals)) ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "RoundedMode?")
   (expand "MinOrMax?")
   (flatten)
   (inst -4 "r!1" "f!1")
   (split)
   (("1" (expand "isMin?") (flatten) (grind-reals))
    ("2"
     (expand "isMax?")
     (flatten)
     (inst -2 "(# Fnum:=0, Fexp:=0 #)")
     (("1" (expand "FtoR") (grind-reals))
      ("2" (expand "Fbounded?") (expand "abs") (grind-reals))))
    ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (rewrite "RND_aux_alt_def")
   (expand "RND_aux_alt")
   (grind-reals)
   (("1"
     (expand "FtoR")
     (case "floor(x * radix ^ (dExp(b))) * radix ^ -dExp(b) <= (x * radix ^ (dExp(b))) * radix ^ -dExp(b)")
     (("1"
       (case "(x * radix ^ (dExp(b))) * radix ^ -dExp(b) <= x")
       (("1" (grind-reals))
        ("2" (hide-all-but 1) (rewrite "expt_inverse") (field))))
      ("2"
       (hide-all-but 1)
       (div-by 1 "radix ^ -dExp(b)")
       (grind-reals))))
    ("2"
     (flip-ineq 1)
     (expand "FtoR")
     (case "floor(x * radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix)))) *
                           radix ^ floor(ln(x * radix / vNum(b)) / ln(radix)) <= (x * radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix)))) *
                           radix ^ floor(ln(x * radix / vNum(b)) / ln(radix))")
     (("1"
       (case "(x * radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix)))) *
                                radix ^ floor(ln(x * radix / vNum(b)) / ln(radix)) <= x")
       (("1" (grind-reals))
        ("2" (hide 2 -1) (rewrite "expt_inverse") (field))))
      ("2"
       (hide 2)
       (div-by 1 "radix ^ floor(ln(x * radix / vNum(b)) / ln(radix))")
       (grind-reals))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (rewrite "RND_aux_alt_def")
   (expand "RND_aux_alt")
   (lift-if)
   (split +)
   (("1"
     (flatten)
     (expand "Fsucc")
     (lift-if)
     (split +)
     (("1"
       (flatten)
       (expand "FtoR")
       (case-replace
        "vNum(b) / radix * radix ^ (1 - dExp(b))=radix*(radix ^ (-dExp(b) - 1) * vNum(b))")
       (("1"
         (case "radix ^ (-dExp(b) - 1) * vNum(b) <= radix * (radix ^ (-dExp(b) - 1) * vNum(b))")
         (("1" (grind-reals))
          ("2"
           (hide-all-but 1)
           (div-by 1 "radix ^ (-dExp(b) - 1)*vNum(b)")
           (assert))))
        ("2"
         (hide-all-but 1)
         (rewrite "expt_div" :dir rl)
         (rewrite "expt_div" :dir rl)
         (rewrite "expt_inverse")
         (field))
        ("3" (assert))))
      ("2"
       (flatten)
       (expand "FtoR")
       (rewrite "expt_inverse")
       (field 2))))
    ("2"
     (flatten)
     (flip-ineq 1)
     (expand "Fsucc")
     (lift-if)
     (split +)
     (("1"
       (flatten)
       (expand "FtoR")
       (rewrite "expt_plus")
       (field 1)
       (mult-by 1
        "radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix)))")
       (case-replace
        "(vNum(b) * (radix ^ floor(ln(x * radix / vNum(b)) / ln(radix)))) *
                                              radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix)))=vNum(b)")
       (("1" (grind-reals))
        ("2" (hide-all-but 1) (rewrite "expt_inverse") (field))))
      ("2"
       (flatten)
       (split 2)
       (("1" (flatten) (expand "FtoR") (grind-reals))
        ("2"
         (flatten)
         (expand "FtoR")
         (mult-by 2
          "radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix)))")
         (invoke
          (case-replace
           "%1 = floor(x * radix ^ (-floor(ln(x * radix / vNum(b)) / ln(radix))))+1")
          (! 1 r))
         (("1" (grind-reals))
          ("2" (hide-all-but 2) (rewrite "expt_inverse") (field))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_Min")
   (grind-reals)
   (("1"
     (expand "isMin?")
     (split)
     (("1" (rewrite "RND_aux_le"))
      ("2"
       (skosimp*)
       (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
       (("1"
         (case-replace "RND_aux(b)(r)=Fpred(b)(Fsucc(b)(RND_aux(b)(r)))")
         (("1"
           (rewrite "FpredProp")
           (("1"
             (case "r < FtoR(Fsucc(b)(RND_aux(b)(r)))")
             (("1" (grind-reals)) ("2" (rewrite "RND_aux_ge"))))
            ("2" (rewrite "FsuccCanonic"))))
          ("2" (rewrite "FpredFsucc"))))
        ("2" (assert))))))
    ("2" (flip-ineq 1) (expand "isMin?") (skosimp*) (grind-reals))
    ("3"
     (expand "isMin?")
     (flip-ineq 1)
     (rewrite "FpredFoppFsucc")
     (rewrite "FoppCorrect")
     (rewrite "FoppCorrect")
     (split)
     (("1"
       (case "-r < FtoR(Fsucc(b)(RND_aux(b)(-r)))")
       (("1" (grind-reals)) ("2" (rewrite "RND_aux_ge"))))
      ("2"
       (skosimp*)
       (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
       (("1"
         (case "FtoR(Fsucc(b)(RND_aux(b)(-r))) <= FtoR(Fopp(Fnormalize(b)(f!1)))")
         (("1" (rewrite "FoppCorrect") (grind-reals))
          ("2"
           (rewrite "FsuccProp")
           (("1"
             (case "-r <= FtoR(Fopp(Fnormalize(b)(f!1)))")
             (("1"
               (case "FtoR(RND_aux(b)(-r)) < -r")
               (("1" (grind-reals))
                ("2"
                 (case "FtoR(RND_aux(b)(-r)) <= -r")
                 (("1" (grind-reals)) ("2" (rewrite "RND_aux_le"))))))
              ("2" (rewrite "FoppCorrect") (grind-reals))))
            ("2"
             (lemma "FcanonicOpp")
             (inst -1 "b" "Fnormalize(b)(f!1)")
             (assert))))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_Max")
   (case-replace "r=--r")
   (("1"
     (rewrite "MinOppMax")
     (("1" (rewrite -1 :dir rl) (rewrite "RND_Min_isMin"))
      ("2" (rewrite "FcanonicBounded"))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_aux_float")
   (expand "RND_aux")
   (lift-if)
   (lift-if)
   (lift-if)
   (assert)
   (ground)
   (("1"
     (expand "FtoR")
     (lemma "expt_plus")
     (inst - "dExp(b)" "Fexp(f)" "radix")
     (assert))
    ("2"
     (hide 1)
     (expand "FtoR")
     (mult-by -1 "radix^Fexp(f)")
     (rewrite "expt_plus" :dir rl)
     (expand "vNum")
     (rewrite "expt_plus" :dir rl)
     (assert))
    ("3"
     (hide 1)
     (expand "FtoR")
     (expand "vNum")
     (rewrite "expt_plus" :dir rl)
     (mult-by -1 "radix^Fexp(f)")
     (rewrite "expt_plus" :dir rl)
     (assert))
    ("4"
     (hide 1)
     (expand "FtoR")
     (expand "vNum")
     (rewrite "expt_plus" :dir rl)
     (mult-by 1 "radix^Fexp(f)")
     (rewrite "expt_plus" :dir rl)
     (assert))
    ("5"
     (hide 1)
     (expand "FtoR")
     (expand "vNum")
     (rewrite "expt_plus" :dir rl)
     (mult-by 1 "radix^Fexp(f)")
     (rewrite "expt_plus" :dir rl)
     (assert))
    ("6"
     (case "FORALL (eg1:real,eg2:real): eg1 = eg2 IMPLIES floor(eg1) = floor(eg2)")
     (("1"
       (inst?)
       (ground)
       (hide 2)
       (expand "FtoR")
       (invoke (case "%1 = %2 * (%3)") (! 1 1 2) (! 1 2 2) (! 1 2 3))
       (("1" (assert))
        ("2"
         (hide 2)
         (rewrite "expt_plus" :dir rl)
         (assert)
         (case "Fnum(f) * radix ^ (1 + dExp(b) + Fexp(f) - Prec(b)) = Fnum(f) * radix ^ (Fexp(f)) *
                                     radix ^ (1 + dExp(b) - Prec(b))")
         (("1" (assert))
          ("2"
           (hide 2)
           (invoke (case "%1 = %2 * (%3)") (! 1 1 2) (! 1 2 2) (! 1 2 3))
           (("1" (assert))
            ("2" (hide 2) (rewrite "expt_plus" :dir rl))))))))
      ("2" (hide-all-but 1) (skosimp*) (assert))))
    ("7"
     (hide 2)
     (expand "FtoR")
     (lemma "expt_plus")
     (inst - "Fexp(f)" "1+dExp(b)-Prec(b)" "radix")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_float_Min")
   (expand "RND_Min")
   (assert)
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (ground)
   (("1" (rewrite "RND_aux_float_def"))
    ("2" (expand "FtoR") (mult-by -2 "radix^(Fexp(f))") (assert))
    ("3" (expand "FtoR") (mult-by -1 "radix^(Fexp(f))") (assert))
    ("4" (expand "FtoR") (mult-by 2 "radix^(Fexp(f))") (assert))
    ("5"
     (case "-FtoR(f) = FtoR(-f)")
     (("1"
       (replace -1)
       (rewrite "RND_aux_float_def" +)
       (hide -)
       (hide 2)
       (expand "-")
       (expand "Fopp")
       (assert))
      ("2" (hide-all-but 1) (grind))))
    ("6"
     (case "-FtoR(f) = FtoR(-f)")
     (("1"
       (replace -1)
       (hide -1)
       (rewrite "RND_aux_float_def" -)
       (hide-all-but (1 5))
       (grind))
      ("2" (hide-all-but 1) (grind))))
    ("7" (expand "FtoR") (mult-by 3 "radix^(Fexp(f))") (assert))
    ("8"
     (case "-FtoR(f) = FtoR(-f)")
     (("1"
       (replace -1)
       (lemma "RND_aux_float_def")
       (inst - "b" "-f")
       (assert)
       (hide-all-but (1 5))
       (grind))
      ("2" (hide-all-but 1) (grind))))
    ("9"
     (case "-FtoR(f) = FtoR(-f)")
     (("1"
       (replaces -1)
       (rewrite "RND_aux_float_def" +)
       (hide-all-but (1 6))
       (grind))
      ("2" (hide-all-but 1) (grind))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_Max")
   (expand "RND_float_Max")
   (rewrite "RND_float_Min_def")
   (case "-FtoR(f) = FtoR(-f)")
   (("1" (assert)) ("2" (hide 2) (grind))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (ground)
   (("1"
     (expand ">=" -1)
     (rewrite "FleCorrect")
     (rewrite "RND_float_Min_def")
     (lemma "RND_Min_isMin")
     (inst?)
     (expand "isMin?")
     (flatten)
     (expand ">=" +)
     (rewrite "FleCorrect")
     (assert))
    ("2"
     (expand ">=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "RND_float_Min_def")
     (lemma "RND_Min_isMin")
     (inst?)
     (expand "isMin?")
     (flatten)
     (inst - "g")
     (("1" (assert))
      ("2"
       (expand "Fcanonic?")
       (ground)
       (("1" (expand "Fnormal?") (propax))
        ("2" (expand "Fsubnormal?") (propax))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (ground)
   (("1"
     (expand "<=" -1)
     (rewrite "FleCorrect")
     (rewrite "RND_float_Max_def")
     (lemma "RND_Max_isMax")
     (inst?)
     (expand "isMax?")
     (flatten)
     (expand "<=" +)
     (rewrite "FleCorrect")
     (assert))
    ("2"
     (expand "<=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "RND_float_Max_def")
     (lemma "RND_Max_isMax")
     (inst?)
     (expand "isMax?")
     (flatten)
     (inst - "g")
     (("1" (assert))
      ("2"
       (expand "Fcanonic?")
       (ground)
       (("1" (expand "Fnormal?") (propax))
        ("2" (expand "Fsubnormal?") (propax))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "FcanonicUnique")
   (inst?)
   (inst - "b")
   (assert)
   (hide 2)
   (lemma "RND_float_Min_ge_canonic")
   (inst?)
   (inst - "f")
   (assert)
   (expand ">=")
   (rewrite "FleCorrect")
   (rewrite "FleCorrect")
   (assert)
   (case "FtoR(RND_float_Min(b)(f)) <= FtoR(f)")
   (("1" (assert))
    ("2"
     (hide 2)
     (rewrite "RND_float_Min_def" +)
     (lemma "RND_Min_isMin")
     (inst?)
     (expand "isMin?")
     (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "FcanonicUnique")
   (inst?)
   (inst - "b")
   (assert)
   (hide 2)
   (lemma "RND_float_Max_le_canonic")
   (inst?)
   (inst - "f")
   (assert)
   (expand "<=")
   (rewrite "FleCorrect")
   (rewrite "FleCorrect")
   (assert)
   (case "FtoR(RND_float_Max(b)(f)) >= FtoR(f)")
   (("1" (assert))
    ("2"
     (hide 2)
     (rewrite "RND_float_Max_def" +)
     (lemma "RND_Max_isMax")
     (inst?)
     (expand "isMax?")
     (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_float_Min_ge_canonic")
   (inst - "b" "f" "RND_float_Min(b)(g)")
   (assert)
   (hide 2)
   (expand ">=")
   (rewrite "FleCorrect")
   (rewrite "FleCorrect")
   (rewrite "RND_float_Min_def")
   (lemma "RND_Min_isMin")
   (inst?)
   (expand "isMin?")
   (ground))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_float_Min_ge_canonic")
   (inst - "b" "g" "RND_float_Min(b)(f)")
   (assert)
   (ground)
   (("1" (expand ">=") (expand "<=") (propax))
    ("2"
     (hide (2 3))
     (expand ">=")
     (expand "<=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "RND_float_Min_def")
     (lemma "RND_Min_isMin")
     (inst?)
     (expand "isMin?")
     (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_float_Max")
   (lemma "RND_float_Min_le")
   (inst - "b" "-f" "-g")
   (split -)
   (("1"
     (expand "<=")
     (expand ">=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "FoppCorrect")
     (rewrite "FoppCorrect")
     (assert))
    ("2" (hide 2) (grind))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_float_Max")
   (lemma "RND_float_Min_ge")
   (inst - "b" "-f" "-g")
   (split -)
   (("1"
     (expand "<=")
     (expand ">=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (rewrite "FoppCorrect")
     (rewrite "FoppCorrect")
     (assert))
    ("2" (hide 2) (grind))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (ground)
   (("1"
     (lemma "RND_float_Min_ge")
     (inst - "b" "f" "g")
     (split -)
     (("1"
       (case "FtoR(g) = FtoR(RND_float_Min(b)(g))")
       (("1"
         (expand ">=")
         (expand "<")
         (rewrite "FleCorrect")
         (rewrite "FltCorrect")
         (assert))
        ("2"
         (hide (-1 -2))
         (rewrite "RND_float_Min_def")
         (lemma "RND_Min_isMin")
         (inst?)
         (expand "isMin?")
         (flatten)
         (inst - "g")
         (("1" (assert))
          ("2"
           (expand "Fcanonic?")
           (expand "Fnormal?")
           (expand "Fsubnormal?")
           (ground))))))
      ("2"
       (hide -)
       (expand ">=")
       (expand "<")
       (rewrite "FleCorrect")
       (rewrite "FltCorrect")
       (assert))))
    ("2"
     (expand "<")
     (rewrite "FltCorrect")
     (rewrite "FltCorrect")
     (rewrite "RND_float_Min_def")
     (lemma "RND_Min_isMin")
     (inst?)
     (expand "isMin?")
     (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (ground)
   (("1"
     (lemma "RND_float_Max_le")
     (inst - "b" "f" "g")
     (split -)
     (("1"
       (case "FtoR(g) = FtoR(RND_float_Max(b)(g))")
       (("1"
         (expand "<=")
         (expand ">")
         (rewrite "FleCorrect")
         (rewrite "FltCorrect")
         (assert))
        ("2"
         (hide (-1 -2))
         (rewrite "RND_float_Max_def")
         (lemma "RND_Max_isMax")
         (inst?)
         (expand "isMax?")
         (flatten)
         (inst - "g")
         (("1" (assert))
          ("2"
           (expand "Fcanonic?")
           (expand "Fnormal?")
           (expand "Fsubnormal?")
           (ground))))))
      ("2"
       (hide -)
       (expand "<=")
       (expand ">")
       (rewrite "FleCorrect")
       (rewrite "FltCorrect")
       (assert))))
    ("2"
     (expand ">")
     (rewrite "FltCorrect")
     (rewrite "FltCorrect")
     (rewrite "RND_float_Max_def")
     (lemma "RND_Max_isMax")
     (inst?)
     (expand "isMax?")
     (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_float_Min_ge")
   (inst - "b" "f" "float_int(0)")
   (assert)
   (case "FtoR(RND_float_Min(b)(float_int(0))) = 0")
   (("1"
     (expand ">=")
     (expand ">=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (assert)
     (rewrite "RND_float_Min_def")
     (rewrite "RND_float_Min_def")
     (lemma "RND_Min_isMin")
     (inst-cp - "b" "FtoR(float_int(0))")
     (inst - "b" "FtoR(f)")
     (assert)
     (expand "isMin?")
     (ground)
     (inst - "float_int(0)")
     (("1" (ground) (expand "FtoR" + 1) (expand "float_int" 1) (assert))
      ("2"
       (expand "Fbounded?" 1)
       (assert)
       (expand "float_int" 1)
       (assert)
       (rewrite "abs_0")
       (assert)
       (typepred "dExp(b)")
       (assert))))
    ("2"
     (hide-all-but 1)
     (expand "float_int")
     (expand "RND_float_Min")
     (expand "RND_aux_float")
     (lift-if)
     (ground)
     (rewrite "floor_int")
     (assert)
     (expand "FtoR")
     (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_float_Min_lt_canonic")
   (inst - "b" "f" "RND_float_Min(b)(float_int(0))")
   (assert)
   (expand "<")
   (rewrite "FltCorrect")
   (rewrite "FltCorrect")
   (case "FtoR(RND_float_Min(b)(float_int(0))) = 0")
   (("1" (replaces -1))
    ("2"
     (hide-all-but 1)
     (rewrite "RND_float_Min_def")
     (case "FtoR(float_int(0)) = 0")
     (("1"
       (replace -1)
       (hide -1)
       (expand "RND_Min")
       (expand "RND_aux")
       (assert)
       (lift-if)
       (ground)
       (rewrite "floor_int")
       (expand "FtoR")
       (propax))
      ("2" (hide 2) (grind))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_float_Max_le")
   (inst - "b" "f" "float_int(0)")
   (assert)
   (case "FtoR(RND_float_Max(b)(float_int(0))) = 0")
   (("1"
     (expand "<=")
     (expand "<=")
     (rewrite "FleCorrect")
     (rewrite "FleCorrect")
     (assert)
     (rewrite "RND_float_Max_def")
     (rewrite "RND_float_Max_def")
     (lemma "RND_Max_isMax")
     (inst-cp - "b" "FtoR(float_int(0))")
     (inst - "b" "FtoR(f)")
     (assert)
     (expand "isMax?")
     (ground)
     (("1"
       (inst - "float_int(0)")
       (("1"
         (ground)
         (expand "FtoR" + 1)
         (expand "float_int" 1)
         (expand "FtoR" 1)
         (assert)
         (expand "FtoR" -1)
         (assert))
        ("2"
         (hide-all-but 1)
         (expand "Fbounded?" 1)
         (assert)
         (expand "float_int" 1)
         (assert)
         (rewrite "abs_0")
         (assert)
         (typepred "dExp(b)")
         (assert))))
      ("2"
       (replace -1)
       (hide-all-but 2)
       (expand "RND_Max")
       (expand "RND_Min")
       (expand "RND_aux")
       (assert)
       (ground)
       (expand "Fopp")
       (rewrite "floor_int")
       (assert)
       (expand "FtoR")
       (assert))))
    ("2"
     (hide-all-but 1)
     (expand "RND_float_Max")
     (expand "RND_float_Min")
     (lift-if)
     (ground)
     (("1"
       (expand "RND_aux_float")
       (lift-if)
       (ground)
       (("1"
         (expand "float_int")
         (hide -)
         (rewrite "floor_int")
         (("1" (grind)) ("2" (hide 2) (grind))))
        ("2" (hide 2) (grind))))
      ("2" (hide-all-but 2) (grind)) ("3" (hide-all-but 3) (grind))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_float_Min_gt_canonic")
   (inst - "b" "f" "RND_float_Min(b)(float_int(0))")
   (assert)
   (expand ">")
   (rewrite "FltCorrect")
   (rewrite "FltCorrect")
   (case "FtoR(RND_float_Min(b)(float_int(0))) = 0")
   (("1" (replaces -1) (ground))
    ("2"
     (hide-all-but 1)
     (rewrite "RND_float_Min_def")
     (case "FtoR(float_int(0)) = 0")
     (("1"
       (replace -1)
       (hide -1)
       (expand "RND_Min")
       (expand "RND_aux")
       (assert)
       (lift-if)
       (ground)
       (rewrite "floor_int")
       (expand "FtoR")
       (propax))
      ("2" (hide 2) (grind))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "FcanonicUnique")
   (skeep)
   (inst?)
   (inst - "b")
   (assert)
   (hide 2)
   (rewrite "RND_float_Min_def")
   (expand "*")
   (rewrite "FmultCorrect")
   (typepred "Fnormalize(b)(float_int(1))")
   (replace -2)
   (rewrite "float_int_def" +)
   (assert)
   (rewrite "RND_float_Min_def" :dir rl)
   (lemma "RND_float_Min_canonic")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "FcanonicUnique")
   (skeep)
   (inst?)
   (inst - "b")
   (assert)
   (hide 2)
   (rewrite "RND_float_Max_def")
   (expand "*")
   (rewrite "FmultCorrect")
   (typepred "Fnormalize(b)(float_int(1))")
   (replace -2)
   (rewrite "float_int_def" +)
   (assert)
   (rewrite "RND_float_Max_def" :dir rl)
   (lemma "RND_float_Max_canonic")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "FcanonicUnique")
   (skeep)
   (inst?)
   (inst - "b")
   (assert)
   (hide 2)
   (rewrite "RND_float_Min_def")
   (expand "+")
   (rewrite "FplusCorrect")
   (typepred "Fnormalize(b)(float_int(0))")
   (replace -2)
   (rewrite "float_int_def" +)
   (assert)
   (rewrite "RND_float_Min_def" :dir rl)
   (lemma "RND_float_Min_canonic")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "FcanonicUnique")
   (skeep)
   (inst?)
   (inst - "b")
   (assert)
   (hide 2)
   (rewrite "RND_float_Max_def")
   (expand "+")
   (rewrite "FplusCorrect")
   (typepred "Fnormalize(b)(float_int(0))")
   (replace -2)
   (rewrite "float_int_def" +)
   (assert)
   (rewrite "RND_float_Max_def" :dir rl)
   (lemma "RND_float_Max_canonic")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "FcanonicUnique")
   (inst -1 "b" "q" "Fsucc(b)(p)")
   (rewrite -1)
   (("1"
     (hide -1 3)
     (expand* "isMin?" "isMax?")
     (flatten)
     (case "FtoR(Fsucc(b)(p)) <= FtoR(q)")
     (("1"
       (case "FtoR(q) <= FtoR(Fsucc(b)(p))")
       (("1" (assert))
        ("2"
         (hide -1 3)
         (lemma "FpredLe")
         (inst -1 "b" "q" "Fsucc(b)(p)")
         (split -1)
         (("1"
           (flatten)
           (rewrite -2)
           (rewrite "FpredFsucc")
           (rewrite -4)
           (("1"
             (flip-ineq 1)
             (lemma "FpredLt")
             (inst -1 "b" "q")
             (flip-ineq -1)
             (hide 2 3 4)
             (inst -7 "Fpred(b)(q)")
             (("1" (assert))
              ("2"
               (rewrite "FcanonicBounded")
               (rewrite "FpredCanonic"))))
            ("2" (rewrite "FcanonicBounded") (rewrite "FpredCanonic"))))
          ("2" (rewrite "FsuccCanonic")) ("3" (propax))))))
      ("2" (rewrite "FsuccProp"))))
    ("2" (rewrite "FsuccCanonic"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Closest?")
   (skosimp*)
   (expand "abs" 1 2)
   (grind-reals)
   (("1"
     (expand "isMin?")
     (flatten)
     (inst -5 "f!1")
     (hide (-1 -2 -3 -7))
     (expand "abs" +)
     (lift-if)
     (ground)
     (("1"
       (expand "abs")
       (assert)
       (lift-if)
       (split -)
       (("1" (flatten) (assert)) ("2" (flatten) (assert))))
      ("2"
       (expand "abs" -3 1)
       (case "abs(FtoR(p) - r) = r - FtoR(p)")
       (("1" (replaces -1) (expand "abs") (assert))
        ("2"
         (hide-all-but (-2 1))
         (case "FORALL (xrp:nnreal): abs(-xrp)=xrp")
         (("1" (inst - "r-FtoR(p)") (replace -1) (propax))
          ("2" (hide-all-but 1) (grind))))))))
    ("2"
     (expand "abs" +)
     (assert)
     (lift-if)
     (hide (-1 -2 -3 -4))
     (expand "isMax?")
     (flatten)
     (inst - "f!1")
     (grind :exclude "FtoR"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "Total?")
   (skeep)
   (inst 1 "RND_Min(b)(r)")
   (("1" (rewrite "RND_Min_isMin")) ("2" (rewrite "FcanonicBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand* "Compatible?" "isMin?")
   (skosimp*)
   (split)
   (("1" (grind-reals)) ("2" (skeep) (inst? -3) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "RoundedMode?")
   (skeep)
   (split)
   (("1" (rewrite "isMin_Total")) ("2" (rewrite "isMin_Compatible"))
    ("3" (expand "MinOrMax?") (skeep)) ("4" (rewrite "isMin_Monotone"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand* "Unique?" "isMin?")
   (skosimp*)
   (case "FtoR(f1!1) <= FtoR(f2!1)")
   (("1"
     (case "FtoR(f2!1) <= FtoR(f1!1)")
     (("1" (assert)) ("2" (rewrite -3))))
    ("2" (rewrite -4))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "Total?")
   (skeep)
   (skeep)
   (inst 1 "Fopp(RND_Min(b)(-r))")
   (("1"
     (case-replace "r=--r")
     (("1"
       (rewrite "MinOppMax")
       (("1" (rewrite "RND_Min_isMin"))
        ("2" (rewrite "FcanonicBounded"))))
      ("2" (assert))))
    ("2" (rewrite "FoppBounded") (rewrite "FcanonicBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand* "Compatible?" "isMax?")
   (skosimp*)
   (split)
   (("1" (grind-reals)) ("2" (skeep) (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand* "RoundedMode?")
   (skeep)
   (split)
   (("1" (rewrite "isMax_Total")) ("2" (rewrite "isMax_Compatible"))
    ("3" (expand "MinOrMax?") (skeep)) ("4" (rewrite "isMax_Monotone"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand* "Unique?" "isMax?")
   (skosimp*)
   (case "FtoR(f1!1) <= FtoR(f2!1)")
   (("1"
     (case "FtoR(f2!1) <= FtoR(f1!1)")
     (("1" (assert)) ("2" (grind-reals))))
    ("2" (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "Total?")
   (skeep)
   (expand "ToZero?")
   (grind-reals)
   (case "0 <= r")
   (("1"
     (assert)
     (lemma "isMin_Total")
     (expand "Total?")
     (inst -1 "b" "r"))
    ("2"
     (assert)
     (lemma "isMax_Total")
     (expand "Total?")
     (inst -1 "b" "r"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Compatible?")
   (skosimp*)
   (expand "ToZero?")
   (grind-reals)
   (("1"
     (lemma "isMin_Compatible")
     (expand "Compatible?")
     (inst -1 "b!1" "r1!1" "r2!1" "f1!1" "f2!1")
     (assert))
    ("2"
     (lemma "isMax_Compatible")
     (expand "Compatible?")
     (inst -1 "b!1" "r1!1" "r2!1" "f1!1" "f2!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Monotone?")
   (skeep)
   (skeep)
   (expand "ToZero?")
   (grind-reals)
   (("1"
     (lemma "isMin_Monotone")
     (expand "Monotone?")
     (inst -1 "b" "r1" "r2" "f1" "f2")
     (assert))
    ("2"
     (flip-ineq 1)
     (case " FtoR(f1) <=0")
     (("1"
       (case "0<= FtoR(f2)")
       (("1" (assert))
        ("2"
         (hide -1 -2 -3 -4 2)
         (expand "isMin?")
         (flatten)
         (inst -3 "(# Fnum:=0, Fexp:=0#)")
         (("1" (expand* "FtoR") (grind-reals))
          ("2"
           (expand "Fbounded?")
           (grind-reals)
           (expand "abs" 1)
           (grind-reals))))))
      ("2"
       (hide -2 -4 -5 2)
       (expand "isMax?")
       (flatten)
       (inst -3 "(# Fnum:=0, Fexp:=0#)")
       (("1" (expand* "FtoR") (grind-reals))
        ("2"
         (expand "Fbounded?")
         (grind-reals)
         (expand "abs" 1)
         (grind-reals))))))
    ("3"
     (lemma "isMax_Monotone")
     (expand "Monotone?")
     (inst -1 "b" "r1" "r2" "f1" "f2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RoundedMode?")
   (split)
   (("1" (rewrite "ToZero_Total")) ("2" (rewrite "ToZero_Compatible"))
    ("3" (rewrite "ToZero_MinOrMax")) ("4" (rewrite "ToZero_Monotone"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Unique?")
   (skeep)
   (skeep)
   (expand "ToZero?")
   (grind-reals)
   (("1"
     (lemma "isMin_Unique")
     (expand "Unique?")
     (inst -1 "b" "r" "f1" "f2")
     (assert))
    ("2"
     (lemma "isMax_Unique")
     (expand "Unique?")
     (inst -1 "b" "r" "f1" "f2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "isMin_Total")
   (lemma "isMax_Total")
   (expand "Total?")
   (skeep)
   (inst -1 "b" "r")
   (inst -2 "b" "r")
   (skosimp*)
   (case "abs(FtoR(f!1)-r)<= abs(FtoR(f!2)-r)")
   (("1"
     (inst 1 "f!1")
     (expand "Closest?")
     (skosimp*)
     (expand* "isMin?" "isMax?")
     (flatten)
     (case " FtoR(f!3) <= r")
     (("1" (expand* "abs") (grind-reals))
      ("2" (expand* "abs") (grind-reals))))
    ("2"
     (flip-ineq 1)
     (inst 1 "f!2")
     (expand* "Closest?" "isMin?" "isMax?")
     (flatten)
     (skosimp*)
     (case "FtoR(f!3) <= r")
     (("1" (expand* "abs") (grind-reals))
      ("2" (expand* "abs") (grind-reals))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Compatible?")
   (skeep)
   (skeep)
   (expand "Closest?")
   (skosimp*)
   (inst -1 "f!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "MinOrMax?")
   (skeep)
   (skosimp*)
   (case "r!1<= FtoR(f!1)")
   (("1"
     (hide 1)
     (expand* "isMax?" "Closest?")
     (split)
     (("1" (propax))
      ("2" (skosimp*) (inst -3 "f!2") (expand "abs" -3) (grind-reals))))
    ("2"
     (flip-ineq 1)
     (hide 2)
     (expand* "isMin?" "Closest?")
     (split)
     (("1" (assert))
      ("2" (skosimp*) (inst -3 "f!2") (expand "abs" -3) (grind-reals))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Monotone?")
   (skeep)
   (skeep)
   (expand "Closest?")
   (inst -2 "f2")
   (inst -3 "f1")
   (expand* "abs")
   (grind-reals))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RoundedMode?")
   (split)
   (("1" (rewrite "Closest_Total")) ("2" (rewrite "Closest_Compatible"))
    ("3" (rewrite "Closest_MinOrMax"))
    ("4" (rewrite "Closest_Monotone"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_EClosest")
   (grind-reals)
   (("1"
     (expand "EvenClosest?")
     (case "Closest?(b)(r, RND_Min(b)(r))")
     (("1"
       (split)
       (("1" (propax))
        ("2"
         (skosimp*)
         (lemma "Closest_MinOrMax")
         (expand "MinOrMax?")
         (inst -1 "b" "r" "f!1")
         (split)
         (("1"
           (lemma "isMin_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "f!1" "RND_Min(b)(r)")
           (assert)
           (rewrite "RND_Min_isMin"))
          ("2"
           (expand "Closest?" -2)
           (inst -2 "RND_Min(b)(r)")
           (flip-ineq -2)
           (case-replace "FtoR(f!1) = FtoR(RND_Max(b)(r))")
           (("1" (assert))
            ("2"
             (lemma "isMax_Unique")
             (expand "Unique?")
             (inst -1 "b" "r" "f!1" "RND_Max(b)(r)")
             (("1" (assert) (rewrite "RND_Max_isMax"))
              ("2" (rewrite "FcanonicBounded"))))))
          ("3" (propax))))))
      ("2"
       (hide 2)
       (lemma "RND_Min_isMin" :subst ("b" "b" "r" "r"))
       (lemma "RND_Max_isMax" :subst ("b" "b" "r" "r"))
       (expand* "isMin?" "isMax?" "Closest?")
       (flatten)
       (skosimp*)
       (case "FtoR(f!1) <= r")
       (("1" (expand "abs") (grind-reals))
        ("2" (expand "abs") (grind-reals))))
      ("3" (rewrite "FcanonicBounded"))))
    ("2"
     (hide 1)
     (expand "EvenClosest?")
     (case "Closest?(b)(r, RND_Max(b)(r))")
     (("1"
       (split)
       (("1" (propax))
        ("2"
         (skosimp*)
         (lemma "Closest_MinOrMax")
         (expand "MinOrMax?")
         (inst -1 "b" "r" "f!1")
         (split)
         (("1"
           (expand "Closest?" -2)
           (inst -2 "RND_Max(b)(r)")
           (flip-ineq -2)
           (case-replace "FtoR(f!1) = FtoR(RND_Min(b)(r))")
           (("1" (assert))
            ("2"
             (lemma "isMin_Unique")
             (expand "Unique?")
             (inst -1 "b" "r" "f!1" "RND_Min(b)(r)")
             (("1" (assert) (rewrite "RND_Min_isMin"))
              ("2" (rewrite "FcanonicBounded"))))))
          ("2"
           (lemma "isMax_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "f!1" "RND_Max(b)(r)")
           (assert)
           (rewrite "RND_Max_isMax"))
          ("3" (propax))))))
      ("2"
       (hide 2)
       (lemma "RND_Min_isMin" :subst ("b" "b" "r" "r"))
       (lemma "RND_Max_isMax" :subst ("b" "b" "r" "r"))
       (expand* "isMin?" "isMax?" "Closest?")
       (flatten)
       (skosimp*)
       (case "FtoR(f!1) <= r")
       (("1" (expand "abs") (grind-reals))
        ("2" (expand "abs") (grind-reals))))
      ("3" (rewrite "FcanonicBounded"))))
    ("3"
     (expand "EvenClosest?")
     (split)
     (("1"
       (lemma "RND_Min_isMin" :subst ("b" "b" "r" "r"))
       (lemma "RND_Max_isMax" :subst ("b" "b" "r" "r"))
       (expand* "isMin?" "isMax?" "Closest?")
       (flatten)
       (skosimp*)
       (case "FtoR(f!1) <= r")
       (("1" (expand "abs") (grind-reals))
        ("2" (expand "abs") (grind-reals))))
      ("2"
       (skosimp*)
       (lemma "MaxSuccMin")
       (lemma "OddFsuccEven")
       (inst -2 "b" "RND_Min(b)(r)" "RND_Max(b)(r)" "r")
       (split)
       (("1"
         (inst -2 "b" "RND_Min(b)(r)")
         (split -2)
         (("1"
           (case-replace "Fnormalize(b)(RND_Max(b)(r))=RND_Max(b)(r)")
           (("1" (assert))
            ("2" (rewrite "FcanonicUnique" :subst ("b" "b")))))
          ("2"
           (lemma "odd_or_even_int" :subst ("x" "Fnum(RND_Min(b)(r))"))
           (assert))
          ("3" (assert))))
        ("2" (propax)) ("3" (rewrite "RND_Max_isMax"))
        ("4" (rewrite "RND_Min_isMin")) ("5" (assert)) ("6" (assert))))))
    ("4"
     (hide 2)
     (expand "EvenClosest?")
     (case "Closest?(b)(r, RND_Min(b)(r))")
     (("1"
       (split)
       (("1" (propax))
        ("2"
         (skosimp*)
         (lemma "Closest_MinOrMax")
         (expand "MinOrMax?")
         (inst -1 "b" "r" "f!1")
         (split)
         (("1"
           (lemma "isMin_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "f!1" "RND_Min(b)(r)")
           (assert)
           (rewrite "RND_Min_isMin"))
          ("2"
           (lemma "isMax_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "f!1" "RND_Max(b)(r)")
           (("1" (assert) (rewrite "RND_Max_isMax"))
            ("2" (rewrite "FcanonicBounded"))))
          ("3" (propax))))))
      ("2"
       (hide 2)
       (lemma "RND_Min_isMin" :subst ("b" "b" "r" "r"))
       (lemma "RND_Max_isMax" :subst ("b" "b" "r" "r"))
       (expand* "isMin?" "isMax?" "Closest?")
       (flatten)
       (skosimp*)
       (case "FtoR(f!1) <= r")
       (("1" (expand "abs") (grind-reals))
        ("2" (expand "abs") (grind-reals))))
      ("3" (rewrite "FcanonicBounded"))))
    ("5"
     (flip-ineq 2)
     (expand "EvenClosest?")
     (case "Closest?(b)(r, RND_Min(b)(r))")
     (("1"
       (split)
       (("1" (propax))
        ("2"
         (case-replace "Fnormalize(b)(RND_Min(b)(r))=RND_Min(b)(r)")
         (("1" (assert))
          ("2" (rewrite "FcanonicUnique" :subst ("b" "b")))))))
      ("2"
       (hide 2)
       (lemma "RND_Min_isMin" :subst ("b" "b" "r" "r"))
       (lemma "RND_Max_isMax" :subst ("b" "b" "r" "r"))
       (expand* "isMin?" "isMax?" "Closest?")
       (flatten)
       (skosimp*)
       (case "FtoR(f!1) <= r")
       (("1" (expand "abs") (grind-reals))
        ("2" (expand "abs") (grind-reals))))
      ("3" (rewrite "FcanonicBounded"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "Total?")
   (skeep)
   (inst 1 "RND_EClosest(b)(r)")
   (("1" (rewrite "RND_EClosest_isEclosest"))
    ("2" (rewrite "FcanonicBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "Closest_Compatible")
   (expand "Compatible?")
   (skeep)
   (skeep)
   (expand "EvenClosest?")
   (split)
   (("1" (flatten) (inst -1 "b" "r1" "r2" "f1" "f2") (assert))
    ("2"
     (flatten)
     (split -3)
     (("1"
       (case-replace "Fnormalize(b)(f2)=Fnormalize(b)(f1)")
       (rewrite "FcanonicUnique" :subst ("b" "b")))
      ("2" (skosimp*) (inst -1 "f!1") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "Closest_MinOrMax")
   (expand "MinOrMax?")
   (skeep)
   (skeep)
   (expand "EvenClosest?")
   (flatten)
   (inst -1 "b" "r" "f")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "Closest_Monotone")
   (expand "Monotone?")
   (skeep)
   (skeep)
   (expand "EvenClosest?")
   (flatten)
   (inst -1 "b" "r1" "r2" "f1" "f2")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RoundedMode?")
   (split)
   (("1" (rewrite "EvenClosest_Total"))
    ("2" (rewrite "EvenClosest_Compatible"))
    ("3" (rewrite "EvenClosest_MinOrMax"))
    ("4" (rewrite "EvenClosest_Monotone"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Unique?")
   (skeep)
   (skeep)
   (lemma "EvenClosest_MinOrMax")
   (expand "MinOrMax?")
   (inst-cp -1 "b" "r" "f1")
   (split)
   (("1"
     (inst -2 "b" "r" "f2")
     (split)
     (("1"
       (lemma "isMin_Unique")
       (expand "Unique?")
       (inst -1 "b" "r" "f1" "f2")
       (assert))
      ("2"
       (expand "EvenClosest?")
       (flatten)
       (split)
       (("1"
         (split)
         (("1"
           (lemma "MaxSuccMin")
           (inst -1 "b" "Fnormalize(b)(f1)" "Fnormalize(b)(f2)" "r")
           (split)
           (("1"
             (case "odd?(Fnum(Fnormalize(b)(f2)))")
             (("1"
               (lemma "odd_iff_not_even")
               (inst -1 "Fnum(Fnormalize(b)(f2))")
               (assert))
              ("2" (rewrite -1) (rewrite "EvenFsuccOdd"))))
            ("2" (assert))
            ("3"
             (lemma "isMax_Compatible")
             (expand "Compatible?")
             (inst -1 "b" "r" "r" "f2" "Fnormalize(b)(f2)")
             (assert))
            ("4"
             (lemma "isMin_Compatible")
             (expand "Compatible?")
             (inst -1 "b" "r" "r" "f1" "Fnormalize(b)(f1)")
             (assert))
            ("5" (assert)) ("6" (assert))))
          ("2" (inst -1 "f1") (assert))))
        ("2" (inst -1 "f2") (assert))))
      ("3" (propax))))
    ("2"
     (inst -2 "b" "r" "f2")
     (split)
     (("1"
       (expand "EvenClosest?")
       (flatten)
       (split)
       (("1"
         (split)
         (("1"
           (lemma "MaxSuccMin")
           (inst -1 "b" "Fnormalize(b)(f2)" "Fnormalize(b)(f1)" "r")
           (split)
           (("1"
             (case "odd?(Fnum(Fnormalize(b)(f1)))")
             (("1"
               (lemma "odd_iff_not_even")
               (inst -1 "Fnum(Fnormalize(b)(f1))")
               (assert))
              ("2" (copy -2) (rewrite -2) (rewrite "EvenFsuccOdd"))))
            ("2" (assert))
            ("3"
             (lemma "isMax_Compatible")
             (expand "Compatible?")
             (inst -1 "b" "r" "r" "f1" "Fnormalize(b)(f1)")
             (assert))
            ("4"
             (lemma "isMin_Compatible")
             (expand "Compatible?")
             (inst -1 "b" "r" "r" "f2" "Fnormalize(b)(f2)")
             (assert))
            ("5" (assert)) ("6" (assert))))
          ("2" (inst -1 "f1") (assert))))
        ("2" (inst -1 "f2") (assert))))
      ("2"
       (lemma "isMax_Unique")
       (expand "Unique?")
       (inst -1 "b" "r" "f1" "f2")
       (assert))
      ("3" (propax))))
    ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "isMin_Total")
   (lemma "isMax_Total")
   (expand "Total?")
   (skeep)
   (skeep)
   (inst -1 "b" "r")
   (inst -2 "b" "r")
   (skosimp*)
   (case "abs(FtoR(f!1)-r)<abs(FtoR(f!2)-r)")
   (("1"
     (inst 1 "f!1")
     (expand "AFZClosest?")
     (case "Closest?(b)(r, f!1)")
     (("1"
       (split)
       (("1" (propax))
        ("2"
         (flatten)
         (hide 1)
         (skosimp*)
         (lemma "Closest_MinOrMax")
         (expand "MinOrMax?")
         (inst -1 "b" "r" "f!3")
         (split)
         (("1"
           (expand "Closest?" -2)
           (inst -2 "f!1")
           (flip-ineq -2)
           (case-replace "FtoR(f!3)=FtoR(f!2)")
           (("1" (assert))
            ("2"
             (lemma "isMin_Unique")
             (expand "Unique?")
             (inst -1 "b" "r" "f!3" "f!2")
             (split)
             (("1" (propax)) ("2" (propax)) ("3" (propax))))))
          ("2"
           (lemma "isMax_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "f!3" "f!1")
           (split)
           (("1" (propax)) ("2" (propax)) ("3" (propax))))
          ("3" (propax))))))
      ("2"
       (hide 2)
       (lemma "LeMinMaxClosest")
       (inst -1 "b" "f!1" "f!2" "f!1" "r")
       (split)
       (("1" (propax)) ("2" (grind-reals)) ("3" (propax)) ("4" (assert))
        ("5" (propax)) ("6" (assert)) ("7" (assert)) ("8" (assert))))))
    ("2"
     (flip-ineq 1)
     (split-ineq -1)
     (("1"
       (case "0 <= r")
       (("1"
         (inst 1 "f!1")
         (expand "AFZClosest?")
         (split)
         (("1"
           (lemma "LeMinMaxClosest")
           (inst -1 "b" "f!1" "f!2" "f!1" "r")
           (split)
           (("1" (propax)) ("2" (assert)) ("3" (propax)) ("4" (assert))
            ("5" (propax)) ("6" (assert)) ("7" (assert)) ("8" (assert))))
          ("2"
           (flatten)
           (expand "isMax?")
           (flatten)
           (expand "abs" 1)
           (grind-reals))))
        ("2"
         (flip-ineq 1)
         (inst 1 "f!2")
         (expand "AFZClosest?")
         (split)
         (("1"
           (lemma "LeMinMaxClosest")
           (inst -1 "b" "f!2" "f!2" "f!1" "r")
           (split)
           (("1" (propax)) ("2" (assert)) ("3" (propax)) ("4" (assert))
            ("5" (propax)) ("6" (assert)) ("7" (assert)) ("8" (assert))))
          ("2"
           (flatten)
           (expand "isMin?")
           (flatten)
           (expand "abs" 1)
           (grind-reals))))))
      ("2"
       (case "abs(FtoR(f!2) - r) < abs(FtoR(f!1) - r)")
       (("1"
         (hide -2 1)
         (inst 1 "f!2")
         (expand "AFZClosest?")
         (case "Closest?(b)(r, f!2)")
         (("1"
           (split)
           (("1" (propax))
            ("2"
             (flatten)
             (hide 1)
             (skosimp*)
             (lemma "Closest_MinOrMax")
             (expand "MinOrMax?")
             (inst -1 "b" "r" "f!3")
             (split)
             (("1"
               (lemma "isMin_Unique")
               (expand "Unique?")
               (inst -1 "b" "r" "f!3" "f!2")
               (split)
               (("1" (propax)) ("2" (propax)) ("3" (propax))))
              ("2"
               (expand "Closest?" -2)
               (inst -2 "f!2")
               (flip-ineq -2)
               (case-replace "FtoR(f!3)=FtoR(f!1)")
               (("1" (assert))
                ("2"
                 (lemma "isMax_Unique")
                 (expand "Unique?")
                 (inst -1 "b" "r" "f!3" "f!1")
                 (split)
                 (("1" (propax)) ("2" (propax)) ("3" (propax))))))
              ("3" (propax))))))
          ("2"
           (lemma "LeMinMaxClosest")
           (inst -1 "b" "f!2" "f!2" "f!1" "r")
           (split)
           (("1" (propax)) ("2" (assert)) ("3" (propax)) ("4" (assert))
            ("5" (propax)) ("6" (assert)) ("7" (assert))
            ("8" (assert))))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "Closest_Compatible")
   (inst -1 "b")
   (expand "Compatible?")
   (skeep)
   (expand "AFZClosest?")
   (flatten)
   (split 1)
   (("1"
     (inst -1 "r1" "r2" "f1" "f2")
     (split)
     (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))))
    ("2"
     (split)
     (("1" (flatten) (assert))
      ("2"
       (flatten)
       (hide 1)
       (skosimp*)
       (rewrite -6 :dir rl)
       (rewrite -6)
       (rewrite -1))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "Closest_MinOrMax")
   (expand "MinOrMax?")
   (skeep)
   (skosimp*)
   (inst -1 "b" "r!1" "f!1")
   (split)
   (("1" (propax)) ("2" (propax)) ("3" (expand "AFZClosest?") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "Closest_Monotone")
   (expand "Monotone?")
   (skeep)
   (skeep)
   (expand "AFZClosest?")
   (flatten)
   (inst -1 "b" "r1" "r2" "f1" "f2")
   (split)
   (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RoundedMode?")
   (split)
   (("1" (rewrite "AFZClosest_Total"))
    ("2" (rewrite "AFZClosest_Compatible"))
    ("3" (rewrite "AFZClosest_MinOrMax"))
    ("4" (rewrite "AFZClosest_Monotone"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "Unique?")
   (skeep)
   (skeep)
   (expand "AFZClosest?")
   (flatten)
   (split)
   (("1"
     (split)
     (("1"
       (lemma "Closest_MinOrMax")
       (expand "MinOrMax?")
       (inst-cp -1 "b" "r" "f1")
       (inst -1 "b" "r" "f2")
       (split)
       (("1"
         (split)
         (("1"
           (lemma "isMin_Unique")
           (expand "Unique?")
           (assert)
           (inst -1 "b" "r" "f1" "f2")
           (split)
           (("1" (propax)) ("2" (propax)) ("3" (propax))))
          ("2"
           (case "0<= r")
           (("1"
             (case "0<= FtoR(f1)")
             (("1"
               (case "0<= FtoR(f2)")
               (("1"
                 (expand "abs")
                 (grind-reals)
                 (expand* "isMin?" "isMax?")
                 (flatten)
                 (grind-reals))
                ("2"
                 (rewrite "RleRoundedR0" :subst
                  ("b" "b" "P" "isMin?" "r" "r" "f" "f2"))
                 (rewrite "isMin_RoundedMode"))))
              ("2"
               (rewrite "RleRoundedR0" :subst
                ("b" "b" "P" "isMax?" "r" "r" "f" "f1"))
               (rewrite "isMax_RoundedMode"))))
            ("2"
             (flip-ineq 1)
             (case "FtoR(f2) <= 0")
             (("1"
               (case "FtoR(f1) <= 0")
               (("1"
                 (expand "abs")
                 (grind-reals)
                 (expand* "isMin?" "isMax?")
                 (grind-reals))
                ("2"
                 (rewrite "RleRoundedLessR0" :subst
                  ("b" "b" "P" "isMax?" "r" "r" "f" "f1"))
                 (rewrite "isMax_RoundedMode"))))
              ("2"
               (rewrite "RleRoundedLessR0" :subst
                ("b" "b" "P" "isMin?" "r" "r" "f" "f2"))
               (rewrite "isMin_RoundedMode"))))))
          ("3" (propax))))
        ("2"
         (split)
         (("1"
           (case "0<=r")
           (("1"
             (case "0<=FtoR(f1)")
             (("1"
               (case "0<=FtoR(f2)")
               (("1"
                 (expand "abs")
                 (grind-reals)
                 (expand* "isMin?" "isMax?")
                 (flatten)
                 (inst -6 "f1")
                 (split)
                 (("1" (grind-reals)) ("2" (propax))))
                ("2"
                 (rewrite "RleRoundedR0" :subst
                  ("b" "b" "P" "isMax?" "r" "r" "f" "f2"))
                 (rewrite "isMax_RoundedMode"))))
              ("2"
               (rewrite "RleRoundedR0" :subst
                ("b" "b" "P" "isMin?" "r" "r" "f" "f1"))
               (rewrite "isMin_RoundedMode"))))
            ("2"
             (flip-ineq 1)
             (case "FtoR(f2) <= 0")
             (("1"
               (case "FtoR(f1) <= 0")
               (("1"
                 (expand "abs")
                 (grind-reals)
                 (expand* "isMin?" "isMax?")
                 (flatten)
                 (inst -4 "f2")
                 (split)
                 (("1" (grind-reals)) ("2" (grind-reals))))
                ("2"
                 (rewrite "RleRoundedLessR0" :subst
                  ("b" "b" "P" "isMin?" "r" "r" "f" "f1"))
                 (rewrite "isMin_RoundedMode"))))
              ("2"
               (rewrite "RleRoundedLessR0" :subst
                ("b" "b" "P" "isMax?" "r" "r" "f" "f2"))
               (rewrite "isMax_RoundedMode"))))))
          ("2"
           (lemma "isMax_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "f1" "f2")
           (split)
           (("1" (propax)) ("2" (propax)) ("3" (propax))))
          ("3" (propax))))
        ("3" (propax))))
      ("2" (rewrite -1))))
    ("2" (rewrite -1))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand* "RoundedMode?" "MinOrMax?")
   (flatten)
   (inst -5 "FtoR(f!1)" "p!1")
   (split)
   (("1" (expand "isMin?") (flatten) (inst -2 "f!1") (assert))
    ("2" (expand "isMax?") (flatten) (inst -2 "f!1") (assert))
    ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (copy -2)
   (expand "RoundedMode?" -1)
   (flatten)
   (expand "Total?")
   (inst -1 "FtoR(f!1)")
   (skosimp*)
   (expand "Compatible?")
   (inst -2 "FtoR(f!1)" "FtoR(f!1)" "f!2" "f!1")
   (assert)
   (lemma "RoundedProjectorEq")
   (inst -1 "P!1" "b!1" "f!1" "f!2")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "Fexp(Fnormalize(b)(f)) <= Fexp(p)")
   (("1"
     (inst 1 "Fnum(p)")
     (case "FtoR(f) =FtoR(p)")
     (("1" (rewrite -1) (expand "FtoR") (propax))
      ("2"
       (lemma "FsuccZleEq")
       (inst -1 "b" "Fnormalize(b)(f)" "p")
       (split)
       (("1" (assert)) ("2" (propax))
        ("3"
         (hide 2 3)
         (expand "isMin?")
         (flatten)
         (inst -4 "Fsucc(b)(Fnormalize(b)(f))")
         (("1"
           (flip-ineq 1)
           (split)
           (("1"
             (flip-ineq -1)
             (lemma "FsuccLt")
             (inst -1 "b" "Fnormalize(b)(f)")
             (assert))
            ("2" (assert))))
          ("2" (rewrite "FcanonicBounded") (rewrite "FsuccCanonic"))))
        ("4" (expand "isMin?") (flatten) (assert))))))
    ("2"
     (flip-ineq 1)
     (inst 1
      "Fnum(Fnormalize(b)(f))*radix^(Fexp(Fnormalize(b)(f))-Fexp(p))")
     (("1"
       (rewrite "FnormalizeCorrect" :dir rl :subst ("b" "b" "p" "f"))
       (expand "FtoR")
       (rewrite "expt_div" :dir rl)
       (field 1))
      ("2" (expand "^") (grind-reals)) ("3" (grind-reals))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "RoundedMode?" "MinOrMax?")
   (flatten)
   (inst -4 "FtoR(p)" "f")
   (split)
   (("1"
     (lemma "isMin_Rep")
     (inst -1 "b" "f" "p")
     (split)
     (("1" (propax)) ("2" (propax)) ("3" (propax))))
    ("2"
     (lemma "isMin_Rep")
     (inst -1 "b" "Fopp(f)" "Fopp(p)")
     (split)
     (("1" (skosimp*) (inst 1 "-m!1") (expand* "FtoR" "Fopp") (assert))
      ("2" (rewrite "FoppCorrect") (rewrite "MaxOppMin"))
      ("3" (rewrite "FoppBounded"))))
    ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "RoundedMode?")
   (expand "MinOrMax?")
   (flatten)
   (inst -4 "r" "p")
   (split)
   (("1"
     (expand "isMin?")
     (flatten)
     (case-replace "abs(FtoR(p) - r)=r-FtoR(p)")
     (("1"
       (lemma "FloatPlusUlpBounded")
       (inst -1 "b" "p")
       (split)
       (("1"
         (skosimp*)
         (inst -4 "f!1")
         (split)
         (("1"
           (flip-ineq -1)
           (rewrite -1)
           (hide-all-but 1)
           (expand "Fulp")
           (grind-reals))
          ("2" (rewrite -1) (grind-reals))))
        ("2" (propax))))
      ("2" (hide-all-but (1 -1)) (expand "abs") (grind-reals))))
    ("2"
     (expand "isMax?")
     (flatten)
     (case-replace "abs(FtoR(p) - r)=FtoR(p)-r")
     (("1"
       (lemma "FloatMinusUlpBounded")
       (inst -1 "b" "p")
       (split)
       (("1"
         (skosimp*)
         (inst -4 "f!1")
         (split)
         (("1"
           (flip-ineq -1)
           (rewrite -1)
           (hide-all-but 1)
           (expand "Fulp")
           (grind-reals))
          ("2" (rewrite -1) (grind-reals))))
        ("2" (propax))))
      ("2" (hide-all-but (1 -1)) (expand "abs") (grind-reals))))
    ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (b: Format, p: float, r: real):
                        Fbounded?(b)(p) => 0 <= r =>
                         Closest?(b)(r, p) => abs(FtoR(p) - r) <= Fulp(b)(p) / 2")
   (("1"
     (skeep)
     (case "0 <= r")
     (("1" (inst -2 "b" "p" "r") (assert))
      ("2"
       (inst -1 "b" "Fopp(p)" "-r")
       (split)
       (("1"
         (rewrite "FulpOpp")
         (case-replace "abs(FtoR(p) - r)=abs(FtoR(Fopp(p)) - -r)")
         (rewrite "FoppCorrect")
         (hide-all-but 1)
         (expand "abs")
         (grind-reals))
        ("2" (rewrite "ClosestFopp")) ("3" (grind-reals))
        ("4" (rewrite "FoppBounded"))))))
    ("2"
     (hide 2)
     (skeep)
     (case "FtoR(p) <= r")
     (("1"
       (lemma "FloatPlusUlpBounded")
       (inst -1 "b" "p")
       (split)
       (("1"
         (skosimp*)
         (mult-by 1 "2")
         (case "abs(FtoR(p) - r) <= Fulp(b)(p)- abs(FtoR(p) - r)")
         (("1" (assert))
          ("2"
           (hide 2)
           (case "abs(FtoR(f!1) - r) <= Fulp(b)(p) - abs(FtoR(p) - r)")
           (("1"
             (case "abs(FtoR(p) - r) <= abs(FtoR(f!1) - r)")
             (("1" (assert))
              ("2" (hide -1 2) (expand "Closest?") (inst -5 "f!1"))))
            ("2"
             (hide 2)
             (rewrite -1)
             (case "abs(FtoR(p)-r) < Fulp(b)(p)")
             (("1" (hide -2 -4 -6) (expand "abs") (grind-reals))
              ("2"
               (rewrite "RoundedModeUlp" :subst ("b" "b" "P" "Closest?"))
               (rewrite "Closest_RoundedMode"))))))))
        ("2" (propax))))
      ("2"
       (flip-ineq 1)
       (lemma "FloatMinusUlpBounded")
       (inst -1 "b" "p")
       (split)
       (("1"
         (skosimp*)
         (mult-by 1 "2")
         (case "abs(FtoR(p) - r) <= Fulp(b)(p)- abs(FtoR(p) - r)")
         (("1" (assert))
          ("2"
           (hide 2)
           (case "abs(FtoR(f!1) - r) <= Fulp(b)(p) - abs(FtoR(p) - r)")
           (("1"
             (case "abs(FtoR(p) - r) <= abs(FtoR(f!1) - r)")
             (("1" (assert))
              ("2" (hide 2) (expand "Closest?") (inst -6 "f!1"))))
            ("2"
             (hide 2)
             (copy -2)
             (rewrite -2)
             (case "abs(FtoR(p)-r) < Fulp(b)(p)")
             (("1" (hide -3 -4 -6) (expand "abs") (grind-reals))
              ("2"
               (rewrite "RoundedModeUlp" :subst ("b" "b" "P" "Closest?"))
               (rewrite "Closest_RoundedMode"))))))))
        ("2" (propax))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split-ineq -7)
   (("1" (expand "Unique?") (inst -5 "z1" "p" "q") (assert))
    ("2"
     (expand* "RoundedMode?" "Monotone?")
     (flatten)
     (inst -6 "z1" "z2" "p" "q")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (b: Format, p: float, r: real):
                               Fcanonic?(b)(p) =>
                                Closest?(b)(r, p) => 0 <= r =>
                                 r <= FtoR(p) + Fulp(b)(Fpred(b)(p)) / 2 =>
                                  abs(FtoR(p) - r) <= Fulp(b)(Fpred(b)(p)) / 2")
   (("1"
     (skeep)
     (case "0<=r")
     (("1"
       (inst -2 "b" "p" "r")
       (case "0<= FtoR(p)")
       (("1"
         (case "Fabs(p)=p")
         (("1"
           (split)
           (("1" (assert)) ("2" (expand "abs" -6) (grind-reals))
            ("3" (propax)) ("4" (propax)) ("5" (propax))))
          ("2"
           (hide-all-but (1 -1))
           (expand* "Fabs" "abs" "FtoR")
           (grind-reals)
           (decompose-equality 1))))
        ("2"
         (rewrite "RleRoundedR0" :subst ("b" "b" "P" "Closest?" "r" "r"))
         (("1" (rewrite "Closest_RoundedMode"))
          ("2" (rewrite "FcanonicBounded"))))))
      ("2"
       (flip-ineq 1)
       (inst -2 "b" "Fopp(p)" "-r")
       (case "FtoR(p) <= 0")
       (("1"
         (case "Fabs(p)=Fopp(p)")
         (("1"
           (split)
           (("1"
             (case-replace "abs(FtoR(Fopp(p)) - -r)=abs(FtoR(p) - r)")
             (("1" (assert))
              ("2"
               (rewrite "FoppCorrect")
               (expand "abs" 1)
               (grind-reals))))
            ("2"
             (expand "abs" -6)
             (grind-reals)
             (("1" (rewrite "FoppCorrect") (assert))
              ("2" (rewrite "FoppCorrect") (assert))))
            ("3" (assert))
            ("4" (rewrite "ClosestFopp") (rewrite "FcanonicBounded"))
            ("5" (lemma "FcanonicOpp") (inst -1 "b" "p") (assert))))
          ("2"
           (hide-all-but (1 -1))
           (expand* "Fabs" "Fopp" "abs" "FtoR")
           (grind-reals))))
        ("2"
         (rewrite "RleRoundedLessR0" :subst
          ("b" "b" "P" "Closest?" "r" "r"))
         (("1" (rewrite "Closest_RoundedMode"))
          ("2" (rewrite "FcanonicBounded"))))))))
    ("2"
     (hide 2)
     (skeep)
     (expand "abs" 1)
     (grind-reals)
     (flip-ineq 1)
     (copy -3)
     (expand "Closest?" -1)
     (inst -1 "Fpred(b)(p)")
     (case "FtoR(Fpred(b)(p)) - r <= 0")
     (("1"
       (expand "abs" -2)
       (grind-reals)
       (case " FtoR(p) - r -(FtoR(Fpred(b)(p)) - r) <= Fulp(b)(Fpred(b)(p))")
       (("1" (grind-reals))
        ("2" (assert) (rewrite "FpredDiff") (assert))))
      ("2"
       (hide 2)
       (flip-ineq 1)
       (flip-ineq -2)
       (expand "abs" 1)
       (grind-reals)
       (lemma "FpredLt")
       (inst -1 "b" "p")
       (assert))))
    ("3"
     (hide 2)
     (skeep)
     (rewrite "FpredBounded")
     (rewrite "FcanonicBounded"))
    ("4"
     (hide 2)
     (skeep)
     (rewrite "FpredBounded")
     (rewrite "FcanonicBounded"))
    ("5" (hide 2) (skeep) (rewrite "FcanonicBounded"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "abs")
   (grind-reals)
   (("1"
     (case-replace "Fabs(p)=Fopp(p)")
     (("1" (rewrite "ClosestFopp"))
      ("2"
       (expand* "Fabs" "Fopp")
       (case "FtoR(p) <= 0")
       (("1" (expand "FtoR") (expand "abs" 1) (grind-reals))
        ("2"
         (rewrite "RleRoundedLessR0" :subst
          ("b" "b" "P" "Closest?" "r" "r" "f" "p"))
         (rewrite "Closest_RoundedMode"))))))
    ("2"
     (case-replace "Fabs(p)=p")
     (case "0 <= FtoR(p)")
     (("1"
       (expand "FtoR")
       (expand* "Fabs" "abs")
       (grind-reals)
       (decompose-equality 1))
      ("2"
       (rewrite "RleRoundedR0" :subst
        ("b" "b" "P" "Closest?" "r" "r" "f" "p"))
       (rewrite "Closest_RoundedMode"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fbounded?" 1)
   (split)
   (("1"
     (mult-by 1 "radix^Fexp(Fminus(q, p))")
     (("1"
       (case-replace
        "abs(Fnum(Fminus(q, p))) * radix ^ Fexp(Fminus(q, p))=FtoR(q)-FtoR(p)")
       (("1"
         (hide -1)
         (expand* "Fminus" "min")
         (grind-reals)
         (("1"
           (case "FtoR(q) - FtoR(p) <= FtoR(p)")
           (("1"
             (case " FtoR(p)< vNum(b) * radix ^ Fexp(p)")
             (("1" (assert))
              ("2"
               (expand "FtoR" 1)
               (expand "Fbounded?" -3)
               (flatten)
               (grind-reals))))
            ("2" (grind-reals))))
          ("2"
           (flip-ineq 1)
           (case "FtoR(q) - FtoR(p) <= FtoR(q)")
           (("1"
             (case "FtoR(q) < vNum(b) * radix ^ Fexp(q)")
             (("1" (assert))
              ("2"
               (expand "Fbounded?" -4)
               (flatten)
               (expand "FtoR" 1)
               (grind-reals))))
            ("2" (grind-reals))))))
        ("2"
         (hide 2)
         (rewrite "FminusCorrect" :dir rl)
         (case "FtoR(Fminus(q, p))=abs(FtoR(Fminus(q, p)))")
         (("1"
           (rewrite -1)
           (expand "FtoR" 1)
           (rewrite "abs_mult")
           (expand "abs" 1 3)
           (propax))
          ("2"
           (hide 2)
           (expand "abs")
           (grind-reals)
           (rewrite "FminusCorrect")
           (grind-reals))))))
      ("2" (assert))))
    ("2"
     (expand* "Fminus" "Fbounded?")
     (flatten)
     (expand "min")
     (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "FtoR(p) <= FtoR(q)")
   (("1" (rewrite "SterbenzAux"))
    ("2"
     (case-replace "Fminus(q, p)=Fopp(Fminus(p, q))")
     (("1" (rewrite "FoppBounded") (rewrite "SterbenzAux"))
      ("2"
       (hide-all-but 1)
       (expand* "Fminus" "Fopp")
       (case-replace "min(Fexp(q), Fexp(p)) = min(Fexp(p), Fexp(q))")
       (("1" (assert)) ("2" (hide 2) (expand "min") (grind-reals))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (b: Format, f, p, q: float):
                               Fbounded?(b)(p) =>
                                Fbounded?(b)(q) =>
                                 Fbounded?(b)(f) => Fexp(p) <= Fexp(q) =>
                                  Closest?(b)(FtoR(p) + FtoR(q), f) =>
                                   (EXISTS (e: (Fbounded?(b))):
                                      FtoR(e) = FtoR(p) + FtoR(q) - FtoR(f) AND
                                       Fexp(e) = min(Fexp(p), Fexp(q)))")
   (("1"
     (skeep)
     (case "Fexp(p) <= Fexp(q)")
     (("1"
       (inst -2 "b" "f" "p" "q")
       (split)
       (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))
        ("5" (propax)) ("6" (propax))))
      ("2"
       (inst -1 "b" "f" "q" "p")
       (split)
       (("1"
         (skosimp*)
         (inst 2 "e!1")
         (split)
         (("1" (assert)) ("2" (expand "min") (assert))))
        ("2" (assert)) ("3" (assert)) ("4" (propax)) ("5" (propax))
        ("6" (propax))))))
    ("2"
     (hide 2)
     (skeep)
     (lemma "RoundedModeRep")
     (inst -1 "Closest?" "b" "f" "Fplus(p,q)")
     (split)
     (("1"
       (skosimp*)
       (case "FtoR(Fminus(Fplus(p,q),(# Fnum := m!1, Fexp := Fexp(Fplus(p, q)) #)))=FtoR(p)+FtoR(q)-FtoR(f)")
       (("1"
         (case "Fexp(Fminus(Fplus(p,q),(# Fnum := m!1, Fexp := Fexp(Fplus(p, q)) #)))=Fexp(p)")
         (("1"
           (inst 1
            "(Fminus(Fplus(p, q), (# Fnum := m!1, Fexp := Fexp(Fplus(p, q)) #)))")
           (("1"
             (split)
             (("1" (propax)) ("2" (rewrite -1) (expand "min") (assert))))
            ("2"
             (expand "Fbounded?")
             (split)
             (("1"
               (mult-by 1 "radix^(Fexp(p))")
               (("1"
                 (case-replace
                  "abs(Fnum
                                                              ((Fminus(Fplus(p, q),
                                                                       (# Fnum := m!1, Fexp := Fexp(Fplus(p, q)) #)))))
                                                         * radix ^ (Fexp(p))=abs(FtoR(p) + FtoR(q) - FtoR(f))")
                 (("1"
                   (expand "Closest?")
                   (inst -9 "q")
                   (("1"
                     (case "abs(FtoR(q) - FtoR(p) - FtoR(q)) < vNum(b) * radix ^ (Fexp(p))")
                     (("1"
                       (case "abs(FtoR(p) + FtoR(q) - FtoR(f))=abs(FtoR(f) - FtoR(p) - FtoR(q))")
                       (("1" (assert))
                        ("2"
                         (hide-all-but 1)
                         (expand "abs")
                         (grind-reals))))
                      ("2"
                       (hide -1 -2 -3 -4 -6 -7 -8 -9 2)
                       (flatten)
                       (assert)
                       (expand "FtoR")
                       (rewrite "abs_mult")
                       (rewrite "abs_mult")
                       (expand "abs" 1 1)
                       (expand "abs" 1 2)
                       (assert)
                       (real-props :simple? t)
                       (grind-reals))))
                    ("2" (expand "Fbounded?") (propax))))
                  ("2"
                   (hide 2)
                   (rewrite -2 :dir rl)
                   (expand "FtoR")
                   (rewrite -1)
                   (rewrite "abs_mult")
                   (expand "abs" 1 3)
                   (propax))))
                ("2" (assert))))
              ("2" (rewrite -1) (flatten))))))
          ("2" (hide 2) (expand* "Fminus" "Fplus" "min") (grind-reals))))
        ("2"
         (hide 2)
         (rewrite "FminusCorrect")
         (rewrite "FplusCorrect")
         (assert))))
      ("2" (rewrite "FplusCorrect"))
      ("3" (rewrite "Closest_RoundedMode")) ("4" (propax))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RoundedModeRep")
   (inst -1 "isMin?" "b" "f" "Fmult(p,q)")
   (split)
   (("1"
     (skosimp*)
     (case "FtoR(Fminus(Fmult(p,q),(# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))=FtoR(p) * FtoR(q) - FtoR(f)")
     (("1"
       (case "Fexp(Fminus(Fmult(p,q),(# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))=Fexp(p) + Fexp(q)")
       (("1"
         (inst 1
          "(Fminus(Fmult(p, q), (# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))")
         (("1" (split) (("1" (propax)) ("2" (propax))))
          ("2"
           (expand "Fbounded?" 1)
           (split)
           (("1"
             (mult-by 1 "radix^(Fexp(p) + Fexp(q))")
             (("1"
               (case "abs(Fnum
                                                                                          ((Fminus(Fmult(p, q),
                                                                                                   (# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))))
                                                                                     * radix ^ (Fexp(p) + Fexp(q))=abs(FtoR(p) * FtoR(q) - FtoR(f))")
               (("1"
                 (rewrite -1)
                 (case "Fulp(b)(f) <= vNum(b) * radix ^ (Fexp(p) + Fexp(q))")
                 (("1"
                   (case "abs(FtoR(p) * FtoR(q) - FtoR(f)) < Fulp(b)(f)")
                   (("1" (assert))
                    ("2"
                     (hide 2 -1)
                     (case-replace
                      "abs(FtoR(p) * FtoR(q) - FtoR(f))=abs(FtoR(f)-(FtoR(p)*FtoR(q)))")
                     (("1"
                       (rewrite "RoundedModeUlp" :subst ("P" "isMin?"))
                       (rewrite "isMin_RoundedMode"))
                      ("2"
                       (hide-all-but 1)
                       (expand "abs")
                       (grind-reals))))))
                  ("2"
                   (hide -1 -2 -3 2)
                   (case "vNum(b)=radix^Prec(b)")
                   (("1"
                     (case "Fbounded?(b)((# Fnum:=vNum(b)-1, Fexp:= Prec(b)+Fexp(p) + Fexp(q)#))")
                     (("1"
                       (case-replace
                        "vNum(b) * radix ^ (Fexp(p) + Fexp(q))= Fulp(b)(
                                                                                                 (# Fnum:=vNum(b)-1, Fexp:= Prec(b)+Fexp(p) + Fexp(q)#))")
                       (("1"
                         (rewrite "FulpMonotone")
                         (expand "isMin?")
                         (flatten)
                         (case "FtoR(p) * FtoR(q) <=
                                                                                                                         FtoR((# Fnum := vNum(b) - 1, Fexp := Fexp(p) + Fexp(q) + Prec(b) #))")
                         (("1" (assert))
                          ("2"
                           (hide 2 3 -1)
                           (expand "FtoR")
                           (rewrite "expt_plus")
                           (rewrite "expt_plus")
                           (div-by 1
                            "radix ^ (Fexp(q))*radix ^ (Fexp(p))")
                           (case-replace
                            "Fnum(p) * Fnum(q) * radix ^ (Fexp(p)) * radix ^ (Fexp(q)) /
                                                                                                             (radix ^ (Fexp(q)) * radix ^ (Fexp(p)))=Fnum(p) * Fnum(q)")
                           (("1"
                             (case-replace "vNum(b) = radix ^ Prec(b)")
                             (case-replace
                              "(radix ^ Prec(b) * (radix ^ Fexp(p) * radix ^ Fexp(q) * radix ^ Prec(b)) -
                                                                                                                       radix ^ Fexp(p) * radix ^ Fexp(q) * radix ^ Prec(b))
                                                                                                                      / (radix ^ (Fexp(q)) * radix ^ (Fexp(p)))= (radix ^ Prec(b)-1)* radix ^ Prec(b)")
                             (("1"
                               (hide -1 -3 -4 -7 -10 -11 -12 -13)
                               (expand "Fbounded?")
                               (flatten)
                               (expand "abs")
                               (grind-reals)
                               (case "Fnum(p) * Fnum(q) <= (radix ^ Prec(b) - 1) * Fnum(q)")
                               (("1"
                                 (case
                                  "(radix ^ Prec(b) - 1) * Fnum(q) <= (radix ^ Prec(b) - 1) * radix ^ Prec(b)")
                                 (("1" (grind-reals))
                                  ("2"
                                   (div-by 1 "radix ^ Prec(b) - 1")
                                   (grind-reals))))
                                ("2"
                                 (div-by 1 "Fnum(q)")
                                 (hide -3 -4 -5 -6 -7 2)
                                 (copy -2)
                                 (rewrite -2 :dir rl)
                                 (flip-ineq -1)
                                 (hide -1)
                                 (case
                                  "forall (e1,e2:int): e1>= e2 OR e1 <= e2-1")
                                 (("1"
                                   (inst -1 "Fnum(p)" "vNum(b)")
                                   (assert))
                                  ("2" (skosimp*) (assert))))))
                              ("2" (field 1))))
                            ("2" (field 1))))))
                        ("2"
                         (rewrite "FulpCanonic")
                         (("1"
                           (rewrite "expt_plus")
                           (rewrite "expt_plus")
                           (rewrite "expt_plus")
                           (assert))
                          ("2"
                           (case "Fnormal?(b)((# Fnum := vNum(b) - 1, Fexp := Fexp(p) + Fexp(q) + Prec(b) #))")
                           (("1" (expand "Fcanonic?") (assert))
                            ("2"
                             (hide 2 3 4)
                             (expand "Fnormal?")
                             (lemma "radix_less_vNum")
                             (inst -1 "b")
                             (case "vNum(b) <= vNum(b) * radix - radix")
                             (("1" (expand "abs" 1) (grind-reals))
                              ("2"
                               (hide 2 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11)
                               (move-terms 1 l 1)
                               (move-terms 1 r 2)
                               (case "vNum(b) <= vNum(b) * radix - vNum(b)")
                               (("1" (assert))
                                ("2"
                                 (div-by 1 "vNum(b)")
                                 (case-replace
                                  "(vNum(b) * radix - vNum(b)) / vNum(b)=radix -1")
                                 (("1" (assert))
                                  ("2" (field 1))))))))))))))
                      ("2"
                       (assert)
                       (hide -2 -3 -4 -5 -6 -7 -8 2)
                       (expand "Fbounded?")
                       (lemma "radix_less_vNum")
                       (inst -1 "b")
                       (expand "abs")
                       (grind-reals))))
                    ("2" (expand "vNum") (propax)) ("3" (assert))))))
                ("2"
                 (rewrite -2 :dir rl)
                 (expand "FtoR" 1)
                 (rewrite -1)
                 (rewrite "abs_mult")
                 (expand "abs" 1 3)
                 (propax))))
              ("2" (assert))))
            ("2" (assert))))))
        ("2" (expand* "Fmult" "Fminus" "min"))))
      ("2"
       (rewrite "FminusCorrect")
       (rewrite "FmultCorrect")
       (rewrite -1))))
    ("2" (rewrite "FmultCorrect")) ("3" (rewrite "isMin_RoundedMode"))
    ("4" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RoundedModeRep")
   (inst -1 "isMax?" "b" "f" "Fmult(p,q)")
   (split)
   (("1"
     (skosimp*)
     (case "FtoR(Fminus(Fmult(p,q),(# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))=FtoR(p) * FtoR(q) - FtoR(f)")
     (("1"
       (case "Fexp(Fminus(Fmult(p,q),(# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))=Fexp(p) + Fexp(q)")
       (("1"
         (inst 1
          "(Fminus(Fmult(p, q), (# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))")
         (("1" (split) (("1" (propax)) ("2" (propax))))
          ("2"
           (expand "Fbounded?" 1)
           (split)
           (("1"
             (mult-by 1 "radix^(Fexp(p) + Fexp(q))")
             (("1"
               (case "abs(Fnum
                                                                                                             ((Fminus(Fmult(p, q),
                                                                                                                      (# Fnum := m!1, Fexp := Fexp(Fmult(p, q)) #)))))
                                                                                                        * radix ^ (Fexp(p) + Fexp(q))=abs(FtoR(p) * FtoR(q) - FtoR(f))")
               (("1"
                 (rewrite -1)
                 (case "Fulp(b)(f) <= vNum(b) * radix ^ (Fexp(p) + Fexp(q))")
                 (("1"
                   (case "abs(FtoR(p) * FtoR(q) - FtoR(f)) < Fulp(b)(f)")
                   (("1" (assert))
                    ("2"
                     (hide 2 -1)
                     (case-replace
                      "abs(FtoR(p) * FtoR(q) - FtoR(f))=abs(FtoR(f)-(FtoR(p)*FtoR(q)))")
                     (("1"
                       (rewrite "RoundedModeUlp" :subst ("P" "isMax?"))
                       (rewrite "isMax_RoundedMode"))
                      ("2"
                       (hide-all-but 1)
                       (expand "abs")
                       (grind-reals))))))
                  ("2"
                   (hide -1 -2 -3 2)
                   (case "vNum(b)=radix^Prec(b)")
                   (("1"
                     (case "Fbounded?(b)((# Fnum:=vNum(b)-1, Fexp:= Prec(b)+Fexp(p) + Fexp(q)#))")
                     (("1"
                       (case-replace
                        "vNum(b) * radix ^ (Fexp(p) + Fexp(q))= Fulp(b)(
                                                                                                                     (# Fnum:=vNum(b)-1, Fexp:= Prec(b)+Fexp(p) + Fexp(q)#))")
                       (("1"
                         (rewrite "FulpMonotone")
                         (expand "isMax?")
                         (flatten)
                         (inst -11
                          "(# Fnum := vNum(b) - 1, Fexp := Fexp(p) + Fexp(q) + Prec(b) #)")
                         (rewrite -11)
                         (hide 2 3 -1 -2 -3 -11)
                         (expand "FtoR")
                         (rewrite "expt_plus")
                         (rewrite "expt_plus")
                         (case-replace " vNum(b) = radix ^ Prec(b)")
                         (("1"
                           (div-by 1
                            "radix ^ (Fexp(q))*radix ^ (Fexp(p))")
                           (case-replace
                            "Fnum(p) * Fnum(q) * radix ^ (Fexp(p)) * radix ^ (Fexp(q)) /
                                                                                                                                   (radix ^ (Fexp(q)) * radix ^ (Fexp(p)))=Fnum(p) * Fnum(q)")
                           (("1"
                             (case-replace
                              "(radix ^ Prec(b) * (radix ^ Fexp(p) * radix ^ Fexp(q) * radix ^ Prec(b)) -
                                                                                                                                               radix ^ Fexp(p) * radix ^ Fexp(q) * radix ^ Prec(b))
                                                                                                                                              / (radix ^ (Fexp(q)) * radix ^ (Fexp(p)))= (radix ^ Prec(b)-1)* radix ^ Prec(b)")
                             (("1"
                               (expand "Fbounded?")
                               (flatten)
                               (hide -1 -2)
                               (expand "abs")
                               (grind-reals)
                               (case "Fnum(p) * Fnum(q) <= (radix ^ Prec(b) - 1) * Fnum(q)")
                               (("1"
                                 (case
                                  "(radix ^ Prec(b) - 1) * Fnum(q) <= (radix ^ Prec(b) - 1) * radix ^ Prec(b)")
                                 (("1" (grind-reals))
                                  ("2"
                                   (div-by 1 "radix ^ Prec(b) - 1")
                                   (grind-reals))))
                                ("2"
                                 (div-by 1 "Fnum(q)")
                                 (hide -3 -4 -5 -6 -7 -8 -9 -10 -11 2)
                                 (case-replace
                                  "radix ^ Prec(b)= vNum(b)")
                                 (("1"
                                   (assert)
                                   (flip-ineq -2)
                                   (case
                                    "forall (e1,e2:int): e1>= e2 OR e1 <= e2-1")
                                   (("1"
                                     (inst -1 "Fnum(p)" "vNum(b)")
                                     (assert))
                                    ("2" (skosimp*) (assert))))
                                  ("2" (assert))))))
                              ("2" (field 1))))
                            ("2" (field 1))))
                          ("2" (field 1))))
                        ("2"
                         (rewrite "FulpCanonic")
                         (("1"
                           (rewrite "expt_plus")
                           (rewrite "expt_plus")
                           (rewrite "expt_plus")
                           (assert))
                          ("2"
                           (case "Fnormal?(b)((# Fnum := vNum(b) - 1, Fexp := Fexp(p) + Fexp(q) + Prec(b) #))")
                           (("1" (expand "Fcanonic?") (assert))
                            ("2"
                             (hide 2 3 4)
                             (expand "Fnormal?")
                             (lemma "radix_less_vNum")
                             (inst -1 "b")
                             (case "vNum(b) <= vNum(b) * radix - radix")
                             (("1" (expand "abs") (grind-reals))
                              ("2"
                               (hide-all-but (1 -1))
                               (move-terms 1 l 1)
                               (move-terms 1 r 2)
                               (case "vNum(b) <= vNum(b) * radix - vNum(b)")
                               (("1" (assert))
                                ("2"
                                 (div-by 1 "vNum(b)")
                                 (case-replace
                                  "(vNum(b) * radix - vNum(b)) / vNum(b)=radix -1")
                                 (("1" (assert))
                                  ("2" (field 1))))))))))))))
                      ("2"
                       (expand "Fbounded?")
                       (split)
                       (("1"
                         (lemma "radix_less_vNum")
                         (inst -1 "b")
                         (expand "abs" 1)
                         (grind-reals))
                        ("2" (grind-reals))))))
                    ("2" (expand "vNum") (propax)) ("3" (assert))))))
                ("2"
                 (rewrite -2 :dir rl)
                 (expand "FtoR" 1)
                 (rewrite -1)
                 (rewrite "abs_mult")
                 (expand "abs" 1 3)
                 (propax))))
              ("2" (assert))))
            ("2" (assert))))))
        ("2" (expand* "Fmult" "Fminus" "min"))))
      ("2"
       (rewrite "FminusCorrect")
       (rewrite "FmultCorrect")
       (rewrite -1))))
    ("2" (rewrite "FmultCorrect")) ("3" (rewrite "isMax_RoundedMode"))
    ("4" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "0 <= FtoR(p)")
   (("1"
     (case "0 <= FtoR(q)")
     (("1"
       (case "0 <= FtoR(f)")
       (("1"
         (expand* "RoundedMode?" "MinOrMax?")
         (flatten)
         (inst -9 "FtoR(p)*FtoR(q)" "f")
         (split)
         (("1" (rewrite "errorBoundedMult_aux"))
          ("2" (rewrite "errorBoundedMult_aux2")) ("3" (propax))))
        ("2"
         (rewrite "RleRoundedR0" :subst
          ("P" "P" "b" "b" "r" "FtoR(p)*FtoR(q)"))
         (grind-reals))))
      ("2"
       (flip-ineq 1)
       (case "FtoR(f) <= 0")
       (("1"
         (expand* "RoundedMode?" "MinOrMax?")
         (flatten)
         (inst -9 "FtoR(p)*FtoR(q)" "f")
         (split)
         (("1"
           (lemma "errorBoundedMult_aux2")
           (inst -1 "b" "Fopp(f)" "p" "Fopp(q)")
           (split)
           (("1"
             (skosimp*)
             (inst 1 "Fopp(e!1)")
             (("1"
               (split)
               (("1"
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (assert))
                ("2" (expand "Fopp") (propax))))
              ("2" (rewrite "FoppBounded"))))
            ("2" (expand "Fopp") (propax))
            ("3"
             (case-replace
              "FtoR(p) * FtoR(Fopp(q))=-(FtoR(p) * FtoR(q))")
             (("1" (rewrite "MinOppMax"))
              ("2" (rewrite "FoppCorrect") (assert))))
            ("4" (rewrite "FoppCorrect") (assert))
            ("5" (rewrite "FoppCorrect") (assert)) ("6" (propax))
            ("7" (rewrite "FoppBounded")) ("8" (rewrite "FoppBounded"))
            ("9" (propax))))
          ("2"
           (lemma "errorBoundedMult_aux")
           (inst -1 "b" "Fopp(f)" "p" "Fopp(q)")
           (split)
           (("1"
             (skosimp*)
             (inst 1 "Fopp(e!1)")
             (("1"
               (split)
               (("1"
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (assert))
                ("2" (expand "Fopp") (propax))))
              ("2" (rewrite "FoppBounded"))))
            ("2" (expand "Fopp") (propax))
            ("3"
             (case-replace
              "FtoR(p) * FtoR(Fopp(q))=-(FtoR(p) * FtoR(q))")
             (("1" (rewrite "MaxOppMin"))
              ("2" (rewrite "FoppCorrect") (assert))))
            ("4" (rewrite "FoppCorrect") (assert))
            ("5" (rewrite "FoppCorrect") (assert)) ("6" (propax))
            ("7" (rewrite "FoppBounded")) ("8" (rewrite "FoppBounded"))
            ("9" (propax))))
          ("3" (propax))))
        ("2"
         (rewrite "RleRoundedLessR0" :subst
          ("P" "P" "b" "b" "r" "FtoR(p)*FtoR(q)"))
         (grind-reals))))))
    ("2"
     (flip-ineq 1)
     (case "0 <= FtoR(q)")
     (("1"
       (case "FtoR(f) <= 0")
       (("1"
         (expand* "RoundedMode?" "MinOrMax?")
         (flatten)
         (inst -9 "FtoR(p)*FtoR(q)" "f")
         (split)
         (("1"
           (lemma "errorBoundedMult_aux2")
           (inst -1 "b" "Fopp(f)" "Fopp(p)" "q")
           (split)
           (("1"
             (skosimp*)
             (inst 1 "Fopp(e!1)")
             (("1"
               (split)
               (("1"
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (assert))
                ("2" (expand "Fopp") (propax))))
              ("2" (rewrite "FoppBounded"))))
            ("2" (expand "Fopp") (propax))
            ("3"
             (case-replace
              "FtoR(Fopp(p)) * FtoR(q)=-(FtoR(p) * FtoR(q))")
             (("1" (rewrite "MinOppMax"))
              ("2" (rewrite "FoppCorrect") (assert))))
            ("4" (rewrite "FoppCorrect") (assert)) ("5" (propax))
            ("6" (rewrite "FoppCorrect") (assert))
            ("7" (rewrite "FoppBounded")) ("8" (propax))
            ("9" (rewrite "FoppBounded"))))
          ("2"
           (lemma "errorBoundedMult_aux")
           (inst -1 "b" "Fopp(f)" "Fopp(p)" "q")
           (split)
           (("1"
             (skosimp*)
             (inst 1 "Fopp(e!1)")
             (("1"
               (split)
               (("1"
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (rewrite "FoppCorrect")
                 (assert))
                ("2" (expand "Fopp") (propax))))
              ("2" (rewrite "FoppBounded"))))
            ("2" (expand "Fopp") (propax))
            ("3"
             (case-replace
              "FtoR(Fopp(p)) * FtoR(q)=-(FtoR(p) * FtoR(q))")
             (("1" (rewrite "MaxOppMin"))
              ("2" (rewrite "FoppCorrect") (assert))))
            ("4" (rewrite "FoppCorrect") (assert)) ("5" (propax))
            ("6" (rewrite "FoppCorrect") (assert))
            ("7" (rewrite "FoppBounded")) ("8" (propax))
            ("9" (rewrite "FoppBounded"))))
          ("3" (propax))))
        ("2"
         (rewrite "RleRoundedLessR0" :subst
          ("P" "P" "b" "b" "r" "FtoR(p)*FtoR(q)"))
         (grind-reals))))
      ("2"
       (flip-ineq 1)
       (case "0 <= FtoR(f)")
       (("1"
         (expand* "RoundedMode?" "MinOrMax?")
         (flatten)
         (inst -9 "FtoR(p)*FtoR(q)" "f")
         (split)
         (("1"
           (case-replace "FtoR(p) * FtoR(q)=FtoR(Fopp(p))*FtoR(Fopp(q))")
           (("1"
             (case-replace
              "Fexp(p) + Fexp(q)=Fexp(Fopp(p)) + Fexp(Fopp(q))")
             (("1"
               (rewrite "errorBoundedMult_aux")
               (("1" (rewrite "FoppCorrect") (assert))
                ("2" (rewrite "FoppCorrect") (assert))
                ("3" (rewrite "FoppBounded"))
                ("4" (rewrite "FoppBounded"))))
              ("2" (expand "Fopp") (propax))))
            ("2"
             (rewrite "FoppCorrect")
             (rewrite "FoppCorrect")
             (assert))))
          ("2"
           (case-replace
            "Fexp(p) + Fexp(q)=Fexp(Fopp(p)) + Fexp(Fopp(q))")
           (("1"
             (case-replace
              "FtoR(p) * FtoR(q)=FtoR(Fopp(p))*FtoR(Fopp(q))")
             (("1"
               (rewrite "errorBoundedMult_aux2")
               (("1" (rewrite "FoppCorrect") (assert))
                ("2" (rewrite "FoppCorrect") (assert))
                ("3" (rewrite "FoppBounded"))
                ("4" (rewrite "FoppBounded"))))
              ("2"
               (rewrite "FoppCorrect")
               (rewrite "FoppCorrect")
               (assert))))
            ("2" (expand "Fopp") (propax))))
          ("3" (propax))))
        ("2"
         (rewrite "RleRoundedR0" :subst
          ("P" "P" "b" "b" "r" "FtoR(p)*FtoR(q)"))
         (grind-reals))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "FulpCanonic")
   (("1"
     (expand "FtoR")
     (rewrite "abs_mult")
     (expand "abs" 1 2)
     (expand "Fnormal?")
     (flatten)
     (rewrite "abs_mult")
     (expand "abs" -2 1)
     (div-by 1 " radix ^ (Fexp(p))")
     (field 1))
    ("2" (expand "Fcanonic?") (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "FtoR(p)=FtoR(Fnormalize(b)(p))")
   (("1"
     (expand "FtoR" 1)
     (rewrite "abs_mult")
     (expand "abs" 1 2)
     (expand "Fulp")
     (div-by 1 " radix ^ (Fexp(Fnormalize(b)(p)))")
     (case-replace
      "abs(Fnum(Fnormalize(b)(p))) * radix ^ (Fexp(Fnormalize(b)(p))) /
                         (vNum(b) - 1)/ radix ^ (Fexp(Fnormalize(b)(p)))= abs(Fnum(Fnormalize(b)(p)))/(vNum(b) - 1)")
     (("1"
       (rewrite "div_cancel4")
       (field 1)
       (case "Fbounded?(b)(Fnormalize(b)(p))")
       (("1"
         (expand "Fbounded?")
         (flatten)
         (hide-all-but (-1 1))
         (name-replace "AA" "vNum(b)")
         (grind))
        ("2" (rewrite "FcanonicBounded"))))
      ("2" (field 1))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "Fcanonic?(b)(Fnormalize(b)(p))")
   (("1"
     (expand "Fcanonic?")
     (split)
     (("1"
       (case "Fulp(b)(p) <= abs(FtoR(p)) * radix/vNum(b)")
       (("1" (assert))
        ("2"
         (hide 2)
         (case-replace "FtoR(p)=FtoR(Fnormalize(b)(p))")
         (("1"
           (case-replace "Fulp(b)(p)=Fulp(b)(Fnormalize(b)(p))")
           (("1" (rewrite "FulpLeN"))
            ("2"
             (expand "Fulp")
             (rewrite "FcanonicUnique" :subst
              ("b"
               "b"
               "p"
               "Fnormalize(b)(Fnormalize(b)(p))"
               "q"
               "Fnormalize(b)(p)")))
            ("3" (rewrite "FcanonicBounded"))))
          ("2" (assert))))))
      ("2"
       (case "Fulp(b)(p) = radix ^ (-dExp(b))")
       (("1" (assert))
        ("2"
         (hide 2)
         (expand* "Fulp" "Fsubnormal?")
         (flatten)
         (assert))))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "FulpCanonic")
   (("1"
     (rewrite "FulpCanonic")
     (rewrite "Exp_increq_1")
     (rewrite "Lexico" :subst ("b" "b"))
     (("1" (lemma "FpredLt" :subst ("b" "b" "f" "p")) (assert))
      ("2"
       (split-ineq -2)
       (("1"
         (case-replace "p=(# Fnum:=0, Fexp:=-dExp(b)#)")
         (("1"
           (hide-all-but 2)
           (expand "Fpred")
           (grind-reals)
           (lemma "radix_less_vNum" :subst ("b" "b"))
           (assert))
          ("2"
           (rewrite "FcanonicUnique" :subst
            ("b" "b" "p" "p" "q" "(# Fnum := 0, Fexp := -dExp(b) #)"))
           (("1" (rewrite -1 :dir rl) (expand "FtoR" 1) (assert))
            ("2"
             (hide-all-but 1)
             (expand* "Fcanonic?" "Fsubnormal?" "Fbounded?")
             (expand "abs")
             (grind-reals))))))
        ("2" (rewrite "FpredPos"))))
      ("3" (rewrite "FpredCanonic"))))
    ("2" (rewrite "FpredCanonic"))))


proof_type: f_proof
decl_type: formula
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "FulpCanonic")
   (rewrite "FulpCanonic")
   (("1"
     (case-replace
      "radix * radix ^ (Fexp(Fpred(b)(p)))= radix ^ (1+Fexp(Fpred(b)(p)))")
     (("1"
       (rewrite "Exp_increq_1")
       (hide -1 2)
       (expand "Fpred")
       (grind-reals))
      ("2" (rewrite "expt_plus") (rewrite "expt_x1"))))
    ("2" (rewrite "FpredCanonic"))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "i")
   (case "radix = mod(radix,i) + i * floor(radix / i)")
   (("1"
     (replace -3)
     (assert)
     (replace -1)
     (assert)
     (case "FORALL (ii,jj:int): integer_pred(ii*jj)")
     (("1"
       (inst - "Fnum(f)" "floor(radix/i)")
       (assert)
       (hide-all-but (-1 1))
       (grind :exclude "floor"))
      ("2" (hide-all-but 1) (grind))))
    ("2" (expand "mod") (propax))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (grind-reals)
   (wrap-formula -1 "exp")
   (("1" (rewrite "exp_ln" -1) (grind-reals)) ("2" (grind-reals))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "-vNum(b) / radix = -(vNum(b)/radix)")
   (("1"
     (hide -1)
     (lemma "integers.closed_neg")
     (inst?)
     (hide 2)
     (lemma "radix_div_vNum")
     (inst -1 "b"))
    ("2" (hide 2) (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (grind-reals)
   (expand "abs" 4 2)
   (wrap-formula 2 "abs")
   (expand "abs" 1 2)
   (cancel-by 4 "abs(Fnum(f!1))")
   (hide-all-but (-1 3))
   (grind))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (typepred
      "v!1(b!1)((# Fnum := radix * Fnum(f!1), Fexp := Fexp(f!1) - 1 #))")
     (replaces -2)
     (expand "FtoR")
     (rewrite "expt_div" :dir rl)
     (rewrite "expt_x1")
     (assert))
    ("2"
     (typepred
      "v!1(b!1)((# Fnum := radix * Fnum(f!1), Fexp := Fexp(f!1) - 1 #))")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (assert)
   (case "x*radix/vNum(b) > 0")
   (("1" (assert))
    ("2"
     (hide 2)
     (cross-mult 1)
     (lemma "posreal_times_posreal_is_posreal")
     (inst?)
     (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "vNum")
   (rewrite "expt_plus" :dir rl)
   (mult-by -1 "radix ^ (1 + dExp(b) - Prec(b))")
   (rewrite "expt_plus" :dir rl))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fcanonic?")
   (case "Fsubnormal?(b)
                                         ((# Fnum := floor(x * radix ^ (dExp(b))),
                                             Fexp := -dExp(b) #))")
   (("1" (assert))
    ("2"
     (hide 2)
     (expand* "Fsubnormal?")
     (case "abs(radix * floor(x * radix ^ (dExp(b)))) < vNum(b)")
     (("1"
       (expand "Fbounded?")
       (split)
       (("1"
         (rewrite "abs_mult" -1)
         (expand "abs" -1 1)
         (mult-by 1 "radix")
         (swap "abs(floor(x * radix ^ (dExp(b))))" * "radix")
         (case "vNum(b)<=vNum(b) * radix")
         (("1" (grind-reals))
          ("2" (hide -1 -2 2) (div-by 1 "vNum(b)") (assert))))
        ("2" (propax))))
      ("2"
       (hide 2)
       (rewrite "abs_mult")
       (expand "abs" 1 1)
       (div-by 1 "radix")
       (case "floor(x * radix ^ (dExp(b))) >=0")
       (("1"
         (expand "abs" 1 1)
         (case "x * radix ^ (dExp(b)) < vNum(b) / radix")
         (("1" (grind-reals))
          ("2"
           (hide -1 2)
           (lemma "expt_inverse")
           (inst -1 "dExp(b)+1" "radix")
           (case-replace "-(dExp(b) + 1)=-dExp(b) - 1")
           (("1" (rewrite -2 -3) (rewrite "expt_plus" -3) (grind-reals))
            ("2" (assert))))))
        ("2" (hide -1 2) (grind-reals))))
      ("3" (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "vNum")
   (rewrite "expt_plus" :dir rl)
   (mult-by 2 "radix ^ (Prec(b) - 1 + -dExp(b))")
   (assert)
   (rewrite "expt_plus" :dir rl)
   (assert))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "vNum")
   (rewrite "expt_plus" :dir rl)
   (mult-by 1 "radix ^ (1 + dExp(b) - Prec(b))")
   (rewrite "expt_plus" :dir rl)
   (assert))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: fix
script:
  (""
   (skeep)
   (lemma "RND_log_compute")
   (inst?)
   (assert)
   (replace -1 :dir rl)
   (hide -1)
   (skosimp)
   (expand "Fcanonic?")
   (assert)
   (flatten)
   (typepred "e!1")
   (replace -2 :hide? t)
   (name "AA" "floor(ln(x * radix / vNum(b)) / ln(radix))")
   (replace -1)
   (expand "Fnormal?")
   (expand "Fbounded?")
   (split)
   (("1"
     (case "0<= floor(x * radix ^ (-AA))")
     (("1"
       (expand "abs" 1 1)
       (grind-reals)
       (case "x * radix ^ (-AA) < vNum(b)")
       (("1" (grind-reals))
        ("2"
         (hide 2 -1)
         (case "x * radix ^ (-AA)=x * radix ^^ (-AA)")
         (("1"
           (replace -1)
           (case "x * radix ^^ (-AA) < x * radix ^^ (-(ln(x * radix / vNum(b)) / ln(radix)-1))")
           (("1"
             (case "x * radix ^^ (-(ln(x * radix / vNum(b)) / ln(radix) - 1)) <= vNum(b)")
             (("1"
               (hide -3 -4)
               (name-replace "WW"
                "x * radix ^^ (-(ln(x * radix / vNum(b)) / ln(radix) - 1))")
               (assert))
              ("2"
               (hide 2 -1 -2 -3)
               (case-replace
                "(ln(x * radix / vNum(b)) / ln(radix) - 1)=ln(x / vNum(b)) / ln(radix)")
               (("1" (field) (rewrite "hathatln") (field))
                ("2"
                 (hide 2)
                 (rewrite "ln_div")
                 (rewrite "ln_div")
                 (rewrite "ln_mult")
                 (field))))))
            ("2"
             (hide -1 2)
             (cancel-by 1 "x")
             (hide -1 2)
             (expand "^^")
             (lemma "exp_strict_increasing")
             (expand "strict_increasing?")
             (rewrite -1)
             (hide -1 2)
             (field)
             (case "(ln(x * radix / vNum(b)) / ln(radix) - 1) < AA")
             (("1"
               (rewrite "ln_div")
               (("1"
                 (rewrite "ln_mult")
                 (field)
                 (mult-by -1 "ln(radix)")
                 (("1" (field -1))
                  ("2"
                   (hide -1 -2 2)
                   (case "ln(radix) > 0")
                   (("1" (split) (("1" (grind-reals)) ("2" (propax))))
                    ("2"
                     (hide 2)
                     (lemma "ln_strict_increasing")
                     (expand "strict_increasing?")
                     (inst -1 "1" "radix")
                     (grind-reals))))))
                ("2"
                 (hide -1 -2 2)
                 (case "x>0")
                 (("1" (grind-reals)) ("2" (hide 2) (grind-reals))))))
              ("2" (hide 2) (grind-reals))))))
          ("2" (hide -1 -2 2) (rewrite "hathat_int"))))))
      ("2"
       (case "0 <= x * radix ^ (-AA)")
       (("1" (hide -2 -3 2) (grind-reals))
        ("2" (hide -1 -2 2 3) (grind-reals))))))
    ("2"
     (case "-dExp(b) <= ln(x * radix / vNum(b)) / ln(radix)")
     (("1" (grind-reals))
      ("2"
       (hide -2 2)
       (mult-by 1 "ln(radix)" +)
       (("1"
         (both-sides-f 1 "exp")
         (("1"
           (case-replace "exp(-dExp(b) * ln(radix))=radix^^(-dExp(b))")
           (("1"
             (rewrite "exp_ln")
             (div-by 1 "radix")
             (mult-by 1 "vNum(b)")
             (case-replace
              " radix ^ (-dExp(b)) / radix=radix ^ (-dExp(b) - 1)")
             (("1"
               (field)
               (rewrite "hathat_int")
               (div-by 1 "radix")
               (hide -1 -2 -4)
               (case-replace
                "(vNum(b) * radix ^ (-dExp(b))) / radix =radix ^ (-dExp(b) - 1) * vNum(b)")
               (("1" (hide -2 2) (grind-reals))
                ("2"
                 (hide 2 -1 -2)
                 (lemma "expt_plus")
                 (inst -1 "-dExp(b)" "-1" "radix")
                 (grind-reals)
                 (expand "^" 1 2)
                 (grind-reals)
                 (rewrite "expt_x1_aux"))))
              ("2"
               (hide 2 -1 -2)
               (cross-mult 1)
               (case "radix^(-dExp(b)-1)*radix = radix^(-dExp(b)-1)*radix^1")
               (("1"
                 (replace -1)
                 (hide -1)
                 (rewrite "expt_plus" :dir rl))
                ("2"
                 (expand "^" 1)
                 (expand "expt" 1)
                 (expand "expt" 1)
                 (propax))))))
            ("2" (hide -1 2) (expand "^^") (propax))))
          ("2"
           (lemma "ln_increasing")
           (expand "increasing?")
           (lemma "ln_exp")
           (grind-reals))))
        ("2"
         (hide 2 -1)
         (case "ln(radix) > 0")
         (("1" (split) (("1" (assert)) ("2" (propax))))
          ("2"
           (hide 2)
           (lemma "ln_strict_increasing")
           (expand "strict_increasing?")
           (inst -1 "1" "radix")
           (grind-reals))))))))
    ("3"
     (expand "abs" 1 1)
     (grind-reals)
     (cancel-by 1 "radix")
     (hide -1 1)
     (case "vNum(b) / radix <= x * radix ^ (-AA)")
     (("1"
       (case "integer_pred(vNum(b) / radix)")
       (("1"
         (hide -3 -4)
         (lemma "div_simple")
         (inst -1 "vNum(b)" "radix")
         (case "(EXISTS (k:int): vNum(b) = k * radix)")
         (("1"
           (skosimp*)
           (case-replace " vNum(b) / radix=k!1")
           (("1" (grind-reals)) ("2" (hide -2 -3 -4 2) (grind-reals))))
          ("2" (hide -3 2) (assert))))
        ("2" (assert) (hide-all-but 1) (rewrite "radix_div_vNum"))))
      ("2"
       (hide 2)
       (case "vNum(b) / radix <=  x * radix ^^ (-(ln(x * radix / vNum(b)) / ln(radix)))")
       (("1"
         (case "x * radix ^^ (-(ln(x * radix / vNum(b)) / ln(radix))) <= x * radix ^ (-AA)")
         (("1"
           (name-replace "A1"
            "x * radix ^^ (-(ln(x * radix / vNum(b)) / ln(radix)))")
           (name-replace "A2" "vNum(b) / radix")
           (assert))
          ("2"
           (hide 2 -1)
           (cancel-by 1 "x")
           (hide -1 1)
           (case-replace "radix ^ (-AA)=radix ^^ (-AA)")
           (("1"
             (expand "^^")
             (lemma "exp_increasing")
             (expand "increasing?")
             (rewrite -1)
             (hide -1 -2 -3 2)
             (div-by 1 "-ln(radix)" -)
             (("1" (field))
              ("2"
               (case "ln(radix)>0")
               (("1" (assert))
                ("2"
                 (hide -1 2 3)
                 (lemma "ln_strict_increasing")
                 (expand "strict_increasing?")
                 (inst -1 "1" "radix")
                 (grind-reals))))))
            ("2" (hide -1 -2 2) (rewrite "hathat_int"))))))
        ("2" (hide -1 -2 2) (rewrite "hathatln") (field))))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "radix = 1")
   (("1" (replace -1) (assert))
    ("2" (assert) (lemma "ln_eq_0") (inst?) (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "RND_aux_TCC6")
   (inst?)
   (assert)
   (skosimp*)
   (inst - "e!1")
   (ground)
   (lemma "RND_log_compute")
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "FcanonicOpp")
   (inst -1 "b" "RND_aux(b)(-x)")
   (("1" (assert)) ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (rewrite "FpredCanonic")
   (lemma "FcanonicOpp")
   (inst -1 "b" "RND_aux(b)(-x)")
   (assert))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "FORALL (ik,jk:int): integer_pred(ik*jk)")
   (("1"
     (inst?)
     (hide 2)
     (case "FORALL (rp:nat): integer_pred((radix^rp)/(k^rp))")
     (("1" (inst?))
      ("2"
       (hide 2)
       (induct "rp")
       (("1" (grind))
        ("2"
         (skeep)
         (case "FORALL (ik,jk:int): integer_pred(ik*jk)")
         (("1"
           (case "(radix^(j+1))/(k^(j+1)) = (radix/k)*((radix^j/k^j))")
           (("1"
             (replaces -1)
             (inst?)
             (hide 2)
             (typepred "k")
             (expand "mod")
             (case "floor(radix/k) = radix/k")
             (("1" (replace -1 :dir rl) (assert)) ("2" (assert))))
            ("2"
             (expand "^" +)
             (expand "expt" + 1)
             (expand "expt" + 2)
             (assert))))
          ("2" (hide-all-but 1) (grind))))))))
    ("2" (hide-all-but 1) (grind))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Fcanonic?")
   (case "Fsubnormal?(b)
                           ((# Fnum := floor(Fnum(f) * radix ^ (dExp(b) + Fexp(f))),
                               Fexp := -dExp(b) #))")
   (("1" (assert))
    ("2"
     (hide 2)
     (expand* "Fsubnormal?")
     (case "abs(radix * floor(Fnum(f) * radix ^ (dExp(b) + Fexp(f)))) < vNum(b)")
     (("1"
       (assert)
       (expand "Fbounded?")
       (rewrite "abs_mult" -1)
       (expand "abs" -1 1)
       (mult-by 1 "radix")
       (swap "abs(floor(Fnum(f) * radix ^ (dExp(b)+Fexp(f))))" * "radix")
       (case "vNum(b)<=vNum(b) * radix")
       (("1" (grind-reals))
        ("2" (hide -1 -2 2) (div-by 1 "vNum(b)") (assert))))
      ("2"
       (hide 2)
       (rewrite "abs_mult")
       (expand "abs" 1 1)
       (div-by 1 "radix")
       (case "floor(Fnum(f) * radix ^ (dExp(b)+Fexp(f))) >=0")
       (("1"
         (expand "abs" 1 1)
         (assert)
         (case "Fnum(f) * radix ^ (dExp(b)+Fexp(f)) < vNum(b) / radix")
         (("1" (grind-reals))
          ("2"
           (hide -1 2)
           (cross-mult 1)
           (lemma "expt_plus")
           (inst - "dExp(b)+Fexp(f)" "1" "radix")
           (case "radix^1 = radix")
           (("1"
             (replace -1)
             (mult-by -2 "Fnum(f)")
             (replace -1 :dir rl)
             (mult-by 1 "radix ^ (-(dExp(b) + Fexp(f) + 1))")
             (lemma "expt_plus")
             (inst - "dExp(b) + Fexp(f) + 1" "-(dExp(b) + Fexp(f) + 1)"
              "radix")
             (mult-by -1 "Fnum(f)")
             (assert)
             (replace -1 :dir rl)
             (expand "vNum")
             (rewrite "expt_plus" :dir rl)
             (assert))
            ("2" (hide-all-but 1) (grind))))))
        ("2"
         (assert)
         (lemma "nnreal_times_nnreal_is_nnreal")
         (inst?)
         (assert))))
      ("3" (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (mult-by 1 "radix ^ (Fexp(f) + 1 + dExp(b) - Prec(b))")
   (rewrite "expt_plus" :dir rl)
   (assert))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (skosimp*)
   (lemma "RND_log_compute")
   (inst?)
   (expand "vNum" -1 1)
   (rewrite "expt_plus" :dir rl)
   (inst - "FtoR(f)")
   (expand "FtoR" -1 1)
   (split -)
   (("1"
     (expand "FtoR")
     (lemma "expt_plus")
     (inst - "Fexp(f)" "1+dExp(b)-Prec(b)" "radix")
     (mult-by -1 "Fnum(f)")
     (replace -1 :dir rl)
     (hide -1)
     (replace -1 :dir rl)
     (lemma "RND_aux_TCC6")
     (inst - "b" "FtoR(f)")
     (("1"
       (assert)
       (split -)
       (("1"
         (inst - "e!1")
         (assert)
         (split -)
         (("1"
           (hide-all-but (-1 2))
           (expand "FtoR")
           (lemma "expt_plus")
           (inst - "Fexp(f)" "-e!1" "radix")
           (assert)
           (mult-by -1 "Fnum(f)")
           (replace -1 :dir rl)
           (assert)
           (hide -1)
           (grind :exclude "Fcanonic?"))
          ("2"
           (assert)
           (expand "FtoR" +)
           (lemma "expt_plus")
           (inst - "Fexp(f)" "1+dExp(b)-Prec(b)" "radix")
           (assert))))
        ("2"
         (hide (-2 2))
         (expand "FtoR")
         (mult-by 1 "radix^Fexp(f)")
         (rewrite "expt_plus" :dir rl)
         (assert)
         (expand "vNum")
         (rewrite "expt_plus" :dir rl)
         (assert))))
      ("2"
       (expand "FtoR")
       (case "Fnum(f)>=0")
       (("1" (mult-by -1 "radix^Fexp(f)") (assert)) ("2" (assert))))))
    ("2"
     (mult-by 2 "radix^Fexp(f)")
     (rewrite "expt_plus" :dir rl)
     (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "FcanonicOpp")
   (inst -1 "b" "RND_aux_float(b)(-f)")
   (("1" (assert)) ("2" (assert) (expand "-") (expand "Fopp") (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (rewrite "FpredCanonic")
   (("1"
     (lemma "FcanonicOpp")
     (rewrite "FpredCanonic")
     (("1"
       (lemma "FcanonicOpp")
       (inst -1 "b" "RND_aux_float(b)(-f)")
       (("1" (assert)) ("2" (expand "-") (expand "Fopp") (assert))))
      ("2" (expand "-") (expand "Fopp") (assert))))
    ("2" (expand "-") (expand "Fopp") (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: float
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "float_int")
   (expand "Fbounded?")
   (expand "vNum")
   (assert)
   (typepred "dExp(b)")
   (assert)
   (expand "abs")
   (lemma "increasing_expt_aux")
   (inst - "radix" "Prec(b)-2")
   (assert)
   (expand "^")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_hack
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1" (expand "Sum") (assert) (skosimp*))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst?)
     (prop)
     (("1" (skosimp*) (inst?) (assert)) ("2" (inst?) (assert))
      ("3" (typepred "F1!1(j!1)") (lemma "Sum_nonneg") (inst?) (assert))
      ("4" (skosimp*) (inst?))))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_hack
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1" (expand "Sum") (skosimp*) (ground) (skosimp*))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst?)
     (lemma "Sum_nonneg")
     (inst?)
     (prop)
     (("1" (skosimp*) (inst?)) ("2" (assert))
      ("3" (inst + "j!1") (assert)) ("4" (skosimp*) (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_hack
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1" (expand "Sum") (propax))
    ("2"
     (skosimp*)
     (expand "Sum" +)
     (inst - "F1!1 " "F2!1")
     (prop)
     (("1" (inst?) (assert)) ("2" (skosimp*) (inst?))))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_hack
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1" (skosimp*))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst?)
     (assert)
     (lemma "Sum_nonneg")
     (inst?)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_hack
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1" (skosimp*))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst - "F1!1" "pz!1")
     (prop)
     (("1" (assert))
      ("2"
       (inst?)
       (assert)
       (ground)
       (lemma "Sum_nonneg")
       (inst?)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_hack
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1" (skosimp*) (expand "Sum") (propax))
    ("2"
     (skosimp*)
     (typepred "i!1")
     (expand "Sum" + (1 3))
     (lift-if)
     (ground)
     (("1"
       (case-replace "i!1=j!1+1")
       (("1" (expand "Sum" + 2) (propax)) ("2" (assert))))
      ("2" (inst - "F!1" "i!1") (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_lemmas
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "i")
   (("1" (expand "Sum") (rewrite "expt_x0") (assert))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst?)
     (assert)
     (typepred "d!1")
     (inst?)
     (assert)
     (case-replace "b ^ (-j!1 - 1) * b = b^(-j!1)")
     (("1" (assert) (skosimp*) (assert))
      ("2"
       (hide -1 -2 2)
       (lemma "expt_plus")
       (inst - "(-(j!1+1))" "1" "b")
       (rewrite "expt_x1")
       (assert))))
    ("3" (hide 2) (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: sum_lemmas
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "Sum_pos_less_1")
   (inst?)
   (lemma "expt_pos")
   (inst?)
   (("1"
     (case "1-b^(-i!1)<1")
     (("1"
       (case "Sum(i!1, d!1) < 1")
       (("1"
         (flatten)
         (hide -2 -3 -5)
         (assert)
         (case "forall (r:real): floor(r)=0 iff 0<=r & r<1")
         (("1" (inst?) (assert)) ("2" (hide -1 -2 2) (tcc))))
        ("2" (assert))))
      ("2" (assert)) ("3" (assert))))
    ("2" (split) (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "fin!1=finite(sign(fin!1),Exp(fin!1),d(fin!1))")
   (("1"
     (hide -1)
     (case "forall (s:sign_rep),(d:digits),(n:upto(E_max-E_min)):
                         normalize(normalize(finite(s,n+E_min,d)))=normalize(finite(s,n+E_min,d))")
     (("1"
       (inst - "sign(fin!1)" "d(fin!1)" "Exp(fin!1)-E_min")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (hide 2)
       (induct "n" 1 "upto_induction[E_max-E_min]")
       (("1" (skosimp*) (expand "normalize") (propax))
        ("2"
         (skosimp*)
         (rewrite "normalize" +)
         (lift-if)
         (ground)
         (("1" (rewrite "normalize")) ("2" (inst?))))
        ("3" (assert))))))
    ("2" (assert) (rewrite "fp_num_finite_eta"))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (rewrite "max_pos")
   (rewrite "max_fp_pos")
   (rewrite "value")
   (rewrite "pos")
   (rewrite "expt_x0")
   (assert)
   (case "forall (i:upto(p)):Sum(i,
                   (LAMBDA (n: nat):
                      IF n < p THEN max_significand(n) * (b ^ (-n)) ELSE 0 ENDIF))
                 * b ^ E_max
                 = b ^ (1 + E_max) - b ^ (1 + E_max - i)")
   (("1" (inst?) (expand "value_digit") (propax))
    ("2"
     (hide 2)
     (induct "i" 1 "upto_induction[p]")
     (("1" (rewrite "Sum") (assert))
      ("2"
       (skosimp*)
       (expand "Sum" +)
       (replace -2)
       (hide -2)
       (assert)
       (rewrite "max_significand")
       (lemma "expt_plus")
       (inst-cp - "1" "E_max - jt!1" "b")
       (inst - "E_max" "-jt!1" "b")
       (replace -1)
       (hide -1)
       (replace -1)
       (hide -1)
       (rewrite "expt_x1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "min_fp_pos")
   (expand "value")
   (expand "pos")
   (rewrite "expt_x0")
   (assert)
   (case-replace "Sum(p,value_digit(min_significand))= b^(1-p)")
   (("1"
     (hide -1)
     (lemma "expt_plus")
     (inst - "(1 - p)" "E_min" "b")
     (assert))
    ("2"
     (hide 2)
     (expand "Sum")
     (expand "value_digit")
     (expand "min_significand")
     (case "forall (i:below(p)):Sum(i,
                              LAMBDA (n: nat):
                                IF n < p THEN IF n < p - 1 THEN 0 ELSE 1 ENDIF * b ^ (-n)
                                ELSE 0
                                ENDIF)
                            = 0")
     (("1" (inst?) (assert))
      ("2" (hide 2) (induct-and-rewrite "i" 1 "Sum"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "value")
   (rewrite "zero_times3")
   (("1"
     (rewrite "zero_times3")
     (lemma "expt_nonzero")
     (inst? :copy? t)
     (assert)
     (hide -2)
     (inst?)
     (assert)
     (hide -1)
     (rewrite "Sum_zero")
     (prop)
     (("1"
       (expand "d_zero")
       (apply-extensionality)
       (expand "value_digit")
       (inst?)
       (rewrite "zero_times3")
       (lemma "expt_nonzero")
       (inst?)
       (assert))
      ("2"
       (replace -1)
       (expand "d_zero")
       (expand "value_digit")
       (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "fin!1=finite(sign(fin!1),Exp(fin!1),d(fin!1))")
   (("1"
     (hide -1)
     (case "forall (s:sign_rep),(d:digits),(n:upto(E_max-E_min)):
                         value(finite(s,n+E_min,d))=value(normalize(finite(s,n+E_min,d)))")
     (("1"
       (inst - "sign(fin!1)" "d(fin!1)" "Exp(fin!1)-E_min")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (hide 2)
       (induct "n" 1 "upto_induction[E_max-E_min]")
       (("1" (skosimp*) (expand "normalize") (propax))
        ("2"
         (skosimp*)
         (rewrite "normalize")
         (lift-if)
         (ground)
         (inst?)
         (replace -3 :dir rl)
         (hide -3)
         (expand "value")
         (expand "value_digit")
         (case-replace
          "Sum(p,(LAMBDA (n: nat):
                                 IF n < p THEN shift_left(d!1)(n) * (b ^ (-n))
                                 ELSE 0
                                 ENDIF))=b*Sum(p,(LAMBDA (n: nat): IF n < p THEN d!1(n) * (b ^ (-n)) ELSE 0 ENDIF))")
         (("1"
           (hide -1)
           (lemma "expt_plus")
           (inst - "1" "E_min+jt!1" "b")
           (replace -1)
           (hide -1)
           (rewrite "expt_x1")
           (assert))
          ("2"
           (hide 2)
           (rewrite "Sum")
           (assert)
           (rewrite "shift_left")
           (assert)
           (case "forall (i:below(p)): Sum(i,
                                          (LAMBDA (n: nat):
                                             IF n < p THEN shift_left(d!1)(n) * (b ^ (-n)) ELSE 0 ENDIF))
                                        = b
                                            *
                                            Sum(i+1,
                                                (LAMBDA (n: nat):
                                                   IF n < p THEN d!1(n) * (b ^ (-n)) ELSE 0 ENDIF))")
           (("1" (inst?) (assert))
            ("2"
             (hide 2)
             (induct "i" 1 "below_induction[p]")
             (("1" (expand "Sum") (expand "Sum") (assert))
              ("2"
               (skosimp*)
               (expand "Sum" +)
               (replace -2)
               (hide -2)
               (assert)
               (expand "shift_left")
               (lemma "expt_plus")
               (inst - "1" "-(1+jb!1)" "b")
               (replace -1)
               (rewrite "expt_x1")
               (assert))))))))
        ("3" (assert))))))
    ("2" (rewrite "fp_num_finite_eta"))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "zero?")
   (expand "pos")
   (ground)
   (("1"
     (expand "value")
     (replace -1)
     (rewrite "expt_x0")
     (assert)
     (lemma "pos_times_ge")
     (inst?)
     (lemma "expt_pos")
     (inst?)
     (case "(Sum(p, value_digit(d(fin!1))) >= 0 AND b ^ Exp(fin!1) >= 0)")
     (("1" (assert))
      ("2" (split) (("1" (lemma "Sum_nonneg") (inst?)) ("2" (assert))))))
    ("2"
     (expand "value")
     (typepred "sign(fin!1)")
     (assert)
     (replace -1)
     (rewrite "expt_x1")
     (lemma "expt_pos")
     (inst?)
     (assert)
     (lemma "Sum_nonneg")
     (inst?)
     (lemma "pos_times_ge")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (assert)
   (skosimp*)
   (expand "neg")
   (expand "zero?")
   (expand "value")
   (lemma "expt_pos")
   (inst - "Exp(fin!1)" "b")
   (("1"
     (lemma "Sum_nonneg")
     (inst?)
     (("1"
       (lemma "pos_times_ge")
       (ground)
       (("1" (replace -1) (rewrite "expt_x1") (assert) (inst?) (assert))
        ("2"
         (typepred "sign(fin!1)")
         (assert)
         (replace -1)
         (rewrite "expt_x0")
         (assert)
         (inst?)
         (assert))))
      ("2" (assert))))
    ("2" (assert) (split) (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "normal?")
   (expand "subnormal?")
   (ground)
   (hide 2)
   (case "forall (n:upto(E_max-E_min)),(s:sign_rep),(d:digits):
                       Exp(normalize(finite(s,n+E_min,d))) = E_min or
                       d(normalize(finite(s,n+E_min,d)))(0) > 0")
   (("1"
     (inst - "Exp(fin!1)-E_min" "sign(fin!1)" "d(fin!1)")
     (("1" (assert) (rewrite "fp_num_finite_eta") (assert))
      ("2" (assert) (hide 2 3) (ground))))
    ("2"
     (hide 2 3)
     (induct "n" 1 "upto_induction[E_max-E_min]")
     (("1" (expand "normalize") (propax))
      ("2"
       (skosimp*)
       (rewrite "normalize")
       (lift-if)
       (ground)
       (inst?)
       (assert))
      ("3" (skosimp*) (assert))))
    ("3" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "normal?")
   (expand "zero?")
   (ground)
   (rewrite "normal_value")
   (rewrite "value0")
   (replace -2)
   (expand "d_zero")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "toggle_sign")
   (expand "value")
   (typepred "sign(fin!1)")
   (ground)
   (("1" (replace -1) (rewrite "expt_x0") (rewrite "expt_x1") (assert))
    ("2" (replace -1) (rewrite "expt_x1") (rewrite "expt_x0") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "fin!1 = finite(sign(fin!1),Exp(fin!1),d(fin!1))")
   (("1"
     (expand "toggle_sign")
     (case "forall (s:sign_rep),(d1:digits),(n:upto(E_max-E_min)):
                          d(normalize(finite(s,n+E_min,d1))) = d(normalize(finite(1-s,n+E_min,d1)))")
     (("1"
       (inst - "sign(fin!1)" "d(fin!1)" "Exp(fin!1)-E_min")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (hide -1 2)
       (induct "n" 1 "upto_induction[E_max-E_min]")
       (("1" (expand "normalize") (propax))
        ("2"
         (skosimp*)
         (expand "normalize" +)
         (lift-if)
         (assert)
         (ground)
         (inst?))
        ("3" (skolem-typepred) (ground)) ("4" (assert))))
      ("3" (hide -1 2) (skolem-typepred) (ground))))
    ("2" (rewrite "fp_num_finite_eta"))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "fin!1 = finite(sign(fin!1),Exp(fin!1),d(fin!1))")
   (("1"
     (expand "toggle_sign")
     (case "forall (s:sign_rep),(d1:digits),(n:upto(E_max-E_min)):
                          Exp(normalize(finite(s,n+E_min,d1))) = Exp(normalize(finite(1-s,n+E_min,d1)))")
     (("1"
       (inst - "sign(fin!1)" "d(fin!1)" "Exp(fin!1)-E_min")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (hide -1 2)
       (induct "n" 1 "upto_induction[E_max-E_min]")
       (("1" (expand "normalize") (propax))
        ("2"
         (skosimp*)
         (expand "normalize" +)
         (lift-if)
         (assert)
         (ground)
         (inst?))
        ("3" (skolem-typepred) (ground)) ("4" (assert))))
      ("3" (hide -1 2) (skolem-typepred) (ground))))
    ("2" (rewrite "fp_num_finite_eta"))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "normal?")
   (rewrite "toggle_d_normalize")
   (rewrite "toggle_finite")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "subnormal?")
   (rewrite "toggle_d_normalize")
   (rewrite "toggle_Exp_normalize")
   (rewrite "toggle_zero?")
   (rewrite "toggle_finite")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "value_digit")
   (lift-if)
   (split)
   (("1"
     (flatten)
     (rewrite "both_sides_times_pos_le1")
     (("1" (assert)) ("2" (lemma "expt_pos") (inst?) (assert))))
    ("2"
     (flatten)
     (lemma "expt_pos")
     (inst?)
     (("1" (rewrite "pos_times_le") (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1"
     (expand "Sum")
     (expand "Sum")
     (expand "value_digit")
     (rewrite "expt_x0")
     (skosimp*)
     (lift-if)
     (ground))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst?)
     (lemma "value_digit_le")
     (inst?)
     (assert)
     (case-replace "b ^ (-(1 + j!1)) * b = b^(-j!1)")
     (("1" (hide -1) (assert))
      ("2"
       (hide -1 -2 2)
       (lemma "expt_plus")
       (inst - "-(1+j!1)" "1" "b")
       (rewrite "expt_x1")
       (assert))))
    ("3" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1"
     (expand "Sum")
     (expand "Sum")
     (expand "value_digit")
     (rewrite "expt_x0")
     (case "0 < p")
     (("1" (grind)) ("2" (grind))))
    ("2"
     (skosimp*)
     (rewrite "Sum")
     (inst?)
     (assert)
     (lemma "value_digit_le")
     (inst?)
     (assert)
     (case-replace "b ^ (-(1 + j!1)) * b = b^(-j!1)")
     (("1" (assert))
      ("2"
       (hide -1 -2 -3 2)
       (lemma "expt_plus")
       (inst - "-(1+j!1)" "1" "b")
       (rewrite "expt_x1")
       (assert))))
    ("3" (hide 2) (skosimp*) (assert))
    ("4" (hide 2) (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "j")
   (("1"
     (expand "Sum")
     (skosimp*)
     (rewrite "value_digit")
     (lift-if)
     (assert)
     (rewrite "expt_x0")
     (assert)
     (lemma "Sum_nonneg")
     (inst?)
     (assert))
    ("2" (skosimp*) (rewrite "Sum") (inst?) (assert))
    ("3" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "Sum_d_lt_b")
   (inst - "d!1" "p-1")
   (("1" (assert) (lemma "expt_pos") (inst?) (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "Sum_d_lt1")
   (inst - "d!1" "p-1")
   (("1" (lemma "expt_pos") (inst?) (("1" (assert)) ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "value")
   (case "b ^ (Exp(fin!1)) * Sum(p, value_digit(d(fin!1))) >=0")
   (("1"
     (typepred "sign(fin!1)")
     (prop)
     (("1" (replace -1) (rewrite "expt_x0") (expand "abs") (assert))
      ("2"
       (replace -1)
       (rewrite "expt_x1")
       (expand "abs")
       (assert)
       (lift-if)
       (ground))))
    ("2"
     (hide 2)
     (lemma "expt_pos")
     (inst?)
     (("1"
       (lemma "Sum_nonneg")
       (inst?)
       (("1" (rewrite "pos_times_ge") (assert)) ("2" (assert))))
      ("2" (assert))))
    ("3" (assert)) ("4" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "Sum" + 1)
   (ground)
   (lift-if)
   (ground)
   (rewrite "value_digit")
   (rewrite "min_significand")
   (assert)
   (case-replace "Sum(p - 1, value_digit(min_significand))=0")
   (("1"
     (hide -1)
     (assert)
     (lemma "Sum_pos")
     (inst?)
     (ground)
     (("1"
       (skosimp*)
       (lemma "Sum_ge")
       (inst?)
       (inst - "value_digit(d!1)(i!1)")
       (ground)
       (("1"
         (rewrite "value_digit")
         (typepred "i!1")
         (case "d!1(i!1) * b ^ (-i!1) >= b ^ (-(p - 1))")
         (("1" (assert))
          ("2"
           (lemma "ge_times_ge_pos")
           (inst - "b ^ (-(p - 1))" "1" "d!1(i!1)" "b ^ (-i!1)")
           (ground)
           (hide -3 -4 -5 2 3 4 5)
           (lemma "both_sides_expt_gt1_le")
           (inst - "b" "-(p-1)" "-i!1")
           (assert))))
        ("2" (inst?) (assert))))
      ("2"
       (case "d!1=d_zero")
       (("1" (propax))
        ("2"
         (apply-extensionality)
         (expand "d_zero")
         (inst?)
         (hide 2 4 5 6 7)
         (expand "value_digit")
         (rewrite "pos_times_gt")
         (lemma "expt_pos")
         (inst?)
         (assert))))))
    ("2"
     (hide 2 3 4)
     (case "forall (i:below(p)): Sum(i,value_digit(min_significand)) = 0")
     (("1" (inst?))
      ("2"
       (hide 2)
       (induct "i" 1 "below_induction[p]")
       (("1" (expand "Sum") (propax))
        ("2"
         (skosimp*)
         (rewrite "Sum" +)
         (rewrite "value_digit")
         (rewrite "min_significand")
         (ground))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "forall (s:sign_rep),(d:digits),(n:upto(E_max-E_min)):
                              s=sign(normalize(finite(s,n+E_min,d)))")
   (("1"
     (case-replace "fin!1 = finite(sign(fin!1),Exp(fin!1),d(fin!1))")
     (("1"
       (assert)
       (inst - "sign(fin!1)" "d(fin!1)" "Exp(fin!1)-E_min")
       (assert))
      ("2" (assert) (rewrite "fp_num_finite_eta"))))
    ("2"
     (hide 2)
     (induct "n" 1 "upto_induction[E_max-E_min]")
     (("1" (skosimp*) (expand "normalize") (propax))
      ("2" (skosimp*) (rewrite "normalize") (lift-if) (ground) (inst?))
      ("3" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "normal_value")
   (rewrite "abs_value_fin")
   (expand "normal?")
   (assert)
   (expand "max_pos")
   (expand "value")
   (expand "max_fp_pos")
   (expand "pos")
   (rewrite "expt_x0")
   (assert)
   (prop)
   (("1"
     (lemma "value_sig_ge1")
     (inst?)
     (assert)
     (lemma "both_sides_expt_gt1_le")
     (inst - "b" "E_min" "(Exp(normalize(fin!1)))")
     (assert)
     (lemma "le_times_le_pos")
     (inst - "b^E_min" "1" "Sum(p, value_digit(d(normalize(fin!1))))"
      "b ^ (Exp(normalize(fin!1)))")
     (assert))
    ("2"
     (lemma "expt_pos")
     (inst?)
     (assert)
     (lemma "both_sides_expt_gt1_le")
     (inst - "b" "(Exp(normalize(fin!1)))" "E_max")
     (assert)
     (lemma "le_times_le_pos")
     (inst - "b ^ (Exp(normalize(fin!1)))"
      "Sum(p, value_digit(d(normalize(fin!1))))"
      "Sum(p, value_digit(max_significand))" " b ^ E_max")
     (("1"
       (assert)
       (hide -1 2)
       (rewrite "Sum_le")
       (hide -1 2)
       (skosimp*)
       (expand "value_digit")
       (lemma "expt_pos")
       (inst?)
       (rewrite "both_sides_times_pos_le1")
       (expand "max_significand")
       (assert))
      ("2"
       (lemma "expt_pos")
       (inst?)
       (assert)
       (lemma "Sum_nonneg")
       (inst?))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "normal_value")
   (rewrite "abs_value_fin")
   (expand "min_pos")
   (expand "value")
   (expand "min_fp_pos")
   (expand "pos")
   (rewrite "expt_x0")
   (assert)
   (expand "subnormal?")
   (assert)
   (ground)
   (("1"
     (expand "zero?")
     (lemma "both_sides_times_pos_le1")
     (inst - "b ^ (Exp(normalize(fin!1)))"
      "Sum(p, value_digit(min_significand))"
      "Sum(p, value_digit(d(normalize(fin!1))))")
     (("1"
       (ground)
       (hide 2 3)
       (rewrite "normal_value")
       (rewrite "value0")
       (rewrite "min_significand_min"))
      ("2" (lemma "expt_pos") (inst?) (assert))))
    ("2"
     (lemma "value_sig_lt1")
     (inst?)
     (assert)
     (assert)
     (lemma "expt_pos")
     (inst?)
     (lemma "both_sides_times_pos_lt1")
     (inst - "b ^ (Exp(normalize(fin!1)))"
      "Sum(p, value_digit(d(normalize(fin!1))))" "1")
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "value_normal")
   (inst?)
   (lemma "value_subnormal")
   (inst?)
   (lemma "finite_cover")
   (inst?)
   (ground)
   (("1"
     (expand "min_pos")
     (rewrite "min_fp_correct")
     (lemma "both_sides_expt_gt1_le")
     (inst - "b" "(1 + E_min - p)" "E_min")
     (ground))
    ("2"
     (lemma "both_sides_expt_gt1_le")
     (rewrite "max_fp_correct")
     (inst - "b" "E_min" "E_max")
     (ground)
     (case "b^E_max < b ^ (1 + E_max) - b ^ (1 + E_max - p)")
     (("1" (ground))
      ("2"
       (hide -1 -2 -3 -4 -5 2 3 4)
       (lemma "exponent_adjust")
       (inst - "b" "E_max" "p-1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (induct "m" 1 "upto_induction[n!1+1]")
   (("1" (rewrite "Sum") (expand "integer?") (propax))
    ("2"
     (skosimp*)
     (rewrite "Sum" +)
     (rewrite "scale_value")
     (rewrite "value_digit")
     (lift-if)
     (ground)
     (case "FORALL (i,j:int): integer?(i+j)")
     (("1"
       (inst?)
       (("1"
         (hide -3 2)
         (rewrite "associative_mult" :dir rl)
         (rewrite "expt_plus" :dir rl)
         (case "FORALL (i,j:int): integer?(i*j)")
         (("1"
           (inst?)
           (("1" (expand "integer?") (propax))
            ("2"
             (assert)
             (hide 2)
             (case "forall (n:nat): integer?(b^n)")
             (("1" (inst?) (expand "integer?") (propax))
              ("2" (skosimp*) (expand "integer?") (propax))))))
          ("2" (expand "integer?") (propax))))
        ("2" (expand "integer?") (propax))))
      ("2" (expand "integer?" 1) (propax))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1" (expand "Sum") (propax))
    ("2"
     (skosimp*)
     (expand "Sum" +)
     (inst?)
     (rewrite "scale_value")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "scaled_Sum_i")
   (rewrite "scale_value_p")
   (replace-eta "scale_value(d!1, (p - 1))"))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "scaled_Sum_i")
   (lemma "Sum_split")
   (inst - "scale_value(d!1, i!1)" "p" "i!1+1")
   (replace -1)
   (hide -1)
   (lemma "floor_plus_int")
   (inst - "Sum(i!1 + 1, scale_value(d!1, i!1))"
    "Sum(p - (i!1 + 1),
                      LAMBDA (k: nat):
                        scale_value(d!1, i!1)(k + (i!1 + 1)))")
   (("1"
     (replace -1)
     (hide -1)
     (assert)
     (lemma "floor_Sum_mant")
     (inst?)
     (hide 2)
     (skosimp*)
     (rewrite "scale_value")
     (rewrite "value_digit")
     (lift-if)
     (ground)
     (("1"
       (lemma "expt_plus")
       (inst - "(-(1 + i!1 + i!2))" "i!1" "b")
       (lemma "both_sides_times_pos_le1")
       (inst - "b ^ (-i!2 - 1)" "d!1(1 + i!1 + i!2)" "(b-1)")
       (("1" (assert))
        ("2" (hide -1 -2 2) (lemma "expt_pos") (inst?) (assert))))
      ("2"
       (lemma "pos_times_le")
       (inst - "(b-1)" "b ^ (-i!2 - 1)")
       (lemma "expt_pos")
       (inst?)
       (assert))))
    ("2" (hide 2) (lemma "scaled_Sum_int") (expand "integer?") (inst?))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "Sum")
   (rewrite "scale_value")
   (rewrite "value_digit")
   (case-replace
    "(d!1(i!1) * b ^ (-i!1) * b ^ i!1) = d!1(i!1) * (b ^ (-i!1) * b ^ i!1)")
   (("1"
     (hide -1)
     (lemma "expt_plus")
     (inst?)
     (replace -1 :dir rl)
     (hide -1)
     (rewrite "expt_x0")
     (assert)
     (lemma "mod_of_mod")
     (inst?)
     (("1"
       (replace -1 :dir rl)
       (hide -1)
       (case-replace "mod(Sum(i!1, scale_value(d!1, i!1)),b) = 0")
       (("1" (hide -1) (rewrite "mod_lt_nat"))
        ("2"
         (hide 2)
         (case "forall (j:upto(i!1)): mod(Sum(j,scale_value(d!1,i!1)),b) = 0")
         (("1" (inst?))
          ("2"
           (hide 2)
           (induct "j" 1 "upto_induction[i!1]")
           (("1" (expand "Sum") (rewrite "mod_zero"))
            ("2"
             (skosimp*)
             (expand "Sum" +)
             (rewrite "scale_value")
             (rewrite "value_digit")
             (case-replace
              "d!1(jt!1) * b ^ (-jt!1) * b ^ i!1 = d!1(jt!1) * (b ^ (-jt!1) * b ^ i!1)")
             (("1"
               (hide -1)
               (lemma "expt_plus")
               (inst?)
               (replace -1 :dir rl)
               (hide -1)
               (lemma "mod_of_mod")
               (inst?)
               (("1"
                 (replace -1 :dir rl)
                 (hide -1)
                 (replace -2)
                 (hide -2)
                 (case-replace
                  "d!1(jt!1) * b ^ ((-jt!1) + i!1) = (d!1(jt!1) * b ^ ((-jt!1) + i!1-1))*b")
                 (("1"
                   (hide -1)
                   (lemma "mod_sum")
                   (inst - "0" "b" "_")
                   (rewrite "mod_zero")
                   (inst?)
                   (("1" (assert))
                    ("2"
                     (rewrite "closed_times")
                     (case "forall (n:nat):integer_pred(b^n)")
                     (("1" (inst?)) ("2" (skosimp*) (assert))))))
                  ("2"
                   (hide 2)
                   (case "b ^ ((-jt!1) + i!1 - 1) * b = b^(i!1-jt!1)")
                   (("1" (assert))
                    ("2"
                     (hide 2)
                     (lemma "expt_plus")
                     (inst - "i!1-jt!1" "(-1)" "b")
                     (replace -1)
                     (rewrite "expt_inverse")
                     (rewrite "expt_x1")
                     (assert))))))
                ("2"
                 (lemma "scaled_Sum_int")
                 (inst?)
                 (assert)
                 (expand "integer?")
                 (propax))
                ("3"
                 (hide -2 2)
                 (rewrite "closed_times")
                 (case "forall (n:nat):integer_pred(b^n)")
                 (("1" (inst?)) ("2" (skosimp*) (assert))))))
              ("2" (assert))))
            ("3"
             (skosimp*)
             (lemma "scaled_Sum_int")
             (inst?)
             (assert)
             (expand "integer?")
             (propax))))
          ("3"
           (skosimp*)
           (lemma "scaled_Sum_int")
           (inst?)
           (expand "integer?")
           (propax))))
        ("3"
         (lemma "scaled_Sum_int")
         (inst?)
         (expand "integer?")
         (propax))))
      ("2"
       (lemma "scaled_Sum_int")
       (inst?)
       (expand "integer?")
       (propax))))
    ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "value")
   (expand "max_fp_pos")
   (expand "pos")
   (rewrite "expt_x0")
   (lemma "pos_times_gt")
   (assert)
   (inst?)
   (assert)
   (lemma "expt_pos")
   (inst?)
   (assert)
   (case "Sum(p, value_digit(max_significand)) > 0")
   (("1" (ground))
    ("2"
     (hide -1 -2 2)
     (expand "Sum")
     (assert)
     (lemma "Sum_nonneg")
     (inst?)
     (rewrite "value_digit")
     (rewrite "max_significand")
     (lemma "expt_pos")
     (inst?)
     (lemma "pos_times_gt")
     (inst?)
     (ground))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "min_fp_pos")
   (expand "value")
   (expand "pos")
   (rewrite "expt_x0")
   (lemma "expt_pos")
   (inst?)
   (("1"
     (assert)
     (lemma "pos_times_gt")
     (inst?)
     (assert)
     (case "Sum(p, value_digit(min_significand)) > 0")
     (("1" (assert) (assert))
      ("2"
       (hide -1 -2 2)
       (expand "Sum")
       (lemma "Sum_nonneg")
       (inst?)
       (rewrite "value_digit")
       (rewrite "min_significand")
       (lemma "expt_pos")
       (inst?)
       (assert))))
    ("2" (assert) (split) (("1" (assert)) ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "max_fp_neg")
   (expand "value")
   (expand "neg")
   (rewrite "expt_x1")
   (lemma "expt_pos")
   (inst?)
   (lemma "Sum_pos")
   (inst?)
   (assert)
   (lemma "pos_times_gt")
   (inst?)
   (ground)
   (("1"
     (inst + "0")
     (rewrite "value_digit")
     (rewrite "expt_x0")
     (rewrite "max_significand")
     (assert))
    ("2"
     (inst + "0")
     (rewrite "value_digit")
     (rewrite "expt_x0")
     (rewrite "max_significand")
     (assert))
    ("3"
     (inst + "0")
     (rewrite "value_digit")
     (rewrite "max_significand")
     (rewrite "expt_x0")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "min_fp_neg")
   (expand "value")
   (expand "neg")
   (rewrite "expt_x1")
   (assert)
   (lemma "expt_pos")
   (inst?)
   (lemma "Sum_pos")
   (inst?)
   (lemma "pos_times_gt")
   (inst?)
   (ground)
   (("1"
     (inst + "p-1")
     (rewrite "value_digit")
     (rewrite "min_significand")
     (hide 1 3 4 5 6)
     (hide -1)
     (lemma "expt_pos")
     (inst?)
     (assert))
    ("2"
     (hide -1 1 3 4 5 6)
     (inst + "p-1")
     (expand "value_digit")
     (expand "min_significand")
     (assert))
    ("3"
     (hide -1 1 3 4 5 6)
     (inst + "p-1")
     (expand "value_digit")
     (expand "min_significand")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (tcc)
   (("1"
     (rewrite "pos_times_ge")
     (assert)
     (lemma "expt_pos")
     (expand "^")
     (inst?)
     (assert))
    ("2"
     (lemma "expt_pos")
     (expand "^")
     (inst?)
     (assert)
     (lemma "expt_pos")
     (assert)
     (inst -1 "-n!1" "b")
     (assert)
     (lemma "pos_times_gt")
     (inst -1 "d!1(n!1)"
      "expt(b, m!1) * (1 / (b * expt(b, -(-n!1) - 1)))")
     (("1"
       (assert)
       (prop)
       (lemma "pos_times_gt")
       (inst -1 "expt(b, m!1)" "(1 / (b * expt(b, -(-n!1) - 1)))")
       (("1" (assert))
        ("2"
         (lemma "zero_times3")
         (inst?)
         (assert)
         (lemma "expt_nonzero_aux")
         (inst?)
         (assert))))
      ("2"
       (lemma "zero_times3")
       (inst?)
       (assert)
       (lemma "zero_times3")
       (inst?)
       (assert)
       (lemma "expt_nonzero_aux")
       (inst?)
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_854_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "integer?(scale_value(d!1, p - 1)(n!1))")
   (("1" (expand "integer?") (assert))
    ("2"
     (hide 2)
     (rewrite "scale_value")
     (rewrite "value_digit")
     (lift-if)
     (ground)
     (("1"
       (case-replace
        "(d!1(n!1) * b ^ (p - 1) * b ^ (-n!1))=(d!1(n!1) * b ^ (p - 1 - n!1))")
       (("1"
         (hide -1)
         (case "FORALL (i,j:int): integer?(i*j)")
         (("1"
           (inst?)
           (assert)
           (hide 2)
           (expand "^")
           (assert)
           (case "FORALL (n:nat): integer_pred(expt(b, n))")
           (("1" (inst?)) ("2" (hide -1 2) (induct "n") (skosimp*))))
          ("2" (expand "integer?") (propax))))
        ("2" (lemma "expt_plus") (inst?) (inst -1 "-n!1") (assert))))
      ("2" (expand "integer?") (propax))))
    ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: NaN_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_nan")
   (lift-if)
   (expand "fp_signal")
   (assert)
   (split 2)
   (("1"
     (flatten)
     (hide -1)
     (typepred "fp_quiet(op!1, mk_quiet(fp1!1), mk_quiet(fp2!1))")
     (("1" (grind)) ("2" (grind))))
    ("2"
     (flatten)
     (typepred "fp_quiet(op!1, fp1!1, fp2!1)")
     (("1" (expand "signal?") (grind)) ("2" (propax))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: NaN_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst +
    "lambda op,fp1,(fp2|NaN?(fp1) or NaN?(fp2)): if NaN?(fp1) then fp1 else fp2 endif")
   (("1" (skolem-typepred) (prop)) ("2" (skosimp*))))


proof_type: f_proof
decl_type: formula
library: float
theory: infinity_arithmetic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "fp_sub_inf")
   (rewrite "fp_add_inf")
   (rewrite "toggle_infinite")
   (lift-if)
   (lift-if)
   (ground)
   (("1"
     (expand "toggle_sign")
     (assert)
     (typepred "i_sign(num2!1)")
     (typepred "i_sign(num1!1)")
     (ground))
    ("2" (expand "toggle_sign") (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: comparison1
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (prop)
   (("1"
     (expand "pos")
     (lemma "value_nonzero")
     (inst?)
     (hide 2)
     (expand "fp_compare")
     (assert)
     (ground)
     (("1"
       (lift-if)
       (expand "n_value")
       (rewrite "expt_x0")
       (ground)
       (case "max_pos < b^(1+E_max)")
       (("1" (expand "abs") (lift-if) (ground))
        ("2"
         (hide -1 -2 -3 2)
         (lemma "max_fp_correct")
         (replace -1)
         (assert)
         (lemma "expt_pos")
         (inst-cp - "1+E_max" "b")
         (inst - "1+E_max-p" "b")
         (assert))))
      ("2"
       (expand "n_value")
       (rewrite "expt_x0")
       (expand "zero?")
       (assert)
       (lemma "expt_pos")
       (inst?)
       (assert))))
    ("2"
     (expand "pos")
     (expand "fp_compare")
     (assert)
     (lift-if)
     (ground)
     (hide -1 1 2 3)
     (expand "n_value")
     (typepred "i_sign(num!1)")
     (ground)
     (replace -1)
     (rewrite "expt_x0")
     (rewrite "expt_x1")
     (lemma "expt_pos")
     (inst?)
     (rewrite "both_sides_times_pos_gt1"))))


proof_type: f_proof
decl_type: formula
library: float
theory: round
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "abs")
   (lift-if)
   (prop)
   (("1" (expand "round_to_even") (lift-if) (ground))
    ("2" (expand "round_to_even") (lift-if) (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: round
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "abs")
   (lift-if)
   (prop)
   (("1"
     (expand "round_to_even")
     (lift-if)
     (ground)
     (expand "integer?")
     (propax))
    ("2"
     (expand "round_to_even")
     (lift-if)
     (ground)
     (expand "integer?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: round
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round")
   (lift-if)
   (prop)
   (("1" (lemma "round_to_even1") (inst?) (assert)) ("2" (grind))
    ("3" (grind)) ("4" (grind))))


proof_type: f_proof
decl_type: formula
library: float
theory: round
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round")
   (lift-if)
   (ground)
   (("1" (expand "round_to_even") (lift-if) (ground))
    ("2" (expand "abs") (lift-if) (expand "sgn") (ground))))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "Exp_of(x!1)")
   (("1"
     (rewrite "expt_inverse")
     (assert)
     (lemma "expt_pos")
     (inst?)
     (rewrite "times_div1")
     (ground)
     (("1" (rewrite "div_mult_pos_le2"))
      ("2"
       (rewrite "div_mult_pos_lt1")
       (rewrite "expt_plus")
       (rewrite "expt_x1"))))
    ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "significand")
   (expand "E")
   (rewrite "associative_mult" :dir rl)
   (rewrite "associative_mult" :dir rl)
   (rewrite "associative_mult" :dir rl)
   (rewrite "expt_plus" :dir rl)
   (rewrite "expt_x0")
   (grind))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (use "real_components")
   (expand "abs")
   (expand "sgn")
   (lift-if)
   (assert)
   (ground))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "b^i!1 < b^(1+j!1) & b^j!1 < b^(1+i!1)")
   (("1"
     (hide -2 -3 -4 -5)
     (flatten)
     (rewrite "both_sides_expt_gt1_lt")
     (rewrite "both_sides_expt_gt1_lt")
     (assert))
    ("2" (assert)) ("3" (assert)) ("4" (assert)) ("5" (assert))
    ("6" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "E")
   (expand "abs")
   (lemma "Exp_of_unique")
   (inst - "Exp_of(x!1)" "i!1" "x!1")
   (assert)
   (hide 2)
   (replace -1)
   (hide -1)
   (split)
   (("1" (assert)) ("2" (assert))
    ("3"
     (rewrite "commutative_mult")
     (rewrite "div_mult_pos_le1" :dir rl))
    ("4"
     (rewrite "commutative_mult")
     (rewrite "div_mult_pos_lt2" :dir rl)
     (rewrite "expt_div")
     (rewrite "expt_x1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "posreal_exponent")
   (inst - "i!1" "n1!1" "abs(z!1)")
   (expand "E")
   (expand "sgn")
   (expand "abs")
   (lift-if)
   (lift-if)
   (assert)
   (ground))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (rewrite "div_mult_pos_le2")
     (("1"
       (expand "scale")
       (lemma "expt_plus")
       (inst - "p-1" "1+Exp_of(x!1)-p" "b")
       (assert))
      ("2" (lemma "expt_pos") (inst?) (assert))))
    ("2"
     (rewrite "div_mult_pos_lt1")
     (("1" (rewrite "expt_plus" :dir rl) (expand "scale") (assert))
      ("2" (lemma "expt_pos") (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality)
   (("1"
     (hide 2)
     (expand "truncate")
     (rewrite "associative_mult")
     (rewrite "expt_plus" :dir rl))
    ("2" (hide 2) (use "expt_pos") (rewrite "pos_times_ge") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "Exp_of_unique")
   (use "expt_pos")
   (("1"
     (inst?)
     (("1"
       (inst - "b^j!1*px!1")
       (("1"
         (assert)
         (hide 2)
         (rewrite "commutative_mult")
         (rewrite "div_mult_pos_le1" :dir rl)
         (rewrite "div_mult_pos_lt2" :dir rl)
         (rewrite "expt_div")
         (rewrite "expt_div")
         (assert))
        ("2"
         (use "pos_times_gt")
         (("1" (assert) (assert)) ("2" (assert))))
        ("3" (assert))))
      ("2" (use "pos_times_gt") (("1" (assert) (assert)) ("2" (assert))))
      ("3" (assert))))
    ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "lambda (px:posreal): choose({i:int|b^i<=px & px<b^(i+1)})")
   (("1"
     (skosimp*)
     (rewrite "nonempty_member")
     (("1"
       (expand "member")
       (lemma "exp_of_exists")
       (inst - "b" "px!1")
       (assert))
      ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))
    ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: fp_round_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (use "pos_times_gt")
   (use "expt_pos")
   (assert)
   (assert)
   (rewrite "Exp_of_correct"))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round_under")
   (rewrite "round_int")
   (("1"
     (lemma "expt_plus")
     (inst - "(1 + E_min - p)" "(-(1 + E_min - p))" "b")
     (rewrite "expt_x0")
     (rewrite "associative_mult")
     (assert))
    ("2"
     (hide 2)
     (expand "min_pos")
     (lemma "min_fp_correct")
     (replace -1)
     (hide -1)
     (rewrite "expt_plus" :dir rl)
     (rewrite "expt_x0")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round_under")
   (rewrite "round_int")
   (("1"
     (lemma "expt_plus")
     (inst - "(1 + E_min - p)" "(-(1 + E_min - p))" "b")
     (rewrite "expt_x0")
     (ground)
     (rewrite "associative_mult")
     (assert)
     (rewrite "associative_mult" :dir rl)
     (assert))
    ("2"
     (hide 2)
     (case "integer?(b ^ (-(1 + E_min - p))
                                  * value(fin!1))")
     (("1" (expand "integer?") (propax))
      ("2"
       (hide 2)
       (expand "subnormal?")
       (rewrite "normal_value")
       (expand "value")
       (prop)
       (replace -1)
       (assert)
       (case-replace
        "b ^ (-(1 + E_min - p))
                             *
                             (Sum(p, value_digit(d(normalize(fin!1))))
                                * (-1) ^ sign(normalize(fin!1))
                                * b ^ E_min) =
         (-1)^sign(normalize(fin!1)) *(Sum(p,scale_value_p(d(normalize(fin!1)))))")
       (("1"
         (hide -1)
         (assert)
         (case-replace
          "scale_value_p(d(normalize(fin!1))) = scale_value(d(normalize(fin!1)),p-1)")
         (("1"
           (hide -1)
           (lemma "scaled_Sum_int")
           (inst?)
           (case "FORALL (i,j:int): integer?(i*j)")
           (("1" (inst?) (expand "integer?") (propax))
            ("2" (hide -1 -2 -3 2 3) (expand "integer?") (propax))))
          ("2"
           (hide -1 -2 2 3)
           (apply-extensionality)
           (("1" (expand "scale_value_p") (propax))
            ("2"
             (expand "scale_value")
             (expand "value_digit")
             (hide 2)
             (skosimp*)
             (lift-if)
             (assert)
             (rewrite "associative_mult" :dir rl)
             (rewrite "expt_plus" :dir rl)
             (ground)
             (("1"
               (rewrite "closed_times")
               (rewrite "closed_times")
               (case "forall (n:nat): integer_pred(b^n)")
               (("1" (inst?)) ("2" (skosimp*) (assert))))
              ("2"
               (rewrite "pos_times_ge")
               (lemma "expt_pos")
               (inst?)
               (assert))))))))
        ("2"
         (hide -1 -2 2 3)
         (assert)
         (lemma "scaled_Sum")
         (inst?)
         (replace -1 :dir rl)
         (hide -1)
         (lemma "expt_plus")
         (inst - "E_min" "(-(1 + E_min - p))" "b")
         (replace -1)
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round_under")
   (case-replace
    "abs(r!1
                 - b ^ (1 + E_min - p)
                     * round(b ^ (-(1 + E_min - p)) * r!1, mode!1)) =
     abs(b ^ (1 + E_min - p)) * abs( r!1*b ^ (-(1 + E_min - p)) - round(b ^ (-(1 + E_min - p)) * r!1, mode!1))")
   (("1"
     (hide -1 -2)
     (rewrite "abs")
     (lemma "expt_pos")
     (inst?)
     (assert)
     (lemma "both_sides_times_pos_lt2")
     (inst - "b^(1+E_min-p)" "_" "1")
     (inst?)
     (lemma "round1")
     (inst?)
     (assert))
    ("2"
     (hide -1 2)
     (rewrite "abs_mult" :dir rl)
     (rewrite "expt_plus" :dir rl)
     (rewrite "expt_x0")
     (assert))
    ("3" (assert)) ("4" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round_under")
   (hide -1)
   (case-replace
    "abs(r!1
                 - b ^ (1 + E_min - p)
                     * round(b ^ (-(1 + E_min - p)) * r!1, to_nearest)) =
     abs(b ^ (1 + E_min - p)) * abs( r!1*b ^ (-(1 + E_min - p)) - round(b ^ (-(1 + E_min - p)) * r!1, to_nearest))")
   (("1"
     (hide -1)
     (expand "abs" + 1)
     (lemma "expt_pos")
     (inst?)
     (("1"
       (assert)
       (lemma "both_sides_times_pos_lt2")
       (inst - "b^(1+E_min-p)" "_" "1/2")
       (expand "round")
       (inst?)
       (rewrite "times_div1")
       (lemma "round_to_even1")
       (inst?)
       (assert))
      ("2" (assert) (split) (("1" (assert)) ("2" (assert))))))
    ("2"
     (hide 2)
     (rewrite "abs_mult" :dir rl)
     (rewrite "expt_plus" :dir rl)
     (rewrite "expt_x0")
     (assert))
    ("3" (assert)) ("4" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round_under")
   (hide -1)
   (expand "round")
   (lemma "both_sides_times_pos_ge2")
   (lemma "expt_pos")
   (inst - "(-(1 + E_min - p))" "b")
   (("1"
     (inst - "b ^ (-(1 + E_min - p))"
      "b ^ (1 + E_min - p) * ceiling(b ^ (-(1 + E_min - p)) * r!1)"
      "r!1")
     (("1"
       (replace -2 :dir rl)
       (hide -2)
       (rewrite "associative_mult")
       (rewrite "associative_mult" :dir rl)
       (rewrite "expt_plus" :dir rl)
       (rewrite "expt_x0")
       (assert))
      ("2" (assert)) ("3" (assert)) ("4" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (hide -1)
   (expand "round_under")
   (expand "round")
   (lemma "both_sides_times_pos_le2")
   (inst - "b ^ (-(1 + E_min - p))"
    "b ^ (1 + E_min - p) * floor(b ^ (-(1 + E_min - p)) * r!1)" "r!1")
   (("1"
     (replace -1 :dir rl)
     (hide -1)
     (rewrite "associative_mult")
     (rewrite "associative_mult" :dir rl)
     (rewrite "expt_plus" :dir rl)
     (rewrite "expt_x0")
     (assert))
    ("2" (assert))
    ("3" (lemma "expt_pos") (inst?) (("1" (assert)) ("2" (assert))))
    ("4" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "round_under")
   (rewrite "abs_mult")
   (expand "round")
   (case "forall (r1,r2:real): abs(sgn(r1)*r2) = abs(r2)")
   (("1"
     (inst?)
     (replace -1)
     (hide -1)
     (case "forall (r:real): abs(floor(abs(r)))=floor(abs(r))")
     (("1"
       (inst?)
       (replace -1)
       (hide -1)
       (lemma "both_sides_times_pos_le2")
       (inst - "abs(b ^ (-(1 + E_min - p)))"
        "abs(b ^ (1 + E_min - p)) * floor(abs(b ^ (-(1 + E_min - p)) * r!1))"
        "abs(r!1)")
       (("1"
         (replace -1 :dir rl)
         (hide -1)
         (hide -1)
         (rewrite "abs_mult" :dir rl)
         (rewrite "associative_mult")
         (rewrite "associative_mult" :dir rl)
         (rewrite "abs_mult" :dir rl)
         (rewrite "expt_plus" :dir rl)
         (rewrite "expt_x0")
         (expand "abs" + 2)
         (assert))
        ("2"
         (hide -1 2)
         (lemma "expt_pos")
         (inst?)
         (expand "abs")
         (assert))))
      ("2" (hide -1 2) (grind))))
    ("2" (hide -1 2) (tcc))))


proof_type: t_proof
decl_type: tcc
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (assert)
   (expand "min_pos")
   (lemma "min_fp_correct")
   (replace -1)
   (hide -1)
   (lemma "expt_pos")
   (inst?)
   (assert)
   (expand "abs")
   (lemma "expt_plus")
   (inst - "E_min" "1-p" "b")
   (replace -1)
   (hide -1)
   (lemma "both_sides_times_pos_lt2")
   (inst - "b^E_min" "b^(1-p)" "1")
   (("1" (lemma "expt_gt1_neg") (inst - "b" "p-1") (ground))
    ("2" (lemma "expt_pos") (inst?) (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: over_under
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1" (expand "subnormal?") (expand "zero?") (ground))
    ("2" (lemma "value_subnormal") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality)
   (expand "truncate")
   (expand "d_zero")
   (assert)
   (lemma "div_eq_zero")
   (assert)
   (rewrite "floor_int")
   (rewrite "mod_zero"))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "abs_value_fin")
   (case "b ^ (Exp(fin!1)) * Sum(p, value_digit(d(fin!1))) >=0")
   (("1"
     (apply-extensionality)
     (hide 2)
     (rewrite "truncate")
     (assert)
     (case-replace
      "(b ^ (x!1 - Exp(fin!1))
                         *
                         (b ^ (Exp(fin!1))
                            * Sum(p, value_digit(d(fin!1))))) =
       Sum(p, value_digit(d(fin!1)))*b^x!1")
     (("1"
       (hide -1 -2)
       (lemma "floor_Sum")
       (inst?)
       (replace -1)
       (hide -1)
       (lemma "mod_Sum")
       (inst?))
      ("2"
       (hide -1 2)
       (assert)
       (lemma "expt_plus")
       (inst?)
       (inst - "Exp(fin!1)")
       (assert))))
    ("2"
     (lemma "expt_pos")
     (inst?)
     (lemma "Sum_nonneg")
     (inst?)
     (rewrite "pos_times_ge")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (rewrite "real_to_fp")
   (expand "abs")
   (lemma "expt_pos")
   (inst-cp - "(1+E_max)" "b")
   (assert)
   (hide -2)
   (inst?)
   (assert)
   (rewrite "truncate_zero")
   (expand "sign_of")
   (expand "pos_zero")
   (propax))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sign_of")
   (lift-if)
   (lemma "value_negative")
   (inst?)
   (ground)
   (expand "neg")
   (expand "pos")
   (assert)
   (typepred "sign(fin!1)")
   (assert))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "normal_value")
   (rewrite "abs_value_fin")
   (lemma "value_sig_lt_b")
   (lemma "value_sig_ge1")
   (expand "normal?")
   (assert)
   (inst?)
   (assert)
   (inst?)
   (lemma "expt_pos")
   (inst?)
   (case "(b ^ (Exp(normalize(fin!1)))
                        * Sum(p, value_digit(d(normalize(fin!1)))))>0")
   (("1"
     (assert)
     (typepred
      "Exp_of(b ^ (Exp(normalize(fin!1)))
                     * Sum(p, value_digit(d(normalize(fin!1)))))")
     (lemma "div_mult_pos_lt2")
     (inst - "b ^ (Exp(normalize(fin!1)))"
      "Sum(p, value_digit(d(normalize(fin!1))))"
      "b
                  ^
                  (1
                     +
                     Exp_of(b ^ (Exp(normalize(fin!1)))
                              * Sum(p, value_digit(d(normalize(fin!1))))))")
     (replace -1 :dir rl)
     (hide -1)
     (lemma "div_mult_pos_le1")
     (inst - "b ^ (Exp(normalize(fin!1)))"
      "Sum(p, value_digit(d(normalize(fin!1))))"
      "b
                  ^
                  ( Exp_of(b ^ (Exp(normalize(fin!1)))
                              * Sum(p, value_digit(d(normalize(fin!1))))))")
     (replace -1 :dir rl)
     (hide -1)
     (rewrite "expt_div")
     (rewrite "expt_div")
     (case "(Exp_of(b ^ (Exp(normalize(fin!1)))
                              * Sum(p, value_digit(d(normalize(fin!1))))))
                      > (Exp(normalize(fin!1)))")
     (("1"
       (lemma "expt_gt1_pos")
       (inst - "b"
        "(Exp_of(b ^ (Exp(normalize(fin!1)))
                           * Sum(p, value_digit(d(normalize(fin!1))))))
                   - (Exp(normalize(fin!1)))")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (lemma "expt_gt1_nonpos")
       (inst - "b"
        "-((1
                        +
                        Exp_of(b ^ (Exp(normalize(fin!1)))
                                 * Sum(p, value_digit(d(normalize(fin!1))))))
                       - (Exp(normalize(fin!1))))")
       (("1" (assert)) ("2" (assert))))))
    ("2" (rewrite "pos_times_gt") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "real_to_fp")
   (lift-if)
   (lemma "value_normal")
   (inst?)
   (assert)
   (flatten)
   (assert)
   (case "max_pos < b^(1+E_max)")
   (("1"
     (assert)
     (hide -1 -2 -3)
     (rewrite "Exp_of_value_normal")
     (lemma "finite_disjoint1")
     (inst?)
     (assert)
     (rewrite "normal_value")
     (rewrite "sign_of_value")
     (("1"
       (assert)
       (rewrite "digits_of_finite")
       (rewrite "fp_num_finite_eta"))
      ("2" (expand "zero?") (rewrite "normal_value" +))))
    ("2"
     (hide 2)
     (hide -1 -2 -3)
     (lemma "max_fp_correct")
     (lemma "expt_pos")
     (inst - "(E_max-(p-1))" "b")
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "real_to_fp")
   (lemma "value_subnormal")
   (inst?)
   (assert)
   (flatten)
   (assert)
   (case "b^E_min < b^(1+E_max)")
   (("1"
     (assert)
     (rewrite "normal_value")
     (rewrite "sign_of_value")
     (("1"
       (hide -1)
       (expand "subnormal?")
       (assert)
       (ground)
       (lemma "digits_of_finite")
       (inst?)
       (lemma "fp_num_finite_eta")
       (inst?)
       (replace -5)
       (replace -2)
       (propax))
      ("2"
       (expand "subnormal?")
       (ground)
       (expand "zero?")
       (assert)
       (rewrite "normal_value" +))))
    ("2" (hide -1 -2 -3 2) (rewrite "both_sides_expt_gt1_lt"))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "finite_cover")
   (inst?)
   (ground)
   (("1" (rewrite "real_to_fp_normal"))
    ("2" (rewrite "real_to_fp_subnormal"))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_round")
   (expand "round_scaled")
   (assert)
   (lift-if)
   (assert)
   (ground)
   (expand "scale")
   (rewrite "Exp_of_value_normal")
   (("1"
     (rewrite "round_int")
     (("1" (rewrite "expt_inverse") (assert))
      ("2"
       (hide 2 3 4)
       (case "integer?(value(fin!1)*b^(-(1 + Exp(normalize(fin!1)) - p)))")
       (("1" (expand "integer?") (assert) (ground))
        ("2"
         (hide 2)
         (rewrite "normal_value")
         (expand "value")
         (case-replace
          "(Sum(p, value_digit(d(normalize(fin!1))))
                                * (-1) ^ sign(normalize(fin!1))
                                * b ^ Exp(normalize(fin!1))
                                * b ^ (-(1 + Exp(normalize(fin!1)) - p))) =
           (-1) ^ sign(normalize(fin!1))
                                * Sum(p, value_digit(d(normalize(fin!1))))
                                * b ^ (p-1)")
         (("1"
           (hide -1)
           (case-replace
            "((-1) ^ sign(normalize(fin!1))
                                 * Sum(p, value_digit(d(normalize(fin!1))))
                                 * b ^ (p - 1)) = ((-1) ^ sign(normalize(fin!1))
                                 * Sum(p, scale_value_p(d(normalize(fin!1)))))")
           (("1"
             (hide -1)
             (case "FORALL (i,j:int): integer?(i*j)")
             (("1"
               (inst?)
               (hide 2)
               (case "forall (n:nat),(d:digits): integer?(Sum(n,scale_value_p(d)))")
               (("1" (expand "integer?") (inst?))
                ("2"
                 (hide 2)
                 (induct "n")
                 (("1" (expand "Sum") (expand "integer?") (propax))
                  ("2"
                   (skosimp*)
                   (rewrite "Sum")
                   (inst?)
                   (case "FORALL (i,j:int): integer?(i+j)")
                   (("1" (inst?) (expand "integer?") (propax))
                    ("2"
                     (hide -1 2)
                     (skosimp*)
                     (expand "integer?")
                     (propax))))))))
              ("2" (hide 2) (skosimp*) (expand "integer?") (propax))))
            ("2"
             (hide 2)
             (assert)
             (lemma "scaled_Sum")
             (inst?)
             (assert))))
          ("2"
           (hide 2)
           (assert)
           (lemma "expt_plus")
           (inst - "Exp(normalize(fin!1))"
            "(-(1+Exp(normalize(fin!1)) - p))" "b")
           (assert))))))))
    ("2"
     (hide 3)
     (expand "over_under?")
     (lemma "value_subnormal")
     (inst?)
     (ground)
     (lemma "finite_cover")
     (inst?)
     (expand "zero?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "round_value")
   (expand "fp_round")
   (lift-if)
   (assert)
   (prop)
   (expand "round_exceptions")
   (expand "round_exceptions_x")
   (lemma "value_nonzero")
   (inst?)
   (assert)
   (expand "zero?")
   (lift-if)
   (prop)
   (("1" (assert))
    ("2"
     (expand "over_under?")
     (assert)
     (expand "underflow")
     (lift-if)
     (assert)
     (rewrite "round_under_value")
     (lemma "finite_cover")
     (inst?)
     (expand "zero?")
     (lemma "value_normal")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_round")
   (expand "round_scaled")
   (lift-if)
   (ground)
   (case-replace
    "r!1
                 - b ^ scale(abs(r!1))
                     * round(r!1 * b ^ (-scale(abs(r!1))), mode!1)=
     b^scale(abs(r!1))*(r!1*b ^ (-scale(abs(r!1))) -round(r!1 * b ^ (-scale(abs(r!1))), mode!1))")
   (("1"
     (hide -1)
     (rewrite "abs_mult")
     (lemma "div_mult_pos_lt2")
     (inst - "abs(b ^ scale(abs(r!1)))"
      "abs((r!1 * b ^ (-scale(abs(r!1)))
                     - round(r!1 * b ^ (-scale(abs(r!1))), mode!1)))"
      "b ^ (1 + Exp_of(abs(r!1)) - p)")
     (("1"
       (replace -1 :dir rl)
       (hide -1)
       (case-replace
        "b ^ (1 + Exp_of(abs(r!1)) - p) / abs(b ^ scale(abs(r!1)))=1")
       (("1" (rewrite "round1"))
        ("2"
         (hide 3)
         (hide 2)
         (lemma "expt_pos")
         (rewrite "abs")
         (lift-if)
         (ground)
         (("1"
           (rewrite "abs")
           (lift-if)
           (inst?)
           (assert)
           (expand "scale")
           (assert))
          ("2"
           (rewrite "abs")
           (lift-if)
           (inst?)
           (assert)
           (expand "scale")
           (assert))))
        ("3"
         (hide 3)
         (expand "abs" + 1)
         (lemma "expt_pos")
         (inst?)
         (assert))))
      ("2"
       (hide 3)
       (lemma "expt_pos")
       (inst?)
       (expand "abs" + 1)
       (assert))))
    ("2" (hide 3) (assert) (rewrite "expt_inverse") (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_round")
   (expand "round_scaled")
   (assert)
   (case "abs(r!1)>0")
   (("1"
     (case-replace
      "(r!1
                   - b ^ scale(abs(r!1))
                       * round(r!1 * b ^ (-scale(abs(r!1))), to_nearest)) =
       b^scale(abs(r!1))*(r!1*b^(-scale(abs(r!1))) - round(r!1 * b ^ (-scale(abs(r!1))), to_nearest))")
     (("1"
       (hide -1)
       (rewrite "abs_mult")
       (lemma "div_mult_pos_le2")
       (inst - "abs(b ^ scale(abs(r!1)))"
        "abs((r!1 * b ^ (-scale(abs(r!1)))
                       - round(r!1 * b ^ (-scale(abs(r!1))), to_nearest)))"
        "b ^ (1 + Exp_of(abs(r!1)) - p) / 2")
       (("1"
         (replace -1 :dir rl)
         (hide -1)
         (case-replace
          "b ^ (1 + Exp_of(abs(r!1)) - p) / 2 / abs(b ^ scale(abs(r!1)))=1/2")
         (("1" (expand "round") (rewrite "round_to_even1"))
          ("2"
           (hide 3)
           (rewrite "div_div2")
           (("1"
             (expand "scale")
             (expand "abs" + 2)
             (lift-if)
             (lemma "expt_pos")
             (inst?)
             (assert))
            ("2"
             (hide 2)
             (lemma "expt_pos")
             (inst?)
             (expand "abs" + 1)
             (assert))))
          ("3"
           (hide 3)
           (lemma "expt_pos")
           (inst?)
           (expand "abs" + 1)
           (assert))))
        ("2"
         (hide 3)
         (lemma "expt_pos")
         (inst?)
         (expand "abs" + 1)
         (assert))))
      ("2" (assert) (hide 3) (rewrite "expt_inverse") (assert))))
    ("2" (hide 3) (expand "abs") (lift-if) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_round")
   (expand "round_scaled")
   (lift-if)
   (assert)
   (ground)
   (expand "round")
   (assert)
   (lemma "div_mult_pos_ge2")
   (inst - "b ^ scale(abs(r!1))" "ceiling(r!1 * b ^ (-scale(abs(r!1))))"
    "r!1")
   (("1" (replace -1 :dir rl) (rewrite "expt_inverse") (assert))
    ("2" (lemma "expt_pos") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_round")
   (expand "round_scaled")
   (lift-if)
   (ground)
   (expand "round")
   (lemma "div_mult_pos_le2")
   (inst - "b ^ scale(abs(r!1))" "floor(r!1 * b ^ (-scale(abs(r!1))))"
    "r!1")
   (("1"
     (replace -1 :dir rl)
     (rewrite "expt_inverse")
     (hide -1)
     (typepred "floor(r!1 * (1 / (b ^ scale(abs(r!1)))))")
     (("1" (assert)) ("2" (skosimp) (lemma "expt_pos") (inst?) (assert))
      ("3" (skosimp*) (lemma "expt_nonzero") (inst?) (assert))
      ("4" (rewrite "expt_nonzero"))))
    ("2" (lemma "expt_pos") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_round")
   (assert)
   (lift-if)
   (prop)
   (("1" (assert))
    ("2"
     (case "abs(r!1)>0")
     (("1"
       (hide 3)
       (expand "round_scaled")
       (rewrite "abs_mult")
       (name-replace "sr!1" "scale(abs(r!1))")
       (rewrite "expt_inverse")
       (lemma "expt_pos")
       (inst?)
       (name-replace "s!1" "b^sr!1")
       (case "abs(s!1)>0")
       (("1"
         (lemma "div_mult_pos_le2")
         (inst - "abs(s!1)" "abs(round(r!1/s!1,to_zero))" "abs(r!1)")
         (("1"
           (replace -1 :dir rl)
           (hide -1)
           (case-replace "abs(r!1) / abs(s!1) = abs(r!1/s!1)")
           (("1"
             (hide -1)
             (name-replace "r!2" "r!1/s!1")
             (("1" (hide -1 -2 -3 1) (grind)) ("2" (assert))))
            ("2"
             (hide -3 2 3)
             (grind)
             (("1" (rewrite "neg_div_lt")) ("2" (rewrite "neg_div_lt"))))
            ("3" (assert)) ("4" (assert))))
          ("2" (assert))))
        ("2" (hide -2 2 3) (expand "abs") (lift-if) (assert))))
      ("2" (hide 3 4) (grind))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "abs(r!1)>0")
   (("1"
     (typepred "Exp_of(abs(r!1))")
     (("1"
       (ground)
       (("1"
         (case "b^E_min<= abs(r!1)")
         (("1"
           (lemma "both_sides_expt_gt1_lt")
           (inst - "b" "E_min" "(1 + Exp_of(abs(r!1)))")
           (assert))
          ("2" (assert))))
        ("2"
         (case "abs(r!1)<b^(1+E_max)")
         (("1"
           (lemma "both_sides_expt_gt1_lt")
           (inst - "b" "Exp_of(abs(r!1))" "1+E_max")
           (assert))
          ("2" (assert))))))
      ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
      ("4" (propax))))
    ("2"
     (lemma "expt_pos")
     (inst - "E_min" "b")
     (("1" (assert)) ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: real_to_fp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "abs")
   (lift-if)
   (ground)
   (lemma "finite_disjoint1")
   (inst?)
   (expand "zero?")
   (propax))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_defs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_add")
   (expand "fp_add_x")
   (lift-if)
   (expand "fp_nan")
   (expand "fp_nan_x")
   (expand "fp_add_inf")
   (expand "fp_add_inf_x")
   (ground)
   (expand "fp_op")
   (expand "fp_op_x")
   (expand "real_to_fp_x")
   (expand "fp_round")
   (expand "fp_round_x")
   (lift-if)
   (expand "round_exceptions")
   (propax))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854_defs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "fp_sub")
   (expand "fp_add")
   (rewrite "toggle_finite")
   (rewrite "toggle_NaN")
   (lift-if)
   (assert)
   (split)
   (("1"
     (flatten)
     (expand "fp_op")
     (expand "apply")
     (rewrite "value_toggle")
     (assert)
     (lift-if)
     (assert)
     (ground)
     (expand "signed_zero")
     (case "forall fp: zero?(toggle_sign(fp)) iff zero?(fp)")
     (("1"
       (inst?)
       (replace -1)
       (case "forall (fin1,fin2: (finite?)): (sign(fin1) = sign(toggle_sign(fin2))) iff (sign(fin1) /= sign(fin2))")
       (("1" (inst?) (replace -1) (propax))
        ("2"
         (hide -1 -2 -3 -4 2 3 4)
         (skosimp*)
         (expand "toggle_sign")
         (typepred "sign(fin1!1)")
         (typepred "sign(fin2!1)")
         (ground))
        ("3"
         (hide -1 -2 -3 -4 2 3 4)
         (skosimp*)
         (rewrite "toggle_finite"))))
      ("2"
       (hide -1 -2 -3 2 3 4)
       (skosimp*)
       (expand "zero?")
       (rewrite "toggle_finite")
       (rewrite "value_toggle")
       (ground))))
    ("2"
     (flatten)
     (rewrite "fp_sub_inf_def")
     (("1" (ground)) ("2" (ground))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "E_balance")
   (lemma "expt_x1")
   (inst?)
   (lemma "expt_x0")
   (inst?)
   (ground)
   (lemma "expt_plus")
   (inst - "1" "E_max+E_min" "b")
   (assert)
   (typepred "b")
   (case "forall (i:above(1)): 4<=i*i")
   (("1" (inst?) (assert))
    ("2"
     (induct "i" 1 "above_induction[1]")
     (("1" (assert)) ("2" (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_854
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "E_balance")
   (lemma "Exponent_range")
   (ground)
   (("1" (cross-mult -3)) ("2" (cross-mult -2))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "value_nonzero")
   (inst -1 "float_to_IEEE(Fnormalize(b)(f))")
   (("1"
     (split)
     (("1" (assert) (flatten) (assert))
      ("2" (expand "zero?") (assert) (grind-reals))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "Sterbenz")
   (inst -1 "b" "IEEE_to_float(ieee)" "IEEE_to_float(ieee2)")
   (split)
   (("1"
     (inst 1
      "float_to_IEEE(Fnormalize(b)(Fminus(IEEE_to_float(ieee2), IEEE_to_float(ieee))))")
     (("1"
       (case "value(float_to_IEEE(Fnormalize(b)
                                                            (Fminus
                                                             (IEEE_to_float(ieee2),
                                                              IEEE_to_float(ieee)))))=FtoR(Fnormalize(b)
                                                            (Fminus
                                                             (IEEE_to_float(ieee2),
                                                              IEEE_to_float(ieee))))")
       (("1"
         (copy -2)
         (rewrite -2)
         (rewrite "FnormalizeCorrect")
         (rewrite "FminusCorrect")
         (assert))
        ("2" (hide 2) (assert))))
      ("2"
       (lemma "E_max_gt_E_min")
       (rewrite "FnormalizeCorrect")
       (rewrite "FminusCorrect")
       (trans-ineq 1 "abs(FtoR(IEEE_to_float(ieee2)))" :strict 2)
       (("1" (expand "abs") (grind-reals)) ("2" (assert))))))
    ("2" (assert)) ("3" (assert)) ("4" (assert)) ("5" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_Min")
   (grind-reals)
   (rewrite "RND_aux_alt_def")
   (expand "RND_aux_alt")
   (assert)
   (expand "b")
   (expand "vNum")
   (rewrite "expt_plus" :dir rl)
   (case-replace "((-(-E_min - 1 + p) - 1) + p)=E_min")
   (("1"
     (grind-reals)
     (("1"
       (hide -1)
       (expand "fp_round")
       (expand "over_under?")
       (expand "abs" 2)
       (grind-reals)
       (("1"
         (case-replace "floor(0)=0")
         (("1" (expand "FtoR") (assert)) ("2" (assert))))
        ("2"
         (expand "round_exceptions")
         (expand "round_exceptions_x")
         (expand "abs" 3)
         (grind-reals)
         (("1"
           (hide 2)
           (flip-ineq -4)
           (rewrite "max_fp_correct")
           (trans-ineq 1 "radix ^ E_min")
           (("1" (assert))
            ("2"
             (trans-ineq 1 "radix ^ E_max")
             (("1"
               (rewrite "Exp_increq_1")
               (lemma " E_max_gt_E_min")
               (assert))
              ("2"
               (move-terms 1 r 2)
               (trans-ineq 1 "radix ^ E_max+radix ^ E_max")
               (("1"
                 (move-terms 1 r 1)
                 (assert)
                 (rewrite "Exp_increq_1"))
                ("2" (rewrite "expt_plus") (assert))))))))
          ("2"
           (lemma " E_max_gt_E_min")
           (expand "underflow")
           (grind-reals)
           (expand "round_under")
           (expand "FtoR")
           (case-replace "-(-E_min - 1 + p)=(1 + E_min - p)")
           (("1"
             (div-by 4 "radix ^ (1 + E_min - p)")
             (expand "round")
             (assert))
            ("2" (assert))))))))
      ("2"
       (flip-ineq 2)
       (expand "fp_round")
       (expand "over_under?")
       (grind-reals)
       (("1"
         (expand "round_exceptions")
         (expand "round_exceptions_x")
         (expand "overflow")
         (grind-reals)
         (lemma " max_fp_correct")
         (expand "abs")
         (expand "FtoR")
         (case-replace
          "floor(ln(r * radix / radix ^ p) / ln(radix))=(E_max + 1) - p")
         (("1"
           (case-replace
            "floor(r * radix ^ (-((E_max + 1) - p)))=radix^p-1")
           (("1" (rewrite -3) (assert) (rewrite "expt_plus" :dir rl))
            ("2"
             (hide 2 -1)
             (case " radix ^ p - 1<= r * radix ^ (-((E_max + 1) - p))")
             (("1"
               (case "r * radix ^ (-((E_max + 1) - p)) < (radix ^ p-1)+1")
               (("1"
                 (assert)
                 (case "FORALL (g:real,i:int): g<i+1 => i<= g=> floor(g)=i")
                 (("1" (inst?) (assert))
                  ("2" (hide-all-but 1) (skosimp*) (assert))))
                ("2"
                 (hide 2 -1)
                 (assert)
                 (trans-ineq 1
                  "radix ^ (1 + E_max)*radix ^ (-(1 + E_max - p))"
                  :strict 1)
                 (("1" (grind-reals))
                  ("2" (rewrite "expt_plus" :dir rl) (assert))))))
              ("2"
               (div-by 1 "radix ^ (-((E_max + 1) - p))")
               (trans-ineq 1 " max_pos")
               (("1"
                 (mult-by -8 "radix ^ (-(1 + E_max - p))")
                 (grind-reals))
                ("2"
                 (mult-by 1 "radix ^ (-((E_max + 1) - p))")
                 (rewrite -1)
                 (assert)
                 (rewrite "expt_plus" :dir rl)
                 (rewrite "expt_plus" :dir rl)
                 (assert))
                ("3" (assert))))))))
          ("2"
           (hide 2)
           (case "FORALL (g:real,i:int): g<i+1 => i<= g=> floor(g)=i")
           (("1"
             (inst?)
             (split)
             (("1" (propax))
              ("2"
               (mult-by 1 "ln(radix)")
               (("1"
                 (rewrite "ln_expt" :dir rl)
                 (lemma "ln_increasing")
                 (expand "increasing?")
                 (inst?)
                 (split)
                 (("1" (propax))
                  ("2"
                   (mult-by 1 "radix ^ p")
                   (rewrite "expt_plus" :dir rl)
                   (trans-ineq 1 " max_pos*radix")
                   (("1" (mult-by -2 "radix") (grind-reals))
                    ("2"
                     (rewrite -1)
                     (assert)
                     (move-terms 1 r 2)
                     (trans-ineq 1
                      "radix ^ (1 + E_max)+radix ^ (1 + E_max)")
                     (("1"
                       (move-terms 1 r 1)
                       (assert)
                       (trans-ineq 1 "radix ^ ((1 + E_max - p)+1)")
                       (("1"
                         (lemma "expt_plus")
                         (inst -1 "(1 + E_max - p)" "1" "radix")
                         (rewrite "expt_x1")
                         (assert))
                        ("2" (rewrite "Exp_increq_1"))))
                      ("2"
                       (grind-reals)
                       (div-by 1 "radix ^ (1 + E_max)")
                       (assert))))
                    ("3" (div-by 1 "radix") (assert))))))
                ("2"
                 (case "ln(radix) > 0")
                 (("1" (split) (("1" (assert)) ("2" (propax))))
                  ("2"
                   (lemma "ln_strict_increasing")
                   (expand "strict_increasing?")
                   (inst -1 "1" "radix")
                   (rewrite "ln_1")
                   (assert))))))
              ("3"
               (mult-by 1 "ln(radix)")
               (("1"
                 (rewrite "ln_expt" :dir rl)
                 (lemma "ln_strict_increasing")
                 (expand "strict_increasing?")
                 (inst?)
                 (split)
                 (("1" (propax))
                  ("2"
                   (mult-by 1 "radix ^ p")
                   (rewrite "expt_plus" :dir rl)
                   (case-replace
                    "radix ^ (2 + E_max)= radix ^ (1 + E_max)*radix")
                   (("1" (grind-reals))
                    ("2"
                     (lemma "expt_plus")
                     (inst -1 "1+E_max" "1" "radix")
                     (rewrite "expt_x1")
                     (assert))))))
                ("2"
                 (lemma "ln_strict_increasing")
                 (expand "strict_increasing?")
                 (inst -1 "1" "radix")
                 (rewrite "ln_1")
                 (assert))))))
            ("2" (hide-all-but 1) (skosimp*) (assert))))))
        ("2"
         (flip-ineq 2)
         (expand "round_scaled")
         (case-replace
          "scale(abs(r))=floor(ln(r * radix / radix ^ p) / ln(radix))")
         (("1" (expand "FtoR") (expand "round") (assert))
          ("2"
           (hide 2 3)
           (expand "abs" 1)
           (expand "scale")
           (move-terms 1 l (1 3))
           (lemma "Exp_of_unique")
           (inst?)
           (inst -1 "r")
           (split)
           (("1" (propax)) ("2" (assert)) ("3" (assert))
            ("4"
             (lemma "hathat_int")
             (inst -1
              "(floor(ln(r * radix / radix ^ p) / ln(radix)) - 1 + p)")
             (rewrite -1 :dir rl)
             (hide -1 2 -3)
             (expand "^^")
             (trans-ineq 1
              "exp(ln(r * radix / radix ^ p) / ln(radix) * ln(radix) +
                                                                   ln(radix) * p
                                                                   - ln(radix))")
             (("1"
               (lemma "exp_increasing")
               (expand "increasing?")
               (inst?)
               (split)
               (("1" (propax))
                ("2"
                 (hide 2)
                 (assert)
                 (div-by 1 "ln(radix)")
                 (("1" (assert))
                  ("2"
                   (case "ln(radix) > 0")
                   (("1" (split) (("1" (assert)) ("2" (propax))))
                    ("2"
                     (lemma "ln_strict_increasing")
                     (expand "strict_increasing?")
                     (inst -1 "1" "radix")
                     (split)
                     (("1" (rewrite "ln_1") (assert))
                      ("2" (assert))))))))))
              ("2"
               (rewrite "ln_div")
               (rewrite "hathat_int" :dir rl)
               (expand "^^")
               (rewrite "ln_exp")
               (case-replace
                "ln(r * radix) + ln(radix) * p - p * ln(radix) - ln(radix)
                                                                 = ln(r * radix)-ln(radix)")
               (("1"
                 (rewrite "ln_div" :dir rl)
                 (case-replace "r * radix / radix=r")
                 (("1" (rewrite "exp_ln") (assert)) ("2" (field 1))))
                ("2" (assert))))))
            ("5"
             (hide 2 -3)
             (rewrite "hathat_int" :dir rl)
             (rewrite "hathat_int" :dir rl)
             (expand "^^")
             (trans-ineq 1
              "exp((ln(r * radix / exp(p * ln(radix))) / ln(radix)-1) *
                                                                    ln(radix)
                                                                    + ln(radix) * p)"
              :strict 2)
             (("1"
               (rewrite "ln_div")
               (rewrite "ln_exp")
               (rewrite "ln_mult")
               (case-replace
                "(((ln(r) + ln(radix) - p * ln(radix)) / ln(radix) - 1) *
                                                                            ln(radix)
                                                                            + ln(radix) * p)=ln(r)")
               (("1" (rewrite "exp_ln") (assert)) ("2" (field 1))))
              ("2"
               (lemma "exp_strict_increasing")
               (expand "strict_increasing?")
               (inst?)
               (split)
               (("1" (propax))
                ("2"
                 (hide 2)
                 (assert)
                 (div-by 1 "ln(radix)")
                 (("1" (field 1))
                  ("2"
                   (case "ln(radix) > 0")
                   (("1" (split) (("1" (assert)) ("2" (propax))))
                    ("2"
                     (lemma "ln_strict_increasing")
                     (expand "strict_increasing?")
                     (inst -1 "1" "radix")
                     (split)
                     (("1" (rewrite "ln_1") (assert))
                      ("2" (assert))))))))))))))))))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "RND_Max")
   (rewrite "FoppCorrect")
   (expand "RND_Min")
   (grind-reals)
   (("1"
     (rewrite "FoppCorrect")
     (lemma "round_value2")
     (inst -1 "float_to_IEEE(RND_aux(b)(r))" "to_pos")
     (("1" (split) (("1" (assert)) ("2" (propax))))
      ("2"
       (trans-ineq 1 "max_pos" :strict 2)
       (("1" (assert)) ("2" (rewrite "max_fp_correct") (grind-reals))))))
    ("2"
     (rewrite "FpredFoppFsucc")
     (rewrite "FoppCorrect")
     (rewrite "FoppCorrect")
     (assert)
     (case-replace
      "FtoR(Fsucc(b)(RND_aux(b)(r)))=FtoR(RND_aux(b)(r))+Fulp(b)(RND_aux(b)(r))")
     (("1"
       (rewrite "FulpCanonic")
       (mult-by 2 "-1")
       (assert)
       (hide -1)
       (rewrite "RND_aux_alt_def")
       (expand "RND_aux_alt")
       (expand "b")
       (expand "vNum")
       (rewrite "expt_plus" :dir rl)
       (case-replace "((-(-E_min - 1 + p) - 1) + p)=E_min")
       (("1"
         (grind-reals)
         (("1"
           (expand "FtoR")
           (expand* "fp_round" "over_under?")
           (expand "abs")
           (expand "round_exceptions")
           (expand "round_exceptions_x")
           (expand "underflow")
           (grind-reals)
           (expand "round_under")
           (expand "round")
           (case-replace "-(-E_min - 1 + p)=1 + E_min - p")
           (("1"
             (div-by 3 "radix ^ (1 + E_min - p)")
             (case-replace
              " (radix ^ (1 + E_min - p) +
                                                                          floor(r * radix ^ (-E_min - 1 + p)) * radix ^ (1 + E_min - p))
                                                                         / radix ^ (1 + E_min - p)=floor(r * radix ^ (-E_min - 1 + p))+1")
             (("1"
               (case "FORALL (g:real): not floor(g)=g => ceiling(g)=floor(g)+1")
               (("1"
                 (inst?)
                 (split)
                 (("1" (assert))
                  ("2"
                   (mult-by -1 " radix ^ (1 + E_min - p)")
                   (case "radix ^ (-(1 + E_min - p)) * r * radix ^ (1 + E_min - p)=r")
                   (("1" (assert))
                    ("2"
                     (hide-all-but (1 -5))
                     (div-by 1 "r")
                     (case "(radix ^ (-(1 + E_min - p)) * r * radix ^ (1 + E_min - p) / r)=
                                                                                                                                  (radix ^ (-(1 + E_min - p))*radix ^ (1 + E_min - p))")
                     (("1" (replace -1) (rewrite "expt_plus" :dir rl))
                      ("2" (assert))))))))
                ("2" (hide-all-but 1) (skosimp*) (assert))))
              ("2" (field 1))))
            ("2" (assert))))
          ("2"
           (flip-ineq 2)
           (hide 1)
           (name "a" "floor(ln(r * radix / radix ^ p) / ln(radix))")
           (copy -2)
           (replace -2)
           (hide -3)
           (expand "fp_round")
           (hide -3)
           (expand "over_under?")
           (expand "abs")
           (expand "round_scaled")
           (expand "abs")
           (expand "FtoR")
           (case-replace "scale(r)=a")
           (("1"
             (div-by 2 "radix ^ a")
             (case-replace
              "(radix ^ a + floor(r * radix ^ (-a)) * radix ^ a) / radix ^ a
                                                                   = floor(r * radix ^ (-a)) +1")
             (("1"
               (expand "round")
               (mult-by 1 "radix ^ (-a)")
               (case-replace
                "(floor(r * radix ^ (-a)) * radix ^ a * radix ^ (-a))
                                                                             = (floor(r * radix ^ (-a)))")
               (("1" (assert))
                ("2"
                 (hide-all-but 1)
                 (div-by 1 "(floor(r * radix ^ (-a)))")
                 (case-replace
                  "((floor(r * radix ^ (-a)) * radix ^ a * radix ^ (-a)) /
                                                                                              (floor(r * radix ^ (-a)))=radix ^ a * radix ^ (-a))")
                 (("1" (rewrite "expt_plus" :dir rl)) ("2" (field 1))))))
              ("2" (field 1))))
            ("2"
             (hide 2 3)
             (expand "scale")
             (move-terms 1 l (1 3))
             (lemma "Exp_of_unique")
             (inst?)
             (inst -1 "r")
             (case "0 < ln(radix)")
             (("1"
               (split)
               (("1" (propax)) ("2" (assert)) ("3" (assert))
                ("4"
                 (rewrite "hathat_int" :dir rl)
                 (expand "^^")
                 (trans-ineq 1
                  "exp(ln(radix) *((ln(r * radix / radix ^ p) / ln(radix)))  + ln(radix) * p - ln(radix))")
                 (("1"
                   (lemma "exp_increasing")
                   (expand "increasing?")
                   (inst?)
                   (split)
                   (("1" (propax))
                    ("2"
                     (hide 2 3)
                     (move-terms 1 l (2 3))
                     (assert)
                     (div-by 1 "ln(radix)")
                     (assert))))
                  ("2"
                   (rewrite "ln_div")
                   (rewrite "ln_expt")
                   (rewrite "ln_mult")
                   (assert)
                   (rewrite "exp_ln")
                   (assert))))
                ("5"
                 (rewrite "hathat_int" :dir rl)
                 (expand "^^")
                 (trans-ineq 1
                  "exp(ln(radix) * (ln(r * radix / radix ^ p) / ln(radix)-1) + ln(radix) * p)"
                  :strict 2)
                 (("1"
                   (rewrite "ln_div")
                   (rewrite "ln_expt")
                   (rewrite "ln_mult")
                   (case-replace
                    "(ln(radix) *
                                                                                                            ((ln(r) + ln(radix) - p * ln(radix)) / ln(radix) - 1)
                                                                                                            + ln(radix) * p)=ln(r)")
                   (("1" (rewrite "exp_ln") (assert)) ("2" (field 1))))
                  ("2"
                   (lemma "exp_strict_increasing")
                   (expand "strict_increasing?")
                   (inst?)
                   (split)
                   (("1" (propax))
                    ("2"
                     (hide 2 3)
                     (move-terms 1 l 2)
                     (assert)
                     (div-by 1 "ln(radix)")
                     (trans-ineq 1
                      "ln(r * radix / radix ^ p) / ln(radix)-1" :strict
                      2)
                     (("1" (field 1)) ("2" (assert))))))))))
              ("2"
               (lemma "ln_strict_increasing")
               (expand "strict_increasing?")
               (inst -1 "1" "radix")
               (rewrite "ln_1")
               (assert))))))))
        ("2" (lemma "E_max_gt_E_min") (assert))))
      ("2"
       (rewrite "FsuccDiff" :dir rl)
       (("1" (assert))
        ("2"
         (lemma "RleRoundedR0")
         (inst -1 "isMin?" "b" "RND_Min(b)(r)" "r")
         (split)
         (("1" (expand "RND_Min") (propax)) ("2" (assert))
          ("3" (rewrite "RND_Min_isMin"))
          ("4" (rewrite "isMin_RoundedMode"))
          ("5" (rewrite "FcanonicBounded"))))))
      ("3" (rewrite "FcanonicBounded"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "round_scaled")
   (case-replace "abs(-r)=abs(r)")
   (("1" (expand "round") (grind-reals))
    ("2" (hide 2) (expand "abs") (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "FORALL (g:real): abs(-g)=abs(g)")
   (("1"
     (expand "fp_round")
     (expand "over_under?")
     (rewrite -1)
     (grind-reals)
     (("1"
       (expand "round_exceptions")
       (expand "round_exceptions_x")
       (expand "overflow")
       (case "max_pos=-max_neg")
       (("1"
         (grind-reals)
         (("1"
           (expand "trap_over")
           (grind-reals)
           (rewrite "fp_round_opp_aux")
           (assert))
          ("2"
           (expand "trap_over")
           (grind-reals)
           (rewrite "fp_round_opp_aux")
           (assert))))
        ("2"
         (hide 2 3)
         (expand* "max_pos" "max_neg" "max_fp_pos" "max_fp_neg" "value"
          "pos" "neg")
         (rewrite "expt_x0")
         (rewrite "expt_x1")
         (assert))))
      ("2"
       (expand "round_exceptions")
       (expand "round_exceptions_x")
       (grind-reals)
       (("1"
         (expand "overflow")
         (case "max_pos=-max_neg")
         (("1"
           (grind-reals)
           (("1"
             (expand "trap_over")
             (grind-reals)
             (rewrite "fp_round_opp_aux")
             (assert))
            ("2"
             (expand "trap_over")
             (grind-reals)
             (rewrite "fp_round_opp_aux")
             (assert))))
          ("2"
           (hide 2 3)
           (expand* "max_pos" "max_neg" "max_fp_pos" "max_fp_neg" "value"
            "pos" "neg")
           (rewrite "expt_x1")
           (rewrite "expt_x0")
           (assert))))
        ("2"
         (expand "underflow")
         (case "tiny?(r, to_neg)=tiny?(-r, to_pos)")
         (("1"
           (case "round_under(r, to_neg)=-round_under(-r, to_pos)")
           (("1" (grind-reals) (rewrite "fp_round_opp_aux") (assert))
            ("2"
             (rewrite "fp_round_opp_aux")
             (hide 4)
             (expand "round_under")
             (expand "round")
             (grind-reals))))
          ("2"
           (hide 4)
           (expand "tiny?")
           (rewrite "fp_round_opp_aux")
           (case "abs(-round_scaled(-r, to_pos)) =abs(round_scaled(-r, to_pos))")
           (("1" (assert) (grind-reals))
            ("2"
             (hide 2)
             (name-replace "AA" "round_scaled(-r, to_pos)")
             (expand "abs" 1)
             (grind-reals))))))))
      ("3" (rewrite "fp_round_opp_aux"))))
    ("2" (hide 2) (skosimp*) (expand "abs") (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: RWB
script:
  (""
   (skeep)
   (lemma "RND_Min_isMin")
   (inst?)
   (expand "isMin?")
   (lemma "RND_Max_isMax")
   (inst?)
   (expand "isMax?")
   (flatten)
   (expand "RND_EClosest")
   (case-replace
    " abs(FtoR(RND_Min(b)(r)) - r)=r - FtoR[radix](RND_Min(b)(r))")
   (("1"
     (case-replace
      "abs(FtoR(RND_Max(b)(r)) - r)=FtoR[radix](RND_Max(b)(r)) - r")
     (("1"
       (hide-all-but 1)
       (grind-reals)
       (("1"
         (lemma "MaxSuccMin")
         (inst -1 "b" "RND_Min(b)(r)" "RND_Max(b)(r)" "r")
         (split)
         (("1"
           (case "r=(FtoR(RND_Max(b)(r))+FtoR(RND_Min(b)(r)))/2")
           (("1"
             (hide 1 2)
             (hide 1)
             (expand "RND_Min")
             (grind-reals :theories ("extra_tegies" "extra_real_props"))
             (("1"
               (hide -2)
               (expand "abs")
               (case-replace
                "(r * radix ^ (-Fexp(RND_aux(b)(r))))=(Fnum(RND_aux(b)(r)))+1/2")
               (("1"
                 (expand "even?")
                 (skosimp*)
                 (replace -4)
                 (case-replace "ceiling(2 * j!1 + 1 / 2)=2 * j!1 + 1")
                 (("1"
                   (case-replace "floor((2 * j!1 + 1) / 2)=j!1")
                   (("1" (expand "FtoR") (assert))
                    ("2" (hide-all-but 1) (assert))))
                  ("2"
                   (case-replace "1 / 2 + 2 * j!1=-1/2+(2*j!1+1)")
                   (("1"
                     (rewrite "ceiling_plus_int")
                     (case-replace "ceiling(-(1 / 2))=0")
                     (("1" (assert)) ("2" (assert))))
                    ("2" (assert))))))
                ("2"
                 (hide 2)
                 (rewrite "expt_inverse")
                 (field 1)
                 (copy -2)
                 (replace -2)
                 (hide -3)
                 (case-replace
                  "FtoR(Fsucc(b)(RND_aux(b)(r)))=FtoR(RND_aux(b)(r))+radix ^ Fexp(RND_aux(b)(r))")
                 (("1" (expand "FtoR") (propax))
                  ("2"
                   (hide 2)
                   (move-terms 1 r 1)
                   (rewrite "FsuccDiff")
                   (("1" (rewrite "FulpCanonic"))
                    ("2"
                     (lemma "RleRoundedR0")
                     (inst -1 "isMin?" "b" "RND_Min(b)(r)" "r")
                     (split)
                     (("1" (expand "RND_Min") (propax)) ("2" (propax))
                      ("3" (rewrite "RND_Min_isMin"))
                      ("4" (rewrite "isMin_RoundedMode"))
                      ("5" (rewrite "FcanonicBounded"))))))))))
              ("2"
               (flip-ineq 1)
               (name "AA" "Fpred(b)(Fopp(RND_aux(b)(-r)))")
               (copy -2)
               (replace -2)
               (hide -3)
               (expand "abs")
               (case "RND_aux(b)(-r)=Fopp(Fsucc(b)(AA))")
               (("1"
                 (replaces -1 2)
                 (expand "Fopp" 2)
                 (case-replace
                  "r * radix ^ (-Fexp(Fsucc(b)(AA)))=Fnum(Fsucc(b)(AA))-1/2")
                 (("1"
                   (case-replace
                    "ceiling(Fnum(Fsucc(b)(AA)) - 1 / 2)=Fnum(Fsucc(b)(AA))")
                   (("1"
                     (case-replace
                      "floor(Fnum(Fsucc(b)(AA)) / 2)=(Fnum(Fsucc(b)(AA))-1)/2")
                     (("1"
                       (expand "FtoR")
                       (field 2)
                       (move-terms 2 r 1)
                       (case "radix ^ Fexp(Fsucc(b)(AA))=FtoR(Fsucc(b)(AA))-FtoR(AA)")
                       (("1" (expand "FtoR" -1) (assert))
                        ("2"
                         (case-replace
                          "Fsucc(b)(AA)=Fopp(Fpred(b)(Fopp(AA)))")
                         (("1"
                           (hide 2 3)
                           (case-replace
                            "radix ^ Fexp(Fopp(Fpred(b)(Fopp(AA))))=radix ^ Fexp((Fpred(b)(Fopp(AA))))")
                           (("1"
                             (rewrite "FoppCorrect")
                             (case-replace
                              " FtoR[radix](AA)=-FtoR(Fopp(AA))")
                             (("1"
                               (case-replace
                                "-FtoR(Fpred(b)(Fopp(AA))) - -(FtoR[radix]((Fopp(AA))))
                                                                                                                                                         = FtoR(Fopp(AA))-FtoR(Fpred(b)(Fopp(AA)))")
                               (("1"
                                 (rewrite "FpredDiff")
                                 (("1"
                                   (rewrite "FulpCanonic")
                                   (case-replace
                                    "Fpred(b)(Fopp(AA))=Fopp(RND_Max(b)(r))")
                                   (("1"
                                     (lemma "FcanonicOpp")
                                     (hide-all-but (-1 1))
                                     (inst -1 "b" "RND_Max(b)(r)")
                                     (assert))
                                    ("2"
                                     (rewrite -10)
                                     (expand "Fopp" 1)
                                     (decompose-equality 1))))
                                  ("2"
                                   (rewrite "FoppCorrect")
                                   (replace -9 :dir rl)
                                   (hide-all-but (-8 1))
                                   (rewrite "FpredFoppFsucc")
                                   (rewrite "FoppCorrect")
                                   (assert)
                                   (trans-ineq
                                    1
                                    "FtoR(Fsucc(b)(RND_aux(b)(-r)))"
                                    :strict
                                    1)
                                   (("1"
                                     (rewrite "FsuccPos")
                                     (lemma "RleRoundedR0")
                                     (inst
                                      -1
                                      "isMin?"
                                      "b"
                                      "RND_Min(b)(-r)"
                                      "-r")
                                     (split)
                                     (("1" (expand "RND_Min") (propax))
                                      ("2" (assert))
                                      ("3" (rewrite "RND_Min_isMin"))
                                      ("4" (rewrite "isMin_RoundedMode"))
                                      ("5" (rewrite "FcanonicBounded"))))
                                    ("2" (assert))))
                                  ("3"
                                   (replace -9 :dir rl)
                                   (hide-all-but 1)
                                   (lemma "FcanonicOpp")
                                   (inst
                                    -1
                                    "b"
                                    "Fpred(b)(Fopp(RND_aux(b)(-r)))")
                                   (flatten)
                                   (rewrite -1)
                                   (rewrite "FpredCanonic")
                                   (lemma "FcanonicOpp")
                                   (inst -1 "b" "RND_aux(b)(-r)")
                                   (assert))))
                                ("2" (assert))))
                              ("2" (rewrite "FoppCorrect") (assert))))
                            ("2" (expand "Fopp" 1) (propax))))
                          ("2"
                           (rewrite "FpredFoppFsucc")
                           (expand "Fopp" 1)
                           (decompose-equality 1))))))
                      ("2"
                       (case "odd?(Fnum(Fsucc(b)(AA)))")
                       (("1"
                         (expand "odd?")
                         (skosimp*)
                         (hide-all-but (-1 1))
                         (replace -1)
                         (assert)
                         (case-replace "(1 + 2 * j!1) / 2=1/2+j!1")
                         (("1" (rewrite "floor_plus_int") (assert))
                          ("2" (field 1))))
                        ("2"
                         (rewrite "EvenFsuccOdd")
                         (replace -4 :dir rl)
                         (hide-all-but (-3 1))
                         (rewrite "FpredCanonic")
                         (lemma "FcanonicOpp")
                         (inst -1 "b" "RND_aux(b)(-r)")
                         (assert))))))
                    ("2" (assert))))
                  ("2"
                   (assert)
                   (rewrite "expt_inverse")
                   (field 1)
                   (hide 2 3)
                   (copy -4)
                   (replace -4)
                   (hide -5)
                   (case-replace
                    "FtoR(AA)=FtoR(Fsucc(b)(AA))-radix ^ Fexp(Fsucc(b)(AA))")
                   (("1" (expand "FtoR" 1) (propax))
                    ("2"
                     (hide 2)
                     (case-replace
                      "Fsucc(b)(AA)=Fopp(Fpred(b)(Fopp(AA)))")
                     (("1"
                       (case-replace
                        "Fexp(Fopp(Fpred(b)(Fopp(AA))))=Fexp((Fpred(b)(Fopp(AA))))")
                       (("1"
                         (rewrite "FoppCorrect")
                         (case-replace "FtoR[radix](AA)=-FtoR(Fopp(AA))")
                         (("1"
                           (case "radix ^ Fexp((Fpred(b)(Fopp(AA))))=FtoR(Fopp(AA))-FtoR(Fpred(b)(Fopp(AA)))")
                           (("1" (assert))
                            ("2"
                             (rewrite "FpredDiff")
                             (("1"
                               (rewrite "FulpCanonic")
                               (hide-all-but (-4 1))
                               (lemma "FcanonicOpp")
                               (inst -1 "b" "Fpred(b)(Fopp(AA))")
                               (assert))
                              ("2"
                               (replace -6 :dir rl)
                               (hide 2 3 -1 -2 -3)
                               (rewrite "FpredFoppFsucc")
                               (rewrite "FoppCorrect")
                               (rewrite "FoppCorrect")
                               (trans-ineq 1
                                "FtoR(Fsucc(b)(RND_aux(b)(-r)))" :strict
                                1)
                               (("1"
                                 (rewrite "FsuccPos")
                                 (lemma "RleRoundedR0")
                                 (inst
                                  -1
                                  "isMin?"
                                  "b"
                                  "RND_Min(b)(-r)"
                                  "-r")
                                 (split)
                                 (("1" (expand "RND_Min") (propax))
                                  ("2" (assert))
                                  ("3" (rewrite "RND_Min_isMin"))
                                  ("4" (rewrite "isMin_RoundedMode"))
                                  ("5" (rewrite "FcanonicBounded"))))
                                ("2" (assert))))
                              ("3"
                               (replace -6 :dir rl)
                               (hide-all-but (-5 1))
                               (rewrite "FpredFoppFsucc")
                               (case-replace
                                "Fopp(Fopp(Fsucc(b)(RND_aux(b)(-r))))=Fsucc(b)(RND_aux(b)(-r))")
                               (("1" (rewrite "FsuccCanonic"))
                                ("2"
                                 (expand "Fopp" 1)
                                 (decompose-equality 1))))))))
                          ("2" (rewrite "FoppCorrect") (assert))))
                        ("2" (expand "Fopp") (propax))))
                      ("2"
                       (rewrite "FpredFoppFsucc")
                       (expand "Fopp" 1)
                       (decompose-equality 1))))))))
                ("2"
                 (replace -2 :dir rl)
                 (rewrite "FsuccFpred")
                 (("1" (expand "Fopp" 1) (decompose-equality 1))
                  ("2"
                   (lemma "FcanonicOpp")
                   (inst -1 "b" "RND_aux(b)(-r)")
                   (assert))))))))
            ("2" (grind-reals))))
          ("2" (propax)) ("3" (rewrite "RND_Max_isMax"))
          ("4" (rewrite "RND_Min_isMin")) ("5" (assert)) ("6" (assert))))
        ("2"
         (lemma "MaxSuccMin")
         (inst -1 "b" "RND_Min(b)(r)" "RND_Max(b)(r)" "r")
         (split)
         (("1"
           (replace -1)
           (expand "RND_Min")
           (grind-reals)
           (("1"
             (expand "abs")
             (case-replace
              "r * radix ^ (-Fexp(RND_aux(b)(r)))
                                                               =Fnum(RND_aux(b)(r))+1/2")
             (("1"
               (case-replace
                "ceiling(Fnum(RND_aux(b)(r)) + 1 / 2)=Fnum(RND_aux(b)(r)) + 1")
               (("1"
                 (case-replace
                  "floor((Fnum(RND_aux(b)(r)) + 1) / 2)=
                                                                                    (Fnum(RND_aux(b)(r)) + 1)/2")
                 (("1"
                   (hide 1 2 3 4)
                   (case-replace
                    "FtoR(Fsucc(b)(RND_aux(b)(r)))=FtoR(RND_aux(b)(r))+Fulp(b)(RND_aux(b)(r))")
                   (("1"
                     (rewrite "FulpCanonic")
                     (expand "FtoR" 1)
                     (field 1))
                    ("2"
                     (rewrite "FsuccDiff" :dir rl)
                     (("1" (assert))
                      ("2"
                       (lemma "RleRoundedR0")
                       (inst -1 "isMin?" "b" "RND_Min(b)(r)" "r")
                       (split)
                       (("1" (expand "RND_Min") (propax)) ("2" (propax))
                        ("3" (rewrite "RND_Min_isMin"))
                        ("4" (rewrite "isMin_RoundedMode"))
                        ("5" (rewrite "FcanonicBounded"))))))
                    ("3" (rewrite "FcanonicBounded"))))
                  ("2"
                   (hide 2 3 4 6)
                   (case "odd?(Fnum(RND_aux(b)(r)))")
                   (("1"
                     (expand "odd?")
                     (skosimp*)
                     (replace -1)
                     (field 1))
                    ("2" (lemma "even_or_odd") (inst?) (assert))))))
                ("2" (assert))))
              ("2"
               (rewrite "expt_inverse")
               (field 1)
               (case-replace
                "(radix ^ Fexp(RND_aux(b)(r))) +
                                                                                  2 * (Fnum(RND_aux(b)(r)) * (radix ^ Fexp(RND_aux(b)(r))))=FtoR(RND_aux(b)(r))
                                                                         + FtoR(Fsucc(b)(RND_aux(b)(r)))")
               (("1" (grind-reals))
                ("2"
                 (hide 2 3 4 6 7)
                 (case-replace
                  "FtoR(Fsucc(b)(RND_aux(b)(r)))=FtoR(RND_aux(b)(r))+Fulp(b)(RND_aux(b)(r))")
                 (("1"
                   (rewrite "FulpCanonic")
                   (expand "FtoR" 1)
                   (propax))
                  ("2"
                   (rewrite "FsuccDiff" :dir rl)
                   (("1" (assert))
                    ("2"
                     (lemma "RleRoundedR0")
                     (inst -1 "isMin?" "b" "RND_Min(b)(r)" "r")
                     (split)
                     (("1" (expand "RND_Min") (propax)) ("2" (propax))
                      ("3" (rewrite "RND_Min_isMin"))
                      ("4" (rewrite "isMin_RoundedMode"))
                      ("5" (rewrite "FcanonicBounded"))))))
                  ("3" (rewrite "FcanonicBounded"))))))))
            ("2"
             (flip-ineq 4)
             (rewrite "FsuccFpred")
             (("1"
               (expand "abs")
               (case-replace
                "Fexp(RND_aux(b)(-r))=Fexp(Fopp(RND_aux(b)(-r)))")
               (("1"
                 (name-replace "AA" "Fopp(RND_aux(b)(-r))")
                 (case-replace "r * radix ^ (-Fexp(AA))=Fnum(AA)-1/2")
                 (("1"
                   (case-replace "ceiling(Fnum(AA) - 1 / 2)=Fnum(AA)")
                   (("1"
                     (case-replace "floor(Fnum(AA) / 2)=Fnum(AA) / 2")
                     (("1" (expand "FtoR" 6) (field 6))
                      ("2"
                       (case "even?(Fnum(AA))")
                       (("1"
                         (case "even?(Fnum(AA))")
                         (("1"
                           (expand "even?")
                           (skosimp*)
                           (hide-all-but (-1 1))
                           (replace -1)
                           (field 1))
                          ("2" (propax))))
                        ("2"
                         (case "AA=Fsucc(b)(Fpred(b)(AA))")
                         (("1"
                           (replaces -1 1)
                           (rewrite "OddFsuccEven")
                           (("1"
                             (lemma "even_or_odd")
                             (inst -1 "Fnum(Fpred(b)(AA))")
                             (assert))
                            ("2" (rewrite "FpredCanonic"))))
                          ("2" (rewrite "FsuccFpred"))))))))
                    ("2" (assert))))
                  ("2"
                   (rewrite "expt_inverse")
                   (field 1)
                   (case-replace
                    "2 * (Fnum(AA) * (radix ^ Fexp(AA))) - (radix ^ Fexp(AA))
                                                                                             = FtoR(AA)+FtoR(Fpred(b)(AA))")
                   (("1" (grind-reals))
                    ("2"
                     (hide 2 3 4 5 6 7 8)
                     (case-replace
                      "2 * (Fnum(AA) * (radix ^ Fexp(AA))) - (radix ^ Fexp(AA))=2*FtoR(AA)-(radix ^ Fexp(AA))")
                     (("1"
                       (move-terms 1 r (1 2))
                       (move-terms 1 l 2)
                       (assert)
                       (case-replace "FtoR[radix](AA)=-FtoR(Fopp(AA))")
                       (("1"
                         (case-replace
                          "Fpred(b)(AA)=Fopp(Fsucc(b)(Fopp(AA)))")
                         (("1"
                           (case-replace
                            "radix ^ Fexp(AA)=Fulp(b)(Fopp(AA))")
                           (("1"
                             (rewrite "FsuccDiff" :dir rl)
                             (("1"
                               (assert)
                               (rewrite "FoppCorrect")
                               (assert)
                               (rewrite "FoppCorrect")
                               (assert))
                              ("2"
                               (rewrite "FoppCorrect")
                               (case "FtoR(AA) <= 0")
                               (("1" (assert))
                                ("2"
                                 (lemma "RleRoundedLessR0")
                                 (inst
                                  -1
                                  "isMax?"
                                  "b"
                                  "RND_Max(b)(r)"
                                  "r")
                                 (split)
                                 (("1" (assert))
                                  ("2" (assert))
                                  ("3" (rewrite "RND_Max_isMax"))
                                  ("4" (rewrite "isMax_RoundedMode"))
                                  ("5" (rewrite "FcanonicBounded"))))))
                              ("3"
                               (lemma "FcanonicOpp")
                               (inst -1 "b" "AA")
                               (assert))))
                            ("2"
                             (rewrite "FulpCanonic")
                             (("1" (assert) (expand "Fopp") (propax))
                              ("2"
                               (lemma "FcanonicOpp")
                               (inst -1 "b" "AA")
                               (assert))))
                            ("3"
                             (rewrite "FoppBounded")
                             (rewrite "FcanonicBounded"))))
                          ("2"
                           (rewrite "FsuccFoppFpred")
                           (expand "Fopp" 1)
                           (decompose-equality 1))))
                        ("2" (rewrite "FoppCorrect") (assert))))
                      ("2" (expand "FtoR" 1) (propax))))))))
                ("2" (expand "Fopp" 1) (propax))))
              ("2"
               (hide 2 3 4 5 6 7)
               (lemma "FcanonicOpp")
               (inst -1 "b" "RND_aux(b)(-r)")
               (assert))))))
          ("2" (propax)) ("3" (rewrite "RND_Max_isMax"))
          ("4" (rewrite "RND_Min_isMin")) ("5" (assert))
          ("6" (assert))))))
      ("2" (hide 2) (expand "abs" 1) (grind-reals))))
    ("2" (hide 2) (expand "abs" 1) (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "0 <= r")
   (("1" (rewrite "Roundings_eq_pos") (expand "abs") (propax))
    ("2"
     (flip-ineq 1)
     (case-replace
      "FtoR[radix](RND_Min(b)(r))=-FtoR[radix](RND_Max(b)(-r))")
     (("1"
       (case-replace " fp_round(r, to_neg)= -fp_round(-r, to_pos)")
       (("1"
         (rewrite "Roundings_eq_neg")
         (expand "abs" 1)
         (case "max_pos=-max_neg")
         (("1" (assert))
          ("2"
           (expand* "max_pos" "max_neg" "max_fp_pos" "max_fp_neg" "value"
            "pos" "neg")
           (rewrite "expt_x0")
           (rewrite "expt_x1")
           (assert))
          ("3" (lemma "E_max_gt_E_min") (propax))))
        ("2" (rewrite "fp_round_opp"))
        ("3" (lemma "E_max_gt_E_min") (propax))))
      ("2"
       (hide 2 3 -2)
       (lemma "isMin_Unique")
       (expand "Unique?")
       (inst -1 "b" "r" "RND_Min(b)(r)" "Fopp(RND_Max(b)(-r))")
       (("1"
         (rewrite "FoppCorrect")
         (split)
         (("1" (propax))
          ("2"
           (case-replace "r=--r")
           (("1"
             (rewrite "MaxOppMin")
             (("1" (rewrite -1 :dir rl) (rewrite "RND_Max_isMax"))
              ("2" (rewrite "FcanonicBounded"))))
            ("2" (assert))))
          ("3" (rewrite "RND_Min_isMin"))))
        ("2" (rewrite "FoppBounded") (rewrite "FcanonicBounded"))
        ("3" (rewrite "FcanonicBounded"))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "0 < r")
   (("1" (rewrite "Roundings_eq_neg") (expand "abs") (propax))
    ("2"
     (case "fp_round(r, to_pos)= - fp_round(-r, to_neg)")
     (("1"
       (case "fp_round(-r, to_neg)=FtoR[radix](RND_Min(b)(-r))")
       (("1"
         (case "-FtoR[radix](RND_Min(b)(-r))= FtoR[radix](RND_Max(b)(r))")
         (("1" (assert))
          ("2"
           (hide-all-but 1)
           (rewrite "FoppCorrect" :dir rl)
           (lemma "isMax_Unique")
           (expand "Unique?")
           (inst -1 "b" "r" "Fopp(RND_Min(b)(-r))" "RND_Max(b)(r)")
           (("1"
             (split)
             (("1" (propax)) ("2" (rewrite "RND_Max_isMax"))
              ("3"
               (case-replace "r=--r")
               (("1"
                 (rewrite "MinOppMax")
                 (("1" (rewrite "RND_Min_isMin"))
                  ("2" (rewrite "FcanonicBounded"))))
                ("2" (assert))))))
            ("2" (rewrite "FcanonicBounded"))
            ("3" (rewrite "FoppBounded") (rewrite "FcanonicBounded"))))))
        ("2" (rewrite "Roundings_eq_pos") (expand "abs") (grind-reals))))
      ("2"
       (rewrite "fp_round_opp")
       (("1" (assert))
        ("2"
         (case-replace "r=0")
         (("1" (hide-all-but 1) (expand "fp_round") (assert))
          ("2" (assert))))))
      ("3" (lemma "E_max_gt_E_min") (propax))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "abs(r) <= max_pos")
   (("1"
     (rewrite "RND_EClosest2")
     (rewrite "Roundings_eq_1" :dir rl)
     (("1"
       (rewrite "Roundings_eq_2" :dir rl)
       (grind-reals)
       (("1"
         (expand "fp_round")
         (grind-reals)
         (("1"
           (expand "round_exceptions")
           (expand "round_exceptions_x")
           (expand "underflow")
           (grind-reals)
           (expand "round_under")
           (expand "round")
           (expand "round_to_even")
           (case "radix ^ (-(1 + E_min - p)) * r -
                                                                                                                                      floor(radix ^ (-(1 + E_min - p)) * r)
                                                                                                                                      <
                                                                                                                                      ceiling(radix ^ (-(1 + E_min - p)) * r) -
                                                                                                                                       radix ^ (-(1 + E_min - p)) * r")
           (("1" (assert))
            ("2"
             (hide 4 2)
             (mult-by 1 "(radix ^ (1 + E_min - p))")
             (assert)
             (case-replace
              "(radix ^ (1 + E_min - p)) * radix ^ (-(1 + E_min - p)) * r=r")
             (("1" (assert))
              ("2"
               (hide 2)
               (div-by 1 "r")
               (rewrite "expt_plus" :dir rl))))))
          ("2"
           (expand "round_scaled")
           (div-by 4 "radix ^ (scale(abs(r)))")
           (expand "round")
           (expand "round_to_even")
           (case "radix ^ (-scale(abs(r))) * r -
                                                                                                                                      floor(radix ^ (-scale(abs(r))) * r)
                                                                                                                                      <
                                                                                                                                      ceiling(radix ^ (-scale(abs(r))) * r) -
                                                                                                                                       radix ^ (-scale(abs(r))) * r")
           (("1" (assert))
            ("2"
             (hide 5)
             (assert)
             (mult-by 1 "(radix ^(scale(abs(r))))")
             (assert)
             (case-replace
              "radix ^ (scale(abs(r))) * radix ^ (-scale(abs(r))) * r=r")
             (("1" (assert))
              ("2" (hide 2) (rewrite "expt_plus" :dir rl) (assert))))))))
        ("2"
         (flip-ineq 2)
         (hide -1)
         (expand "fp_round")
         (grind-reals)
         (("1"
           (expand "round_exceptions")
           (expand "round_exceptions_x")
           (expand "underflow")
           (grind-reals)
           (expand "round_under")
           (div-by 3 "(radix ^ (1 + E_min - p))")
           (expand "round")
           (expand "round_to_even")
           (case "ceiling(radix ^ (-(1 + E_min - p)) * r) -
                                                                                                                                         radix ^ (-(1 + E_min - p)) * r
                                                                                                                                         <
                                                                                                                                         radix ^ (-(1 + E_min - p)) * r -
                                                                                                                                          floor(radix ^ (-(1 + E_min - p)) * r)")
           (("1" (assert))
            ("2"
             (hide 4)
             (mult-by 1 "(radix ^ (1 + E_min - p))")
             (assert)
             (case-replace
              "(radix ^ (1 + E_min - p)) * radix ^ (-(1 + E_min - p)) * r=r")
             (("1" (assert))
              ("2" (hide 2) (rewrite "expt_plus" :dir rl) (assert))))))
          ("2"
           (expand "round_scaled")
           (div-by 4 "radix ^ (scale(abs(r)))")
           (expand "round")
           (expand "round_to_even")
           (case "ceiling(radix ^ (-scale(abs(r))) * r) -
                                                                                                                                         radix ^ (-scale(abs(r))) * r
                                                                                                                                         <
                                                                                                                                         radix ^ (-scale(abs(r))) * r -
                                                                                                                                          floor(radix ^ (-scale(abs(r))) * r)")
           (("1" (assert))
            ("2"
             (hide 5)
             (mult-by 1 " radix ^ (scale(abs(r)))")
             (assert)
             (case-replace
              " radix ^ (scale(abs(r))) * radix ^ (-scale(abs(r))) * r=r")
             (("1" (assert))
              ("2" (hide 2) (rewrite "expt_plus" :dir rl) (assert))))))))
        ("3"
         (flip-ineq 2)
         (flip-ineq 2)
         (expand "fp_round")
         (grind-reals)
         (("1"
           (expand "round_exceptions")
           (expand "round_exceptions_x")
           (expand "underflow")
           (grind-reals)
           (expand "round_under")
           (expand "over_under?")
           (expand "round")
           (div-by 3 "(radix ^ (1 + E_min - p))")
           (mult-by -2 "radix ^ (-(1 + E_min - p))")
           (assert)
           (mult-by -3 "radix ^ (-(1 + E_min - p))")
           (assert)
           (case-replace
            " floor(radix ^ (-(1 + E_min - p)) * r) * (radix ^ (1 + E_min - p)) *
                                                                              radix ^ (-(1 + E_min - p))=floor(radix ^ (-(1 + E_min - p)) * r)")
           (("1"
             (hide -1)
             (case-replace
              "ceiling(radix ^ (-(1 + E_min - p)) * r) * (radix ^ (1 + E_min - p))
                                                                                          * radix ^ (-(1 + E_min - p))=ceiling(radix ^ (-(1 + E_min - p)) * r)")
             (("1"
               (hide -1)
               (expand "round_to_even")
               (assert)
               (hide -1 -2 2 3)
               (expand "FtoR")
               (case-replace "Fexp(RND_aux(b)(abs(r)))=1 + E_min - p")
               (("1" (assert))
                ("2"
                 (hide 3)
                 (rewrite "RND_aux_alt_def")
                 (expand "RND_aux_alt")
                 (expand "b")
                 (expand "vNum")
                 (rewrite "expt_plus" :dir rl)
                 (case-replace
                  " radix ^ ((-(-E_min - 1 + p) - 1) + p)=radix ^ E_min")
                 (("1" (assert)) ("2" (assert))))))
              ("2"
               (hide-all-but 1)
               (div-by 1 "ceiling(radix ^ (-(1 + E_min - p)) * r)")
               (case-replace
                "(ceiling(radix ^ (-(1 + E_min - p)) * r) * (radix ^ (1 + E_min - p))
                                                                                      * radix ^ (-(1 + E_min - p))
                                                                                      / ceiling(radix ^ (-(1 + E_min - p)) * r))=(radix ^ (1 + E_min - p))*radix ^ (-(1 + E_min - p))")
               (("1" (rewrite "expt_plus" :dir rl)) ("2" (assert))))))
            ("2"
             (field 1)
             (hide-all-but 1)
             (div-by 1 "floor(radix ^ (-(1 + E_min - p)) * r)")
             (case-replace
              "(floor(radix ^ (-(1 + E_min - p)) * r) * (radix ^ (1 + E_min - p))
                                                                            * radix ^ (-(1 + E_min - p))
                                                                            / floor(radix ^ (-(1 + E_min - p)) * r))=(radix ^ (1 + E_min - p))*radix ^ (-(1 + E_min - p))")
             (("1" (rewrite "expt_plus" :dir rl)) ("2" (assert))))))
          ("2"
           (expand "round_scaled")
           (div-by 4 "radix ^ (scale(abs(r)))")
           (mult-by -1 " radix ^ (-scale(abs(r)))")
           (mult-by -2 " radix ^ (-scale(abs(r)))")
           (assert)
           (case-replace
            " round(radix ^ (-scale(abs(r))) * r, to_neg) *
                                                                  radix ^ (scale(abs(r)))
                                                                  * radix ^ (-scale(abs(r)))=round(radix ^ (-scale(abs(r))) * r, to_neg)")
           (("1"
             (case-replace
              " round(radix ^ (-scale(abs(r))) * r, to_pos) *
                                                                            radix ^ (scale(abs(r)))
                                                                            * radix ^ (-scale(abs(r)))=round(radix ^ (-scale(abs(r))) * r, to_pos)")
             (("1"
               (hide -1 -2)
               (expand "round")
               (expand "round_to_even")
               (assert)
               (hide -1 -2 3 4)
               (expand "FtoR")
               (div-by 3 "2")
               (case-replace "Fexp(RND_aux(b)(abs(r)))=scale(abs(r))")
               (("1" (assert))
                ("2"
                 (hide 4)
                 (expand "scale")
                 (move-terms 1 r (1 3))
                 (rewrite "RND_aux_alt_def")
                 (expand "RND_aux_alt")
                 (grind-reals)
                 (("1"
                   (expand* "b" "vNum")
                   (rewrite "expt_plus" :dir rl)
                   (expand "over_under?")
                   (assert))
                  ("2"
                   (hide 1 4)
                   (lemma "Exp_of_unique")
                   (inst?)
                   (inst -1 "abs(r)")
                   (split)
                   (("1" (propax))
                    ("2"
                     (hide 2)
                     (rewrite "hathat_int" :dir rl)
                     (expand "^^")
                     (trans-ineq 1
                      "exp((ln(abs(r) * radix / vNum(b)) / ln(radix)) * ln(radix) +
                                                                                               ln(radix) * p
                                                                                               - ln(radix))")
                     (("1"
                       (lemma "exp_increasing")
                       (expand "increasing?")
                       (inst?)
                       (split)
                       (("1" (propax))
                        ("2"
                         (hide 2)
                         (assert)
                         (div-by 1 "ln(radix)")
                         (("1" (assert))
                          ("2"
                           (case "0<ln(radix)")
                           (("1" (split) (("1" (assert)) ("2" (assert))))
                            ("2"
                             (lemma "ln_strict_increasing")
                             (expand "strict_increasing?")
                             (inst -1 "1" "radix")
                             (rewrite "ln_1")
                             (assert))))))))
                      ("2"
                       (rewrite "ln_div")
                       (rewrite "ln_mult")
                       (expand* "b" "vNum")
                       (rewrite "ln_expt")
                       (case-replace
                        "ln(abs(r)) + ln(radix) * p - p * ln(radix)=ln(abs(r))")
                       (("1" (rewrite "exp_ln") (assert))
                        ("2" (assert))))))
                    ("3"
                     (rewrite "hathat_int" :dir rl)
                     (expand "^^")
                     (trans-ineq 1
                      " exp((ln(abs(r) * radix / vNum(b)) / ln(radix)-1) * ln(radix) +
                                                                                                ln(radix) * p) "
                      :strict 2)
                     (("1"
                       (rewrite "ln_div")
                       (expand* "b" "vNum")
                       (rewrite "ln_mult")
                       (rewrite "ln_expt")
                       (case-replace
                        "(ln(radix) *
                                                                                                        ((ln(abs(r)) + ln(radix) - p * ln(radix)) / ln(radix))
                                                                                                        + ln(radix) * p
                                                                                                        - ln(radix))=ln(abs(r))")
                       (("1" (rewrite "exp_ln") (assert))
                        ("2" (field 1))))
                      ("2"
                       (lemma "exp_strict_increasing")
                       (expand "strict_increasing?")
                       (inst?)
                       (split)
                       (("1" (propax))
                        ("2"
                         (hide 2)
                         (move-terms 1 r 2)
                         (assert)
                         (div-by 1 "ln(radix)")
                         (("1"
                           (trans-ineq 1
                            "(ln(abs(r) * radix / vNum(b)) / ln(radix))-1"
                            :strict 2)
                           (("1" (field 1)) ("2" (assert))))
                          ("2"
                           (case "0<ln(radix)")
                           (("1" (split) (("1" (assert)) ("2" (assert))))
                            ("2"
                             (lemma "ln_strict_increasing")
                             (expand "strict_increasing?")
                             (inst -1 "1" "radix")
                             (rewrite "ln_1")
                             (assert))))))))))
                    ("4" (assert)) ("5" (assert))))))))
              ("2"
               (hide-all-but 1)
               (div-by 1 " round(radix ^ (-scale(abs(r))) * r, to_pos)")
               (case-replace
                "1=radix ^ (scale(abs(r)))
                                                                                      * radix ^ (-scale(abs(r)))")
               (("1" (field 1)) ("2" (rewrite "expt_plus" :dir rl))))))
            ("2"
             (hide-all-but 1)
             (div-by 1 " round(radix ^ (-scale(abs(r))) * r, to_neg)")
             (case-replace
              "1=radix ^ (scale(abs(r)))
                                                                            * radix ^ (-scale(abs(r)))")
             (("1" (field 1)) ("2" (rewrite "expt_plus" :dir rl))))))))
        ("4"
         (hide 1 3)
         (expand "fp_round")
         (grind-reals)
         (("1"
           (expand "round_exceptions")
           (expand "round_exceptions_x")
           (expand "underflow")
           (grind-reals)
           (expand "round_under")
           (div-by 2 "(radix ^ (1 + E_min - p))")
           (div-by -4 "(radix ^ (1 + E_min - p))")
           (expand "round")
           (expand "round_to_even")
           (assert))
          ("2"
           (expand "round_scaled")
           (div-by 3 "radix ^ (scale(abs(r)))")
           (div-by -3 "radix ^ (scale(abs(r)))")
           (expand "round")
           (expand "round_to_even")
           (assert))))))
      ("2"
       (hide 3)
       (rewrite "max_fp_correct")
       (expand "abs" -1)
       (grind-reals)
       (trans-ineq 1 "-max_pos")
       (("1"
         (expand* "max_pos" "max_neg" "max_fp_pos" "max_fp_neg" "value"
          "pos" "neg")
         (rewrite "expt_x0")
         (rewrite "expt_x1")
         (assert))
        ("2" (grind-reals))))))
    ("2"
     (case-replace " FtoR[radix](RND_EClosest(b)(r))=sgn(r)*max_pos")
     (("1"
       (expand "fp_round")
       (grind-reals)
       (("1" (expand "abs" 1) (assert))
        ("2"
         (expand "round_exceptions")
         (expand "round_exceptions_x")
         (expand "overflow")
         (propax))
        ("3" (expand "over_under?") (propax))))
      ("2"
       (flip-ineq 2)
       (hide 3 2)
       (rewrite " max_fp_correct")
       (case "Fcanonic?(b)( (#Fnum:=radix^p-1, Fexp:= 1 + E_max - p #) )")
       (("1"
         (case "FtoR((# Fnum := radix ^ p - 1, Fexp := 1 + E_max - p #))=radix ^ (1 + E_max) - radix ^ (1 + E_max - p)")
         (("1"
           (case "FtoR(Fsucc(b)((# Fnum := radix ^ p - 1, Fexp := 1 + E_max - p #)))= radix ^ (1 + E_max)")
           (("1"
             (name-replace "S"
              "(# Fnum := radix ^ p - 1, Fexp := 1 + E_max - p #)")
             (expand* "abs" "sgn")
             (grind-reals)
             (("1"
               (expand "RND_EClosest")
               (case-replace "RND_Max(b)(r)=Fopp(S)")
               (("1"
                 (case-replace "RND_Min(b)(r)=Fopp(Fsucc(b)(S))")
                 (("1"
                   (rewrite "FoppCorrect")
                   (expand "abs")
                   (grind-reals)
                   (("1" (rewrite "FoppCorrect") (grind-reals))
                    ("2" (rewrite "FoppCorrect") (grind-reals))
                    ("3" (rewrite "FoppCorrect") (grind-reals))
                    ("4" (rewrite "FoppCorrect") (grind-reals))))
                  ("2"
                   (hide 3)
                   (lemma "FcanonicUnique")
                   (inst -1 "b" "RND_Min(b)(r)" "Fopp(Fsucc(b)(S))")
                   (split)
                   (("1" (propax))
                    ("2"
                     (lemma "isMin_Unique")
                     (expand "Unique?")
                     (inst -1 "b" "r" "RND_Min(b)(r)"
                      "Fopp(Fsucc(b)(S))")
                     (("1"
                       (split)
                       (("1" (propax))
                        ("2"
                         (expand "isMin?")
                         (split)
                         (("1" (rewrite "FoppCorrect") (grind-reals))
                          ("2"
                           (skosimp*)
                           (rewrite "FpredFoppFsucc" :dir rl)
                           (case-replace
                            " FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
                           (("1"
                             (rewrite "FpredProp")
                             (rewrite "FoppCorrect")
                             (grind-reals))
                            ("2" (assert))))))
                        ("3" (rewrite "RND_Min_isMin"))))
                      ("2"
                       (rewrite "FoppBounded")
                       (rewrite "FcanonicBounded")
                       (rewrite "FsuccCanonic"))
                      ("3" (rewrite "FcanonicBounded"))))
                    ("3"
                     (lemma "FcanonicOpp")
                     (inst -1 "b" "Fsucc(b)(S)")
                     (flatten)
                     (rewrite -1)
                     (rewrite "FsuccCanonic"))
                    ("4" (expand "S") (assert))))))
                ("2"
                 (hide 3)
                 (lemma "FcanonicUnique")
                 (inst -1 "b" "RND_Max(b)(r)" "Fopp(S)")
                 (split)
                 (("1" (propax))
                  ("2"
                   (lemma "isMax_Unique")
                   (expand "Unique?")
                   (inst -1 "b" "r" "RND_Max(b)(r)" "Fopp(S)")
                   (("1"
                     (split)
                     (("1" (propax))
                      ("2"
                       (expand "isMax?")
                       (split)
                       (("1" (rewrite "FoppCorrect") (grind-reals))
                        ("2"
                         (skosimp*)
                         (case-replace
                          "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
                         (("1"
                           (trans-ineq 1
                            "FtoR(Fsucc(b)(Fopp(Fsucc(b)(S))))")
                           (("1"
                             (rewrite "FsuccFoppFpred")
                             (rewrite "FpredFsucc")
                             (assert))
                            ("2"
                             (rewrite "FsuccProp")
                             (("1" (rewrite "FoppCorrect") (grind-reals))
                              ("2"
                               (lemma "FcanonicOpp")
                               (inst -1 "b" "Fsucc(b)(S)")
                               (flatten)
                               (rewrite -1)
                               (rewrite "FsuccCanonic"))))))
                          ("2" (assert))))))
                      ("3" (rewrite "RND_Max_isMax"))))
                    ("2"
                     (rewrite "FoppBounded")
                     (rewrite "FcanonicBounded"))
                    ("3" (expand "S") (rewrite "FcanonicBounded"))))
                  ("3" (lemma "FcanonicOpp") (inst -1 "b" "S") (assert))
                  ("4" (assert))))))
              ("2"
               (hide 1)
               (expand "RND_EClosest")
               (case-replace "FtoR(RND_Min(b)(r))=FtoR(S)")
               (("1"
                 (case-replace "FtoR(RND_Max(b)(r))=FtoR(Fsucc(b)(S))")
                 (("1"
                   (grind-reals)
                   (("1" (expand "abs") (grind-reals))
                    ("2" (expand "abs") (grind-reals))))
                  ("2"
                   (hide 2)
                   (lemma "isMax_Unique")
                   (expand "Unique?")
                   (inst -1 "b" "r" "RND_Max(b)(r)" "Fsucc(b)(S)")
                   (("1"
                     (split)
                     (("1" (propax))
                      ("2"
                       (expand "isMax?")
                       (skosimp*)
                       (case-replace
                        "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
                       (("1" (rewrite "FsuccProp")) ("2" (assert))))
                      ("3" (rewrite "RND_Max_isMax"))))
                    ("2"
                     (rewrite "FcanonicBounded")
                     (rewrite "FsuccCanonic"))
                    ("3" (expand "S") (rewrite "FcanonicBounded"))))))
                ("2"
                 (hide 2)
                 (lemma "isMin_Unique")
                 (expand "Unique?")
                 (inst -1 "b" "r" "RND_Min(b)(r)" "S")
                 (("1"
                   (split)
                   (("1" (propax))
                    ("2"
                     (expand "isMin?")
                     (skosimp*)
                     (assert)
                     (trans-ineq 1 "FtoR(Fnormalize(b)(f!1))")
                     (("1" (assert))
                      ("2"
                       (assert)
                       (trans-ineq 1 "FtoR(Fpred(b)(Fsucc(b)(S)))")
                       (("1"
                         (rewrite "FpredProp")
                         (rewrite "FsuccCanonic"))
                        ("2" (rewrite "FpredFsucc") (assert))))))
                    ("3" (rewrite "RND_Min_isMin"))))
                  ("2" (expand "S") (rewrite "FcanonicBounded"))
                  ("3" (rewrite "FcanonicBounded"))))))))
            ("2"
             (hide 2)
             (expand "Fsucc")
             (expand "vNum")
             (expand "b" 1)
             (expand "FtoR")
             (field 1)
             (rewrite "expt_plus" :dir rl)
             (lemma "expt_plus")
             (inst -1 "1+E_max" "1" "radix")
             (rewrite "expt_x1")
             (assert))))
          ("2" (hide 2) (expand "FtoR") (rewrite "expt_plus" :dir rl))))
        ("2"
         (expand* "Fcanonic?" "Fnormal?" "Fbounded?" "vNum" "b")
         (flatten)
         (split)
         (("1"
           (expand "abs")
           (grind-reals)
           (("1"
             (flip-ineq -1)
             (case "radix^0 <= radix^p")
             (("1" (rewrite "expt_x0") (assert))
              ("2" (rewrite "Exp_increq_1"))))
            ("2"
             (case "radix^0 <= radix^p")
             (("1" (rewrite "expt_x0") (assert))
              ("2" (rewrite "Exp_increq_1"))))))
          ("2" (lemma "E_max_gt_E_min") (assert))
          ("3"
           (hide-all-but 1)
           (case "1 <= radix^p")
           (("1"
             (expand "abs")
             (grind-reals)
             (("1" (div-by -2 "radix") (grind-reals))
              ("2"
               (move-terms 2 r 2)
               (trans-ineq 2 "radix ^ p+radix ^ p")
               (("1"
                 (move-terms 1 r 1)
                 (assert)
                 (trans-ineq 1 "radix^1")
                 (("1" (rewrite "expt_x1") (assert))
                  ("2" (rewrite "Exp_increq_1"))))
                ("2" (grind-reals) (div-by 1 "radix ^ p") (assert))))))
            ("2"
             (trans-ineq 1 "radix^0")
             (("1" (rewrite "expt_x0") (assert))
              ("2" (rewrite "Exp_increq_1"))))))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (grind-reals)
   (("1"
     (rewrite "Roundings_eq_1" :dir rl)
     (expand "fp_round")
     (grind-reals)
     (("1"
       (expand "round_exceptions")
       (expand "round_exceptions_x")
       (grind-reals)
       (("1" (expand "overflow") (grind-reals) (expand "sgn") (assert))
        ("2"
         (expand "underflow")
         (grind-reals)
         (expand "round_under")
         (expand "round")
         (expand "sgn")
         (grind-reals)
         (expand "abs" 4)
         (assert))))
      ("2"
       (expand "round_scaled")
       (expand "round")
       (expand "sgn")
       (grind-reals)
       (expand "abs")
       (grind-reals))))
    ("2"
     (rewrite "Roundings_eq_2" :dir rl)
     (expand "fp_round")
     (grind-reals)
     (("1"
       (expand "round_exceptions")
       (expand "round_exceptions_x")
       (grind-reals)
       (("1"
         (expand "overflow")
         (expand "abs" -1)
         (grind-reals)
         (expand* "sgn" "max_pos" "max_neg")
         (expand* "max_fp_pos" "max_fp_neg" "value" "pos" "neg")
         (rewrite "expt_x0")
         (rewrite "expt_x1")
         (assert))
        ("2"
         (expand "underflow")
         (grind-reals)
         (expand "round_under")
         (expand "round")
         (expand* "sgn" "abs")
         (grind-reals))))
      ("2"
       (expand "round_scaled")
       (expand "round")
       (expand* "sgn" "abs")
       (grind-reals)
       (hide 1 2 3)
       (rewrite "floor_ceiling_reflect1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "mode=to_nearest OR mode=to_zero OR mode=to_pos OR mode=to_neg")
   (("1"
     (split)
     (("1"
       (copy -2)
       (rewrite -2)
       (rewrite "Roundings_eq_3")
       (("1"
         (rewrite "Roundings_eq_3")
         (("1"
           (lemma "RoundedModeNonDecreasing")
           (inst -1 "EvenClosest?" "b" "RND_EClosest(b)(z1)"
            "RND_EClosest(b)(z2)" "z1" "z2")
           (split)
           (("1" (propax)) ("2" (propax))
            ("3" (rewrite "RND_EClosest_isEclosest"))
            ("4" (rewrite "RND_EClosest_isEclosest"))
            ("5" (rewrite "EvenClosest_Unique"))
            ("6" (rewrite "EvenClosest_RoundedMode"))
            ("7" (rewrite "FcanonicBounded"))
            ("8" (rewrite "FcanonicBounded"))))
          ("2" (rewrite "max_fp_correct") (grind-reals))))
        ("2" (rewrite "max_fp_correct") (grind-reals))))
      ("2"
       (copy -2)
       (rewrite -2)
       (rewrite "Roundings_eq_4")
       (("1"
         (rewrite "Roundings_eq_4")
         (("1"
           (lemma "RoundedModeNonDecreasing")
           (inst -1 "ToZero?" "b"
            "IF 0 <= z1 THEN RND_Min(b)(z1)
                  ELSE RND_Max(b)(z1)
                  ENDIF"
            " IF 0 <= z2 THEN RND_Min(b)(z2)
                   ELSE RND_Max(b)(z2)
                   ENDIF"
            "z1" "z2")
           (split)
           (("1" (assert)) ("2" (propax))
            ("3"
             (expand "ToZero?")
             (hide 3)
             (grind-reals)
             (("1" (rewrite "RND_Min_isMin"))
              ("2" (rewrite "RND_Max_isMax"))))
            ("4"
             (expand "ToZero?")
             (hide 3)
             (grind-reals)
             (("1" (rewrite "RND_Min_isMin"))
              ("2" (rewrite "RND_Max_isMax"))))
            ("5" (rewrite "ToZero_Unique"))
            ("6" (rewrite "ToZero_RoundedMode"))
            ("7" (hide 3) (rewrite "FcanonicBounded"))
            ("8" (rewrite "FcanonicBounded"))))
          ("2" (rewrite "max_fp_correct") (grind-reals))))
        ("2" (rewrite "max_fp_correct") (grind-reals))))
      ("3"
       (copy -2)
       (rewrite -2)
       (rewrite "Roundings_eq_2")
       (("1"
         (rewrite "Roundings_eq_2")
         (("1"
           (lemma "RoundedModeNonDecreasing")
           (inst -1 "isMax?" "b" "RND_Max(b)(z1)" "RND_Max(b)(z2)" "z1"
            "z2")
           (split)
           (("1" (propax)) ("2" (propax)) ("3" (rewrite "RND_Max_isMax"))
            ("4" (rewrite "RND_Max_isMax"))
            ("5" (rewrite "isMax_Unique"))
            ("6" (rewrite "isMax_RoundedMode"))
            ("7" (rewrite "FcanonicBounded"))
            ("8" (rewrite "FcanonicBounded"))))
          ("2" (rewrite "max_fp_correct") (expand "abs") (grind-reals))))
        ("2" (rewrite "max_fp_correct") (expand "abs") (grind-reals))))
      ("4"
       (copy -2)
       (rewrite -2)
       (rewrite "Roundings_eq_1")
       (("1"
         (rewrite "Roundings_eq_1")
         (("1"
           (lemma "RoundedModeNonDecreasing")
           (inst -1 "isMin?" "b" "RND_Min(b)(z1)" "RND_Min(b)(z2)" "z1"
            "z2")
           (split)
           (("1" (propax)) ("2" (propax)) ("3" (rewrite "RND_Min_isMin"))
            ("4" (rewrite "RND_Min_isMin"))
            ("5" (rewrite "isMin_Unique"))
            ("6" (rewrite "isMin_RoundedMode"))
            ("7" (rewrite "FcanonicBounded"))
            ("8" (rewrite "FcanonicBounded"))))
          ("2" (rewrite "max_fp_correct") (expand "abs") (grind-reals))
          ("3"
           (case-replace "max_neg=-max_pos")
           (("1" (expand "abs") (assert))
            ("2"
             (hide-all-but 1)
             (expand* "max_pos" "max_neg" "max_fp_pos" "max_fp_neg"
              "value" "pos" "neg")
             (rewrite "expt_x0")
             (rewrite "expt_x1")
             (assert))
            ("3" (lemma "E_max_gt_E_min") (propax))))))
        ("2" (rewrite "max_fp_correct") (expand "abs") (grind-reals))
        ("3"
         (case-replace "max_neg=-max_pos")
         (("1" (expand "abs") (assert))
          ("2"
           (hide-all-but 1)
           (expand* "max_pos" "max_neg" "max_fp_pos" "max_fp_neg" "value"
            "pos" "neg")
           (rewrite "expt_x1")
           (rewrite "expt_x0")
           (assert))
          ("3" (lemma "E_max_gt_E_min") (propax))))))))
    ("2" (hide-all-but 1) (flatten) (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "FORALL (i,j:int): integer?(i*j)")
   (("1"
     (inst -1 "(-1) ^ sign[radix, p, E_max, E_min](ieee)"
      "radix ^ (p - 1)
                                                   *
                                                   Sum(p,
                                                       value_digit[radix, p, E_max, E_min]
                                                           (d[radix, p, E_max, E_min](ieee)))")
     (("1" (expand "integer?") (flatten) (assert))
      ("2"
       (hide 2)
       (case "FORALL (d:digits),(n:upto(p)): rational_pred(radix ^ (p - 1) *
                                                                                                                  Sum(n,
                                                                                                                      value_digit[radix, p, E_max, E_min]
                                                                                                                          (d)))
                                                                                                    AND
                                                                                                    integer_pred(radix ^ (p - 1) *
                                                                                                                  Sum(n,
                                                                                                                      value_digit[radix, p, E_max, E_min]
                                                                                                                          (d)))")
       (("1" (inst -1 "d[radix, p, E_max, E_min](ieee)" "p"))
        ("2"
         (hide 2)
         (induct "n" 1 "upto_induction[p]")
         (("1" (expand "Sum") (propax))
          ("2"
           (skosimp*)
           (inst -2 "d!1")
           (flatten)
           (rewrite "Sum" 1)
           (assert)
           (case " rational_pred(value_digit[radix, p, E_max, E_min](d!1)(jt!1) *
                                                                                                                                                      radix ^ (p - 1)) AND
                                                                                                                                     integer_pred(value_digit[radix, p, E_max, E_min](d!1)(jt!1) *
                                                                                                                                                      radix ^ (p - 1))")
           (("1"
             (case "FORALL (i,j:int): integer?(i+j)")
             (("1" (inst?) (assert) (expand "integer?") (propax))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (expand "integer?")
               (propax))))
            ("2"
             (hide -2 -3 2)
             (split)
             (("1" (expand "value_digit") (propax))
              ("2"
               (expand "value_digit")
               (case-replace
                "d!1(jt!1) * radix ^ (p - 1) * radix ^ (-jt!1)=
                                                                                                                 d!1(jt!1) *(radix ^ (p - 1) * radix ^ (-jt!1))")
               (("1"
                 (rewrite "expt_plus" :dir rl)
                 (hide -1)
                 (case "FORALL (i,j:int): integer?(i*j)")
                 (("1"
                   (inst?)
                   (("1" (expand "integer?") (propax))
                    ("2"
                     (grind-reals)
                     (case "0 <= (-jt!1) - 1 + p ")
                     (("1" (assert) (expand "^") (propax))
                      ("2" (assert))))))
                  ("2"
                   (hide -1 2)
                   (skeep)
                   (expand "integer?")
                   (propax))))
                ("2" (assert))))))))
          ("3" (hide 2) (skosimp*) (assert))
          ("4" (hide 2) (skosimp*) (assert))))
        ("3" (hide 2) (skosimp*) (assert))
        ("4" (hide 2) (skosimp*) (assert))))
      ("3" (hide 2) (grind-reals))))
    ("2" (hide 2) (skosimp*) (expand "integer?") (propax))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "value[radix, p, E_max, E_min](ieee) =
                                      FtoR[radix]
                                          ((# Fnum
                                                := (-1) ^ sign[radix, p, E_max, E_min](ieee) *
                                                    radix ^ (p - 1)
                                                    *
                                                    Sum(p,
                                                        value_digit[radix, p, E_max, E_min]
                                                            (d[radix, p, E_max, E_min](ieee))),
                                              Fexp := Exp[radix, p, E_max, E_min](ieee) + 1 - p #))")
   (("1"
     (split)
     (("1"
       (hide -1)
       (expand "Fbounded?")
       (split)
       (("1"
         (expand "vNum")
         (expand "b")
         (rewrite "abs_mult")
         (rewrite "abs_mult")
         (lemma "Sum_nonneg")
         (inst?)
         (expand "abs" 1 1)
         (grind-reals)
         (case-replace
          "abs((-1) ^ sign[radix, p, E_max, E_min](ieee))=1")
         (("1"
           (expand "abs" 1 1)
           (lemma "value_sig_lt_b")
           (inst?)
           (case-replace " radix ^ p=radix*radix^ (p - 1)")
           (("1" (div-by 1 "radix ^ (p - 1)"))
            ("2"
             (lemma "expt_plus")
             (inst -1 "1" "p-1" "radix")
             (rewrite "expt_x1")
             (assert))))
          ("2"
           (hide -1 2)
           (typepred "sign[radix, p, E_max, E_min](ieee)")
           (split)
           (("1" (rewrite -1) (expand* "^" "expt" "abs"))
            ("2"
             (replace -1)
             (expand* "^" "expt" "abs")
             (expand "expt")
             (propax))))))
        ("2" (expand "b") (assert))))
      ("2" (propax))
      ("3"
       (replace -1 :dir rl)
       (hide -1)
       (lemma "finite_cover")
       (inst?)
       (split)
       (("1" (expand "zero?") (replace -1) (expand "abs") (assert))
        ("2"
         (lemma "value_normal")
         (inst?)
         (split)
         (("1"
           (flatten)
           (trans-ineq 1 " max_pos" :strict 2)
           (rewrite "max_fp_correct")
           (grind-reals))
          ("2" (propax))))
        ("3"
         (lemma "value_subnormal")
         (inst?)
         (split)
         (("1"
           (flatten)
           (trans-ineq 1 "radix ^ E_min" :strict 1)
           (rewrite "Exp_increq_1")
           (lemma "E_max_gt_E_min")
           (assert))
          ("2" (propax))))))))
    ("2"
     (hide 2)
     (expand "FtoR")
     (expand "value")
     (case "Sum(p, value_digit(d(ieee))) * (-1) ^ sign(ieee) * radix ^ Exp(ieee)
                                                                        =
                                                                        Sum(p,
                                                                            value_digit[radix, p, E_max, E_min]
                                                                                (d[radix, p, E_max, E_min](ieee)))
                                                                         * (-1) ^ sign[radix, p, E_max, E_min](ieee)
                                                                         * (radix ^ (p - 1)
                                                                         * radix ^ (1+Exp[radix, p, E_max, E_min](ieee) - p))")
     (("1" (rewrite -1)) ("2" (hide 2) (rewrite "expt_plus" :dir rl))))
    ("3"
     (hide 2)
     (lemma "IEEE_to_float_TCC4")
     (inst?)
     (flatten)
     (assert))
    ("4" (hide 2) (flatten) (assert))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (split)
   (("1"
     (case "Fbounded?(b)(f!1)")
     (("1" (expand* "Fbounded?" "b") (flatten) (assert))
      ("2" (rewrite "FcanonicBounded"))))
    ("2"
     (expand "Fcanonic?")
     (split)
     (("1"
       (expand "Fnormal?")
       (flatten)
       (case " Fexp(f!1) + p - 1 < E_max + 1")
       (("1" (assert))
        ("2"
         (rewrite "Exp_incr_2")
         (hide 2 3)
         (trans-ineq 1 "abs(FtoR(f!1))" :strict 2)
         (rewrite "expt_plus")
         (rewrite "expt_div" :dir rl)
         (expand "FtoR")
         (rewrite "abs_mult")
         (expand "abs" 1 2)
         (rewrite "abs_mult")
         (expand "abs" -2 1)
         (case-replace "vNum(b)=radix ^ p")
         (("1" (div-by 1 "radix ^ Fexp(f!1)") (field 1))
          ("2" (expand "b") (expand "vNum") (propax))))))
      ("2"
       (expand* "Fsubnormal?" "b")
       (flatten)
       (rewrite -2)
       (lemma "E_max_gt_E_min")
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: IEEE_link
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (expand* "FtoR" "value")
   (case-replace
    "radix ^ (Fexp(f!1) - 1 + p)=radix ^ (Fexp(f!1))*radix^(p-1)")
   (("1"
     (div-by 1 "radix ^ (Fexp(f!1))")
     (("1"
       (field 1)
       (("1"
         (case " Sum(p,
                                                                               value_digit(LAMBDA (i: below(p)):
                                                                                             mod(floor((radix ^ (1+i-p)) * abs(Fnum(f!1))), radix)))*(radix ^ (p - 1))=abs(Fnum(f!1))")
         (("1"
           (case "Fnum(f!1) =((-1) ^ sign_of[radix, p](Fnum(f!1)))* abs(Fnum(f!1))")
           (("1" (assert))
            ("2"
             (hide-all-but 1)
             (expand* "sign_of" "pos" "neg" "abs")
             (grind-reals)
             (("1" (rewrite "expt_x1") (assert))
              ("2" (rewrite "expt_x0") (assert))))))
          ("2"
           (hide 2 -1)
           (case "FORALL (j:upto(p)): Sum(j, value_digit(LAMBDA (i: below(p)):
                                        mod(floor((radix ^ (1+i-p)) * abs(Fnum(f!1))), radix)))
                                                                                    * (radix ^ (j-1))
                                         = floor(abs(Fnum(f!1))*radix^(j-p))")
           (("1"
             (inst?)
             (copy -2)
             (rewrite -2)
             (rewrite "expt_x0")
             (assert)
             (lemma "floor_int")
             (inst?))
            ("2"
             (hide 2)
             (induct "j" 1 "upto_induction[p]")
             (("1"
               (rewrite "Sum")
               (lemma "floor_0")
               (inst?)
               (flatten)
               (split -2)
               (("1" (assert)) ("2" (grind-reals))
                ("3"
                 (hide 2)
                 (case-replace "0-p=-p")
                 (("1"
                   (rewrite "expt_inverse")
                   (mult-by 1 "radix ^ p")
                   (field 1)
                   (case "radix ^ p=vNum(b)")
                   (("1"
                     (expand* "Fcanonic?" "Fsubnormal?" "Fnormal?"
                      "Fbounded?")
                     (assert))
                    ("2" (expand "b" 1) (expand "vNum") (propax))))
                  ("2" (assert))))))
              ("2"
               (skosimp*)
               (rewrite "Sum" 1)
               (assert)
               (case-replace
                "Sum(jt!1,
                           value_digit(LAMBDA (i: below(p)):
                                         mod(floor((radix ^ (1 + i - p)) * abs(Fnum(f!1))),
                                             radix)))
                        * (radix ^ jt!1)=radix*floor(abs(Fnum(f!1)) * radix ^ (jt!1 - p))")
               (("1"
                 (expand "value_digit")
                 (hide -1 -3)
                 (case-replace
                  "mod(floor((radix ^ (1 - p + jt!1)) * abs(Fnum(f!1))), radix) *
                         radix ^ (-jt!1)
                         * (radix ^ jt!1) = mod(floor((radix ^ (1 - p + jt!1)) * abs(Fnum(f!1))), radix) *
                    ( radix ^ (-jt!1)* (radix ^ jt!1))")
                 (("1"
                   (rewrite "expt_plus" :dir rl)
                   (assert)
                   (case-replace
                    " mod(floor((radix ^ (1 - p + jt!1)) * abs(Fnum(f!1))), radix)
                       * radix ^ ((-jt!1) + jt!1)=mod(floor((radix ^ (1 - p + jt!1)) * abs(Fnum(f!1))), radix)")
                   (("1"
                     (case "FORALL (n,j:int): mod(floor(radix^j*n),radix)+
                              radix*floor(radix^(j-1)*n)=floor(radix^j*n)")
                     (("1" (inst?) (assert))
                      ("2"
                       (hide-all-but 1)
                       (skeep)
                       (lemma "rem_floor")
                       (lemma "mod_to_rem")
                       (inst -2 "radix" "floor(radix ^ j * n)")
                       (case "mod(floor(radix ^ j * n), radix) + radix * floor(radix ^ (j - 1) * n)
                              = rem(radix)(floor(radix ^ j * n)) +
                                      radix * floor(floor(radix ^ j * n) / radix)")
                       (("1" (assert))
                        ("2"
                         (hide 2 -2)
                         (inst?)
                         (rewrite -1)
                         (move-terms 1 l 1)
                         (assert)
                         (div-by 1 "radix")
                         (case "(FORALL (r:real): (floor(r)=floor(floor(radix*r)/radix)))")
                         (("1"
                           (inst -1 "radix ^ (j - 1) * n")
                           (case-replace
                            "radix ^ j=radix * (radix ^ (j - 1))")
                           (("1" (assert))
                            ("2"
                             (lemma "expt_plus")
                             (inst -1 "1" "j-1" "radix")
                             (rewrite "expt_x1")
                             (assert))))
                          ("2"
                           (hide-all-but 1)
                           (skeep)
                           (case "floor(floor(radix * r) / radix) <= r")
                           (("1"
                             (case " r < floor(floor(radix * r) / radix)+1")
                             (("1" (assert))
                              ("2"
                               (hide -1 2)
                               (move-terms 1 r 2)
                               (trans-ineq 1
                                "floor(radix * r) / radix-1+1/radix"
                                :strict 1)
                               (("1" (field 1))
                                ("2"
                                 (field 1)
                                 (case
                                  "floor(radix * r) - radix <
                                         floor(floor(radix * r) / radix) * radix")
                                 (("1" (assert))
                                  ("2"
                                   (div-by 1 "radix")
                                   (grind-reals))))))))
                            ("2"
                             (trans-ineq 1 "floor(radix * r) / radix")
                             (("1" (assert))
                              ("2"
                               (trans-ineq 1 "(radix * r)/radix")
                               (("1" (grind-reals))
                                ("2" (grind-reals))))))))))))))
                    ("2"
                     (hide-all-but 1)
                     (case-replace "(-jt!1) + jt!1=0")
                     (("1" (rewrite "expt_x0") (assert))
                      ("2" (assert))))))
                  ("2" (assert))))
                ("2"
                 (hide 2)
                 (rewrite -2 :dir rl)
                 (div-by 1
                  " Sum(jt!1,
                                                            value_digit(LAMBDA (i: below(p)):
                                                                          mod(floor((radix ^ (1+i-p )) * abs(Fnum(f!1))),
                                                                              radix)))")
                 (("1"
                   (field 1)
                   (lemma "expt_plus")
                   (inst -1 "1" "jt!1 - 1" "radix")
                   (rewrite "expt_x1")
                   (assert))
                  ("2" (lemma "E_max_gt_E_min") (propax))))))
              ("3" (lemma "E_max_gt_E_min") (propax))))))
          ("3" (lemma "E_max_gt_E_min") (propax))))
        ("2" (lemma "E_max_gt_E_min") (propax))))
      ("2" (lemma "E_max_gt_E_min") (propax))))
    ("2"
     (lemma "expt_plus")
     (inst -1 "Fexp(f!1)" "p-1" "radix")
     (assert))
    ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "MinOrMax?")
   (split)
   (("1"
     (rewrite "RoundedModeUlp" :subst ("b" "b" "P" "isMin?"))
     (rewrite "isMin_RoundedMode"))
    ("2"
     (rewrite "RoundedModeUlp" :subst ("b" "b" "P" "isMax?"))
     (rewrite "isMax_RoundedMode"))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "MinOrMax?")
   (split)
   (("1" (skosimp*) (rewrite "MinOppMax"))
    ("2" (skosimp*) (rewrite "MaxOppMin"))))


