# Proofs

proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x"))
   (flatten)
   (typepred "x")
   (assert)
   (typepred "atan(x / sqrt(1 - x * x))")
   (("1" (assert))
    ("2"
     (lemma "sqrt_pos" ("px" "1-x*x"))
     (("1" (assert))
      ("2" (hide 2) (lemma "sq_lt_abs" ("a" "x" "b" "1")) (grind))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "x!1")
   (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
   (expand "abs" -1 2)
   (expand "sq" -1 2)
   (assert)
   (expand "abs")
   (lift-if)
   (ground))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "x!1")
   (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
   (expand "abs" -1 2)
   (expand "sq" -1 2)
   (lemma "sqrt_pos" ("px" "1 - sq(x!1)"))
   (("1" (assert)) ("2" (assert) (expand "abs") (lift-if) (ground))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: acos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z"))
   (expand "acos")
   (lemma "const_derivable_fun[real_abs_lt1]" ("b" "pi/2"))
   (lemma "asin_derivable_fun")
   (expand "const_fun")
   (lemma "diff_derivable_fun[real_abs_lt1]"
    ("f1"
     "LAMBDA (x: real_abs_lt1): pi / 2"
     "f2"
     "LAMBDA (x: real_abs_lt1): asin(x)"))
   (assert)
   (expand "-" -1)
   (expand "derivable?" -1)
   (inst - "z"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: acos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "asin_derivable_fun")
   (expand "acos" 1)
   (lemma "const_derivable_fun[real_abs_lt1]" ("b" "pi/2"))
   (lemma "deriv_const_fun[real_abs_lt1]" ("b" "pi/2"))
   (expand "const_fun")
   (lemma "diff_derivable_fun[real_abs_lt1]"
    ("f1"
     "LAMBDA (x: real_abs_lt1): pi / 2"
     "f2"
     "LAMBDA (x: real_abs_lt1): asin(x)"))
   (assert)
   (expand "-")
   (lemma "deriv_diff_fun[real_abs_lt1]"
    ("ff1"
     "LAMBDA (x: real_abs_lt1): pi / 2"
     "ff2"
     "LAMBDA (x: real_abs_lt1): asin(x)"))
   (expand "-")
   (replace -3 -1)
   (simplify -1)
   (replace -1 1)
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: acos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "x!1")
   (expand "abs")
   (case "x!1<0")
   (("1" (assert)) ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: acos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "not_one_element?")
   (skosimp*)
   (case "x!1=0")
   (("1" (inst + "1/2") (assert)) ("2" (assert) (inst + "0") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "not_one_element?")
   (skosimp*)
   (inst-cp + "pi/4")
   (inst + "pi/8")
   (flatten)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "not_one_element?")
   (skosimp*)
   (inst-cp + "0")
   (inst + "1/2")
   (flatten)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_open")
   (inst - "0" "pi")
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst + "y!1"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_open")
   (inst - "0" "pi/4")
   (assert)
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst + "y!1"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin_value")
   (lemma "asin_bij")
   (lemma "bij_inv_is_bij[real_abs_le1, real_abs_le_pi2]" ("f" "asin"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "acos_bij")
   (lemma "bij_inv_is_bij[real_abs_le1, nnreal_le_pi]" ("f" "acos"))
   (expand "cos_value")
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "asin_strict_increasing")
   (expand "strict_increasing?")
   (skosimp*)
   (expand "sin_value")
   (lemma "asin_bij")
   (lemma "trich_lt" ("x" "inverse(asin)(x!1)" "y" "inverse(asin)(y!1)"))
   (split -1)
   (("1" (propax))
    ("2"
     (lemma "bij_inv_is_bij" ("f" "asin"))
     (assert)
     (expand "bijective?" -1)
     (expand "injective?" -1)
     (flatten -1)
     (inst - "x!1" "y!1")
     (assert))
    ("3"
     (inst - "inverse(asin)(y!1)" "inverse(asin)(x!1)")
     (assert)
     (lemma "comp_inverse_right[real_abs_le1, real_abs_le_pi2]"
      ("f" "asin" "y" "x!1"))
     (lemma "comp_inverse_right[real_abs_le1, real_abs_le_pi2]"
      ("f" "asin" "y" "y!1"))
     (replace -1)
     (replace -2)
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "sin_value_strict_increasing")
   (expand "strict_increasing?")
   (expand "increasing?")
   (skosimp*)
   (expand "<=" -2)
   (split -2)
   (("1" (inst - "x!1" "y!1") (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_value")
   (lemma "acos_strict_decreasing")
   (expand "strict_decreasing?")
   (skosimp*)
   (lemma "trich_lt" ("x" "inverse(acos)(y!1)" "y" "inverse(acos)(x!1)"))
   (split -1)
   (("1" (propax))
    ("2"
     (lemma "cos_value_bij")
     (expand "bijective?")
     (expand "injective?")
     (flatten)
     (inst - "x!1" "y!1")
     (expand "cos_value")
     (assert))
    ("3"
     (inst - "inverse(acos)(x!1)" "inverse(acos)(y!1)")
     (assert)
     (lemma "acos_bij")
     (lemma "comp_inverse_right[real_abs_le1, nnreal_le_pi]"
      ("f" "acos"))
     (("1" (inst-cp - "x!1") (inst - "y!1") (assert)) ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "cos_value_strict_decreasing")
   (expand "strict_decreasing?")
   (expand "decreasing?")
   (skosimp*)
   (expand "<=" -2)
   (split -2)
   (("1" (inst - "x!1" "y!1") (assert)) ("2" (replace -1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z"))
   (expand "sin_value")
   (lemma "asin_bij")
   (expand "bijective?")
   (flatten)
   (expand "injective?")
   (inst - "inverse(asin)(-z)" "-inverse(asin)(z)")
   (("1"
     (rewrite "asin_neg" -1)
     (lemma "asin_bij")
     (lemma "comp_inverse_right" ("f" "asin"))
     (("1"
       (inst-cp - "z")
       (inst - "-z")
       (("1" (replace -1) (replace -2) (propax))
        ("2"
         (typepred "z")
         (hide-all-but (-1 1))
         (expand "abs")
         (lemma "trichotomy" ("x" "z"))
         (split -1)
         (("1" (assert)) ("2" (assert)) ("3" (assert))))))
      ("2" (propax))))
    ("2"
     (hide 2)
     (typepred "z")
     (typepred "inverse[real_abs_le1, real_abs_le_pi2](asin)(z)")
     (expand "abs" (-1 1))
     (lemma "trichotomy"
      ("x" "inverse[real_abs_le1, real_abs_le_pi2](asin)(z)"))
     (split -1)
     (("1" (assert)) ("2" (assert)) ("3" (assert))))
    ("3" (hide -1 2) (typepred "z") (rewrite "abs_neg"))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z"))
   (typepred "z")
   (typepred "cos_value(z)")
   (lemma "acos_bij")
   (expand "bijective?")
   (expand "injective?")
   (flatten)
   (inst - "cos_value(pi - z)" "-cos_value(z)")
   (("1"
     (expand "cos_value" (-1 1))
     (rewrite "acos_neg" -1)
     (lemma "acos_bij")
     (lemma "comp_inverse_right[real_abs_le1, nnreal_le_pi]"
      ("f" "acos" "y" "pi-z"))
     (("1"
       (replace -1)
       (lemma "comp_inverse_right[real_abs_le1, nnreal_le_pi]"
        ("f" "acos" "y" "z"))
       (replace -1)
       (propax))
      ("2" (propax))))
    ("2" (mult-by -2 "-1" -) (mult-by -3 "-1" -) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z"))
   (typepred "z")
   (typepred "cos_value(pi / 2 + z)")
   (("1"
     (expand "cos_value")
     (expand "sin_value")
     (lemma "acos_bij")
     (expand "bijective?")
     (flatten)
     (expand "injective?")
     (inst - "inverse(asin)(z)" "-inverse(acos)(pi / 2 + z)")
     (("1"
       (split -1)
       (("1" (propax))
        ("2"
         (hide 2)
         (rewrite "acos_neg" 1)
         (lemma "acos_bij")
         (lemma "comp_inverse_right[real_abs_le1, nnreal_le_pi]"
          ("f" "acos" "y" "pi/2+z"))
         (("1"
           (replace -1)
           (lemma "asin_bij")
           (expand "acos" 1)
           (lemma "comp_inverse_right" ("f" "asin" "y" "z"))
           (("1" (replace -1) (assert)) ("2" (propax))))
          ("2" (propax))))))
      ("2"
       (expand "abs" -3)
       (lift-if)
       (lemma "abs_neg")
       (inst?)
       (("1" (assert)) ("2" (assert) (ground))))
      ("3" (assert) (expand "abs" -3) (assert))))
    ("2"
     (hide 2)
     (expand "abs")
     (case "z<0")
     (("1" (assert) (assert)) ("2" (assert) (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin_eqv_cos_value" ("xs" "q1!1"))
   (("1"
     (replace -1)
     (lemma "cos_value_neg" ("xc" "pi/2-q1!1"))
     (assert))
    ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "asin_bij")
   (expand "sin_value")
   (lemma "asin_minus1")
   (lemma "bijective_inverse[real_abs_le1, real_abs_le_pi2]"
    ("f" "asin" "y" "-pi/2" "x" "-1"))
   (("1" (assert)) ("2" (propax)) ("3" (expand "abs" 1) (assert))
    ("4" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin_value")
   (lemma "asin_0")
   (lemma "asin_bij")
   (lemma "bijective_inverse[real_abs_le1, real_abs_le_pi2]"
    ("f" "asin" "y" "0" "x" "0"))
   (("1" (assert)) ("2" (propax)) ("3" (expand "abs") (assert))
    ("4" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "asin_sqrt_half")
   (lemma "asin_bij")
   (expand "sin_value")
   (lemma "bijective_inverse[real_abs_le1, real_abs_le_pi2]"
    ("f" "asin" "y" "pi/4" "x" "sqrt(1/2)"))
   (("1" (assert)) ("2" (propax))
    ("3" (expand "abs" 1) (typepred "pi") (assert))
    ("4"
     (expand "abs")
     (typepred "sqrt(1/2)")
     (assert)
     (lemma "sqrt_le" ("nny" "1/2" "nnz" "1"))
     (rewrite "sqrt_1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "sin_value_minus_pi2")
   (lemma "sin_value_neg" ("xs" "pi/2"))
   (("1" (assert)) ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_value")
   (lemma "acos_1")
   (lemma "acos_bij")
   (lemma "bijective_inverse[real_abs_le1, nnreal_le_pi]"
    ("f" "acos" "x" "1" "y" "0"))
   (("1" (assert)) ("2" (propax)) ("3" (assert))
    ("4" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "sin_value_pi4")
   (rewrite "sin_eqv_cos_value")
   (("1" (lemma "cos_value_neg" ("xc" "pi/4")) (assert))
    ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_value")
   (lemma "acos_bij")
   (lemma "acos_0")
   (lemma "bijective_inverse[real_abs_le1, nnreal_le_pi]"
    ("f" "acos" "x" "0" "y" "pi/2"))
   (("1" (assert)) ("2" (propax)) ("3" (assert))
    ("4" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_value")
   (lemma "acos_bij")
   (lemma "acos_minus1")
   (lemma "bijective_inverse[real_abs_le1, nnreal_le_pi]"
    ("f" "acos" "x" "-1" "y" "pi"))
   (("1" (assert)) ("2" (propax)) ("3" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "xs!1")
   (lemma "asin_bij")
   (expand "sin_value")
   (lemma "comp_inverse_right[real_abs_le1, real_abs_le_pi2]"
    ("f" "asin" "y" "xs!1"))
   (("1" (propax)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "xc!1")
   (expand "cos_value")
   (lemma "comp_inverse_right[real_abs_le1, nnreal_le_pi]"
    ("f" "acos" "y" "xc!1"))
   (("1" (propax)) ("2" (lemma "acos_bij") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "xa!1")
   (lemma "asin_bij")
   (lemma "comp_inverse_left[real_abs_le1, real_abs_le_pi2]"
    ("f" "asin" "x" "xa!1"))
   (("1" (expand "sin_value") (propax)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "cos_value")
   (lemma "acos_bij")
   (typepred "xa!1")
   (lemma "comp_inverse_left[real_abs_le1, nnreal_le_pi]"
    ("f" "acos" "x" "xa!1"))
   (("1" (propax)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z1"))
   (typepred "z1")
   (lemma "cos_value_decreasing")
   (lemma "sin_value_increasing")
   (expand "increasing?")
   (expand "decreasing?")
   (inst-cp - "0" "z1")
   (inst - "z1" "pi/2")
   (inst-cp - "0" "z1")
   (inst - "z1" "pi/2")
   (assert)
   (rewrite "sin_value_0")
   (rewrite "sin_value_pi2")
   (rewrite "cos_value_0")
   (rewrite "cos_value_pi2")
   (lemma "acos_sum" ("nnx" "cos_value(z1)" "nny" "sin_value(z1)"))
   (("1"
     (rewrite "acos_cos_value" -1)
     (lemma "sin_eqv_cos_value" ("xs" "z1"))
     (case "acos(sin_value(z1)) = pi/2 - z1")
     (("1"
       (replace -1 -3)
       (hide -1 -2)
       (lemma "acos_bij")
       (expand "bijective?")
       (expand "injective?")
       (flatten -1)
       (inst - "0"
        "cos_value(z1) * sin_value(z1) -
                     (sqrt(1 - sq(sin_value(z1)))) * (sqrt(1 - sq(cos_value(z1))))")
       (("1"
         (rewrite "acos_0")
         (replace -3 -1)
         (lemma "sq_eq"
          ("nna"
           "cos_value(z1) * sin_value(z1)"
           "nnb"
           "(sqrt(1 - sq(sin_value(z1)))) * (sqrt(1 - sq(cos_value(z1))))"))
         (("1"
           (lemma "sqrt_times"
            ("nny"
             "1 - sq(sin_value(z1))"
             "nnz"
             "1 - sq(cos_value(z1))"))
           (replace -1 * rl)
           (hide -1)
           (rewrite "sq_sqrt" -1)
           (assert)
           (hide -2 -4)
           (lemma "both_sides_plus1"
            ("x"
             "sq(cos_value(z1) * sin_value(z1))"
             "y"
             "1 - sq(cos_value(z1)) +
                     sq(cos_value(z1)) * sq(sin_value(z1)) - sq(sin_value(z1))"
             "z"
             "sq(cos_value(z1)) + sq(sin_value(z1)) - sq(cos_value(z1)) * sq(sin_value(z1))"))
           (replace -1 -2 rl)
           (hide -1)
           (rewrite "sq_times" -1)
           (simplify -1)
           (propax))
          ("2"
           (hide 2)
           (lemma "sq_le" ("nna" "cos_value(z1)" "nnb" "1"))
           (rewrite "sq_1")
           (assert))
          ("3"
           (lemma "sq_le" ("nna" "sin_value(z1)" "nnb" "1"))
           (rewrite "sq_1")
           (assert))
          ("4"
           (lemma "le_times_le_pos"
            ("nnx"
             "0"
             "y"
             "cos_value(z1)"
             "nnz"
             "0"
             "w"
             "sin_value(z1)"))
           (assert))))
        ("2"
         (hide -1 -2 2)
         (lemma "le_times_le_pos"
          ("nnx" "0" "y" "cos_value(z1)" "nnz" "0" "w" "sin_value(z1)"))
         (assert)
         (lemma "le_times_le_pos"
          ("nnx" "cos_value(z1)" "y" "1" "nnz" "sin_value(z1)" "w" "1"))
         (assert)
         (lemma "sq_le_abs" ("a" "sin_value(z1)" "b" "1"))
         (lemma "sq_le_abs" ("a" "cos_value(z1)" "b" "1"))
         (expand "abs" -1 2)
         (expand "abs" -2 2)
         (rewrite "sq_1")
         (typepred "sq(sin_value(z1))")
         (typepred "sq(cos_value(z1))")
         (typepred "sqrt(1 - sq(sin_value(z1)))")
         (("1"
           (hide -2 -4)
           (lemma "sqrt_le" ("nny" "1 - sq(sin_value(z1))" "nnz" "1"))
           (rewrite "sqrt_1")
           (assert)
           (expand "abs")
           (propax))
          ("2" (assert) (expand "abs") (propax))))
        ("3"
         (lemma "sq_le" ("nna" "cos_value(z1)" "nnb" "1"))
         (rewrite "sq_1")
         (assert))))
      ("2"
       (hide -2 2)
       (replace -1 1)
       (rewrite "acos_neg" 1)
       (rewrite "acos_cos_value" 1)
       (assert))))
    ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin2_cos2_value" ("q1" "q1!1"))
   (typepred "q1!1")
   (lemma "cos_value_decreasing")
   (expand "decreasing?")
   (inst-cp - "0" "q1!1")
   (inst - "q1!1" "pi/2")
   (assert)
   (rewrite "cos_value_pi2")
   (rewrite "cos_value_0")
   (lemma "sq_le" ("nna" "cos_value(q1!1)" "nnb" "1"))
   (("1"
     (rewrite "sq_1")
     (lemma "sin_value_increasing")
     (expand "increasing?")
     (inst - "0" "q1!1")
     (("1"
       (flatten -2)
       (replace -5 -3)
       (hide -2)
       (assert)
       (rewrite "sin_value_0")
       (lemma "sq_eq"
        ("nna" "sin_value(q1!1)" "nnb" "sqrt(1 - sq(cos_value(q1!1)))"))
       (("1" (assert)) ("2" (assert))))
      ("2" (expand "abs") (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin2_cos2_value" ("q1" "q1!1"))
   (typepred "q1!1")
   (lemma "sin_value_increasing")
   (lemma "cos_value_decreasing")
   (expand "increasing?")
   (inst-cp - "0" "q1!1")
   (("1"
     (rewrite "sin_value_0")
     (inst - "q1!1" "pi/2")
     (("1"
       (assert)
       (rewrite "sin_value_pi2")
       (lemma "sq_le" ("nna" "sin_value(q1!1)" "nnb" "1"))
       (replace -3 -1)
       (rewrite "sq_1")
       (flatten -1)
       (expand "decreasing?")
       (inst - "q1!1" "pi/2")
       (assert)
       (rewrite "cos_value_pi2")
       (lemma "sq_eq"
        ("nna" "cos_value(q1!1)" "nnb" "sqrt(1 - sq(sin_value(q1!1)))"))
       (("1" (assert)) ("2" (assert))))
      ("2" (expand "abs") (assert))))
    ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "qo1!1")
   (lemma "asin_sin_value" ("xs" "qo1!1"))
   (("1"
     (expand "asin")
     (lemma "sin_value_strict_increasing")
     (expand "strict_increasing?")
     (inst-cp - "qo1!1" "pi/2")
     (("1"
       (rewrite "sin_value_pi2")
       (replace -5)
       (replace -2)
       (expand ">=" -4)
       (expand "<=" -4)
       (split -4)
       (("1"
         (inst - "0" "qo1!1")
         (("1"
           (rewrite "sin_value_0")
           (replace -1)
           (assert)
           (rewrite "sq_rew" -4)
           (rewrite "cos_eqv_sqrt_sin_value" -4))
          ("2" (expand "abs" 1) (assert))
          ("3" (expand "abs" 1) (assert))))
        ("2"
         (replace -1 * rl)
         (rewrite "sin_value_0")
         (rewrite "cos_value_0")
         (rewrite "atan_0"))))
      ("2" (expand "abs" 1) (assert)) ("3" (expand "abs" 1) (assert))))
    ("2" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin_value_asin" ("xa" "x!1/sqrt(1+sq(x!1))"))
   (("1"
     (expand "asin")
     (lemma "div_mult_pos_lt1")
     (inst - "sqrt(1+sq(x!1))" "1" "x!1")
     (lemma "div_cancel3" ("x" "x!1" "n0z" "sqrt(1 + sq(x!1))" "y" "-1"))
     (lemma "trichotomy" ("x" "x!1"))
     (split -1)
     (("1"
       (assert)
       (replace -3)
       (lemma "sq_lt" ("nna" "x!1" "nnb" "sqrt(1 + sq(x!1))"))
       (rewrite "sq_sqrt")
       (assert)
       (rewrite "sq_rew" -5)
       (rewrite "sq_div" -5)
       (lemma "cross_mult"
        ("x"
         "x!1 / sqrt(1 + sq(x!1))"
         "n0x"
         "sqrt(1 - sq(x!1) / (1 + sq(x!1)))"
         "y"
         "x!1"
         "n0y"
         "1"))
       (flatten -1)
       (hide -1 -3 -5 -6)
       (split -1)
       (("1" (replace -1) (assert))
        ("2"
         (hide -2 2)
         (lemma "minus_div1"
          ("x" "1" "n0x" "1" "y" "sq(x!1)" "n0y" "1+sq(x!1)"))
         (replace -1)
         (hide -1)
         (assert)
         (rewrite "sqrt_div")
         (assert))))
      ("2"
       (replace -1)
       (rewrite "sq_0")
       (rewrite "sqrt_1")
       (rewrite "atan_0")
       (rewrite "sin_value_0")
       (assert))
      ("3"
       (assert)
       (case "-x!1 /sqrt(1+sq(x!1)) < 1")
       (("1"
         (assert)
         (rewrite "sq_rew")
         (rewrite "sq_div" -5)
         (lemma "cross_mult"
          ("x"
           "x!1 / sqrt(1 + sq(x!1))"
           "n0x"
           "sqrt(1 - sq(x!1) / (1 + sq(x!1)))"
           "y"
           "x!1"
           "n0y"
           "1"))
         (flatten -1)
         (hide -1 -3 -5 -6)
         (split -1)
         (("1" (replace -1) (assert))
          ("2"
           (hide -2 2)
           (lemma "minus_div1"
            ("x" "1" "n0x" "1" "y" "sq(x!1)" "n0y" "1+sq(x!1)"))
           (replace -1)
           (rewrite "sqrt_div")
           (assert))))
        ("2"
         (assert)
         (hide-all-but (-1 1))
         (rewrite "sq_lt" :dir rl)
         (rewrite "sq_div")
         (rewrite "div_mult_pos_lt1")
         (expand "sq")
         (assert))))))
    ("2"
     (hide 2)
     (rewrite "div_mult_pos_le1")
     (assert)
     (lemma "sq_le_abs" ("a" "x!1" "b" "sqrt(1+sq(x!1))"))
     (rewrite "sq_sqrt")
     (assert)
     (expand "abs")
     (lift-if)
     (ground)
     (("1" (cross-mult 1) (assert)) ("2" (cross-mult 1) (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "nnx!1")
   (expand ">=")
   (expand "<=")
   (split -1)
   (("1"
     (lemma "both_sides_times_pos_lt1"
      ("x" "0" "y" "nnx!1" "pz" "nnx!1"))
     (("1"
       (rewrite "sq_rew")
       (replace -2)
       (flatten -1)
       (rewrite "zero_times1")
       (lemma "sqrt_lt" ("nny" "1" "nnz" "1+sq(nnx!1)"))
       (rewrite "sqrt_1")
       (flatten -1)
       (hide -1)
       (split -1)
       (("1"
         (case "0<atan(nnx!1) & atan(nnx!1) < pi/2")
         (("1"
           (flatten -1)
           (rewrite "cos_eqv_sqrt_sin_value" :dir rl)
           (rewrite "sq_eq" :dir rl)
           (("1"
             (rewrite "sq_sqrt")
             (("1"
               (rewrite "sq_div")
               (rewrite "sq_sqrt")
               (rewrite "sq_1")
               (case "nnx!1/sqrt(1 + sq(nnx!1)) = sin_value(atan(nnx!1))")
               (("1"
                 (lemma "sq_eq"
                  ("nna"
                   "nnx!1 / sqrt(1 + sq(nnx!1))"
                   "nnb"
                   "sin_value(atan(nnx!1))"))
                 (("1"
                   (rewrite "sq_div" -1)
                   (rewrite "sq_sqrt")
                   (assert))
                  ("2"
                   (hide -1 2)
                   (lemma "sin_value_strict_increasing")
                   (expand "strict_increasing?")
                   (inst - "0" "atan(nnx!1)")
                   (("1" (rewrite "sin_value_0") (assert))
                    ("2" (expand "abs") (assert))
                    ("3" (expand "abs") (assert))))))
                ("2"
                 (hide 2)
                 (lemma "sin_value_atan" ("x" "nnx!1"))
                 (assert))
                ("3" (expand "abs" 1) (assert))))
              ("2" (expand "abs" 1) (assert))))
            ("2" (expand "abs" 1) (assert))))
          ("2"
           (hide-all-but (-3 1))
           (typepred "atan(nnx!1)")
           (lemma "atan_strict_increasing")
           (expand "strict_increasing?")
           (inst - "0" "nnx!1")
           (rewrite "atan_0")
           (assert)
           (expand "abs")
           (expand "pi")
           (expand "atan")
           (assert))))
        ("2" (assert))))
      ("2" (assert))))
    ("2"
     (replace -1 1 rl)
     (rewrite "atan_0")
     (rewrite "cos_value_0")
     (rewrite "sq_0")
     (rewrite "sqrt_1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin_value")
   (lemma "asin_bij")
   (lemma "bijective_inverse[real_abs_le1, real_abs_le_pi2]"
    ("f" "asin" "y" "pi/6" "x" "1/2"))
   (("1"
     (replace -1 1)
     (hide-all-but 1)
     (expand "asin")
     (case "1 / 2 / sqrt(1 - 1 / 2 * (1 / 2)) = 1/sqrt(3)")
     (("1"
       (replace -1)
       (hide -1)
       (lemma "atan_plus" ("x" "1/sqrt(3)" "y" "1/sqrt(3)"))
       (flatten)
       (hide -2 -3)
       (rewrite "sq_rew" -1)
       (rewrite "sq_div" -1)
       (assert)
       (lemma "minus_div1" ("x" "1" "n0x" "1" "y" "1" "n0y" "3"))
       (replace -1 -2)
       (hide -1)
       (simplify -1)
       (lemma "div_div1" ("x" "2 * (1 / sqrt(3))" "n0y" "2" "n0z" "3"))
       (replace -1 -2)
       (lemma "div_cancel1" ("x" "1 / sqrt(3) * 3" "n0z" "2"))
       (replace -1 *)
       (hide -1)
       (case "1 / sqrt(3) * 3 = sqrt(3)")
       (("1" (replace -1) (lemma "atan_inv" ("px" "sqrt(3)")) (assert))
        ("2"
         (hide -1 2)
         (lemma "sq_eq" ("nna" "3/sqrt(3)" "nnb" "sqrt(3)"))
         (replace -1 1 rl)
         (rewrite "sq_div" 1)
         (rewrite "sq_sqrt")
         (expand "sq")
         (assert))))
      ("2"
       (hide 2)
       (lemma "minus_div1" ("x" "1" "n0x" "1" "y" "1" "n0y" "4"))
       (replace -1 1)
       (rewrite "sqrt_div" 1)
       (lemma "div_div1" ("x" "1/2" "n0y" "sqrt(3)" "n0z" "sqrt(sq(2))"))
       (expand "sq" -1 1)
       (lemma "div_cancel1" ("x" "1" "n0z" "2"))
       (replace -1)
       (rewrite "div_div1" 1))
      ("3"
       (lemma "minus_div1" ("x" "1" "n0x" "1" "y" "1" "n0y" "4"))
       (replace -1 1)
       (hide -1 2)
       (lemma "sqrt_pos" ("px" "3/4"))
       (assert))))
    ("2" (propax)) ("3" (expand "abs" 1) (assert))
    ("4" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "cos_value_strict_decreasing")
   (expand "strict_decreasing?")
   (inst - "pi/6" "pi/2")
   (("1"
     (rewrite "cos_value_pi2")
     (assert)
     (lemma "cos_eqv_sqrt_sin_value" ("q1" "pi/6"))
     (rewrite "sin_value_pi6" -1)
     (expand "sq" -1)
     (lemma "minus_div1" ("x" "1" "n0x" "1" "y" "1" "n0y" "4"))
     (replace -1 -2)
     (rewrite "sqrt_div" -2)
     (lemma "sqrt_sq" ("x" "2"))
     (expand "sq" -1)
     (assert))
    ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z1" "z2"))
   (typepred "z1")
   (typepred "z2")
   (expand ">=")
   (lemma "acos_sum" ("nnx" "cos_value(z1)" "nny" "cos_value(z2)"))
   (("1"
     (rewrite "acos_cos_value" -1)
     (rewrite "acos_cos_value" -1)
     (replace -1 1)
     (rewrite "cos_value_acos")
     (("1"
       (rewrite "sin_eqv_sqrt_cos_value")
       (rewrite "sin_eqv_sqrt_cos_value")
       (assert))
      ("2"
       (hide 2)
       (hide -1)
       (rewrite "sin_eqv_sqrt_cos_value")
       (rewrite "sin_eqv_sqrt_cos_value")
       (lemma "cos_value_decreasing")
       (expand "decreasing?")
       (lemma "sin_value_increasing")
       (expand "increasing?")
       (inst-cp - "0" "z1")
       (("1"
         (inst-cp - "z1" "pi/2")
         (("1"
           (inst-cp - "0" "z2")
           (("1"
             (inst - "z2" "pi/2")
             (("1"
               (rewrite "sin_value_0")
               (rewrite "sin_value_pi2")
               (inst-cp - "0" "z1")
               (inst-cp - "z1" "pi/2")
               (inst-cp - "0" "z2")
               (inst - "z2" "pi/2")
               (rewrite "cos_value_0")
               (rewrite "cos_value_pi2")
               (assert)
               (lemma "le_times_le_pos"
                ("nnx"
                 "0"
                 "y"
                 "cos_value(z1)"
                 "nnz"
                 "0"
                 "w"
                 "cos_value(z2)"))
               (lemma "le_times_le_pos"
                ("nnx"
                 "cos_value(z1)"
                 "y"
                 "1"
                 "nnz"
                 "cos_value(z2)"
                 "w"
                 "1"))
               (lemma "le_times_le_pos"
                ("nnx"
                 "0"
                 "y"
                 "sin_value(z1)"
                 "nnz"
                 "0"
                 "w"
                 "sin_value(z2)"))
               (("1"
                 (lemma "le_times_le_pos"
                  ("nnx"
                   "sin_value(z1)"
                   "y"
                   "1"
                   "nnz"
                   "sin_value(z2)"
                   "w"
                   "1"))
                 (assert)
                 (expand "abs")
                 (case "cos_value(z1) * cos_value(z2) - sin_value(z2) * sin_value(z1) < 0")
                 (("1" (assert)) ("2" (assert))))
                ("2" (expand "abs" 1) (propax))
                ("3" (expand "abs" 1) (propax))))
              ("2" (expand "abs" 1) (assert))
              ("3" (expand "abs" 1) (propax))))
            ("2" (expand "abs" 1) (propax))
            ("3" (expand "abs" 1) (assert))))
          ("2" (expand "abs" 1) (assert))
          ("3" (expand "abs" 1) (propax))))
        ("2" (expand "abs" 1) (propax))
        ("3" (expand "abs" 1) (assert))))))
    ("2"
     (hide 2)
     (lemma "cos_value_decreasing")
     (expand "decreasing?")
     (inst-cp - "0" "z2")
     (inst - "z2" "pi/2")
     (assert)
     (rewrite "cos_value_0")
     (rewrite "cos_value_pi2")
     (assert))
    ("3"
     (lemma "cos_value_decreasing")
     (expand "decreasing?")
     (inst-cp - "0" "z1")
     (inst - "z1" "pi/2")
     (rewrite "cos_value_0")
     (rewrite "cos_value_pi2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("c" "d"))
   (typepred "c")
   (typepred "d")
   (lemma "asin_diff" ("nnx" "sin_value(c)" "nny" "sin_value(d)"))
   (("1"
     (rewrite "asin_sin_value")
     (rewrite "asin_sin_value")
     (rewrite "cos_eqv_sqrt_sin_value")
     (rewrite "cos_eqv_sqrt_sin_value")
     (replace -1 1)
     (rewrite "sin_value_asin")
     (assert))
    ("2"
     (lemma "sin_value_increasing")
     (expand "increasing?")
     (inst-cp - "0" "d")
     (("1"
       (inst - "d" "pi/2")
       (("1" (rewrite "sin_value_0") (rewrite "sin_value_pi2") (assert))
        ("2" (expand "abs") (assert))))
      ("2" (expand "abs") (assert))))
    ("3"
     (lemma "sin_value_increasing")
     (expand "increasing?")
     (inst-cp - "0" "c")
     (("1"
       (inst - "c" "pi/2")
       (("1" (rewrite "sin_value_0") (rewrite "sin_value_pi2") (assert))
        ("2" (expand "abs") (assert))))
      ("2" (expand "abs") (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_value")
   (lemma "deriv_asin_fun")
   (lemma "asin_derivable_fun")
   (case "bijective?[real_abs_lt1,real_abs_lt_pi2](LAMBDA (x:real_abs_lt1): asin(x))")
   (("1"
     (tccs-step
      (case "inverse?[real_abs_lt1, real_abs_lt_pi2]((LAMBDA (x:real_abs_lt_pi2): inverse(asin)(x)),(LAMBDA (x:real_abs_lt1): asin(x)))")
      :label "TCC" :hide? t)
     (("1"
       (lemma "inverse_derivable[real_abs_lt1, real_abs_lt_pi2]"
        ("F"
         "LAMBDA (x: real_abs_lt1): asin(x)"
         "G"
         "LAMBDA (x: real_abs_lt_pi2): inverse(asin)(x)"
         "f"
         "LAMBDA (x: real_abs_lt1): 1 / sqrt(1 - sq(x))"
         "x"
         "x!1"))
       (("1"
         (replace -2 -1)
         (replace -3 -1)
         (replace -4 -1)
         (replace -5 -1)
         (propax))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!2")
         (lemma "sq_lt_abs" ("a" "x!2" "b" "1"))
         (expand "sq" -1 2)
         (expand "abs" -1 2)
         (lemma "sqrt_pos" ("px" "1-sq(x!2)"))
         (("1" (assert)) ("2" (grind))))
        ("3"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!2")
         (lemma "sq_lt_abs" ("a" "x!2" "b" "1"))
         (expand "sq" -1 2)
         (expand "abs" -1 2)
         (lemma "sqrt_pos" ("px" "1-sq(x!2)"))
         (("1" (assert)) ("2" (grind))))
        ("4"
         (hide-all-but 1)
         (reveal "TCC")
         (skeep)
         (inst? -2)
         (flatten)
         (assert))))
      ("2"
       (split)
       (("1"
         (hide -2 -3 2)
         (name "F" "LAMBDA (x: real_abs_lt1): asin(x)")
         (replace -1)
         (name "G" "LAMBDA (x: real_abs_lt_pi2): inverse(asin)(x)")
         (replace -1)
         (expand "inverse?")
         (skosimp*)
         (typepred "r!1")
         (lemma "extensionality[real_abs_lt_pi2,real_abs_lt1]"
          ("f" "inverse[real_abs_lt1,real_abs_lt_pi2](F)" "g" "G"))
         (("1"
           (split -1)
           (("1"
             (replace -1 1 rl)
             (lemma "comp_inverse_right[real_abs_lt1, real_abs_lt_pi2]"
              ("f" "F" "y" "r!1"))
             (("1" (propax)) ("2" (propax))))
            ("2"
             (replace -3 1 rl)
             (replace -4 1 rl)
             (skosimp*)
             (replace -4 -6 rl)
             (hide 2 -1 -2 -3 -4 -5)
             (copy -1)
             (expand "bijective?" -1)
             (flatten)
             (expand "surjective?")
             (inst - "x!2")
             (skosimp*)
             (typepred "x!2")
             (typepred "x!3")
             (lemma "asin_bij")
             (lemma "comp_inverse_left[real_abs_le1, real_abs_le_pi2]"
              ("f" "asin" "x" "x!3"))
             (("1"
               (lemma "bijective_inverse[real_abs_lt1, real_abs_lt_pi2]"
                ("f"
                 "LAMBDA (x: real_abs_lt1): asin(x)"
                 "x"
                 "x!3"
                 "y"
                 "x!2"))
               (("1" (simplify 1) (assert)) ("2" (propax))))
              ("2" (propax))))))
          ("2"
           (hide -1 -2 -4 -5 2)
           (skosimp*)
           (typepred "x1!1")
           (lemma "sin_value_strict_increasing")
           (expand "strict_increasing?")
           (inst-cp - "x1!1" "pi/2")
           (inst-cp - "-pi/2" "x1!1")
           (case "x1!1<0")
           (("1"
             (assert)
             (rewrite "sin_value_pi2")
             (rewrite "sin_value_minus_pi2")
             (inst - "x1!1" "0")
             (assert)
             (rewrite "sin_value_0")
             (expand "sin_value")
             (assert)
             (replace -7 1 rl)
             (assert))
            ("2"
             (assert)
             (case "x1!1=0")
             (("1"
               (replace -1)
               (lemma "sin_value_0")
               (expand "sin_value" -1)
               (replace -8 + rl)
               (assert))
              ("2"
               (inst - "0" "x1!1")
               (rewrite "sin_value_0")
               (assert)
               (rewrite "sin_value_pi2")
               (rewrite "sin_value_minus_pi2")
               (expand "sin_value")
               (replace -6 + rl)
               (assert))))))))
        ("2"
         (hide -2 -3 2)
         (skosimp*)
         (typepred "x!2")
         (hide -2)
         (lemma "asin_bij")
         (lemma
          "bijective_inverse_is_bijective[real_abs_le1,real_abs_le_pi2]"
          ("f" "asin"))
         (("1"
           (lemma "sin_value_strict_increasing")
           (expand "strict_increasing?")
           (inst-cp - "-pi/2" "x!2")
           (inst-cp - "x!2" "pi/2")
           (case "x!2<0")
           (("1"
             (assert)
             (inst - "x!2" "0")
             (assert)
             (rewrite "sin_value_0")
             (rewrite "sin_value_pi2")
             (rewrite "sin_value_minus_pi2")
             (expand "sin_value")
             (assert))
            ("2"
             (case "x!2=0")
             (("1"
               (replace -1)
               (lemma "sin_value_0")
               (expand "sin_value" -1)
               (assert))
              ("2"
               (inst - "0" "x!2")
               (rewrite "sin_value_0")
               (rewrite "sin_value_pi2")
               (rewrite "sin_value_minus_pi2")
               (expand "sin_value" (-1 -2 -3))
               (assert))))))
          ("2" (propax))))))))
    ("2"
     (hide-all-but 1)
     (lemma "asin_bij")
     (expand "bijective?")
     (expand "injective?")
     (expand "surjective?")
     (flatten)
     (split)
     (("1" (skosimp*) (inst -2 "x1!1" "x2!1") (assert))
      ("2"
       (hide -1)
       (skosimp*)
       (inst - "y!1")
       (skosimp*)
       (typepred "x!2")
       (expand "<=" -1)
       (split -1)
       (("1"
         (expand "<=" -2)
         (split -2)
         (("1" (inst + "x!2") (assert))
          ("2" (replace -1) (rewrite "asin_1") (assert))))
        ("2"
         (typepred "y!1")
         (case "x!2 = 1 OR x!2 = -1")
         (("1"
           (hide -3)
           (split -1)
           (("1" (replace -1) (rewrite "asin_1") (assert))
            ("2" (replace -1) (rewrite "asin_minus1") (assert))))
          ("2" (assert))))))))
    ("3"
     (hide-all-but 1)
     (skosimp*)
     (typepred "x!2")
     (lemma "asin_bij")
     (expand "bijective?")
     (expand "injective?")
     (expand "surjective?")
     (flatten)
     (hide -2)
     (lemma "asin_strict_increasing")
     (expand "strict_increasing?")
     (case "x!2<0")
     (("1"
       (assert)
       (inst-cp -2 "-x!2" "1")
       (inst-cp -2 "x!2" "0")
       (rewrite "asin_0")
       (rewrite "asin_1")
       (rewrite "asin_neg")
       (assert))
      ("2"
       (assert)
       (case "x!2 = 0")
       (("1" (replace -1) (rewrite "asin_0") (assert))
        ("2"
         (inst-cp -1 "0" "x!2")
         (inst -1 "x!2" "1")
         (assert)
         (rewrite "asin_1")
         (rewrite "asin_0")
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "asin_derivable_fun")
   (lemma "deriv_asin_fun")
   (case "bijective?[real_abs_lt1,real_abs_lt_pi2](LAMBDA (x: real_abs_lt1): asin(x))")
   (("1"
     (tccs-step
      (case "inverse?[real_abs_lt1, real_abs_lt_pi2]((LAMBDA (x:real_abs_lt_pi2): sin_value(x)),(LAMBDA (x: real_abs_lt1): asin(x)))")
      :label "TCC" :hide? t)
     (("1"
       (lemma "deriv_inverse_fun[real_abs_lt1, real_abs_lt_pi2]"
        ("F"
         "LAMBDA (x: real_abs_lt1): asin(x)"
         "G"
         "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"
         "f"
         "LAMBDA (x: real_abs_lt1): 1 / sqrt(1 - sq(x))"))
       (("1"
         (replace -2 -1)
         (replace -3 -1)
         (replace -4 -1)
         (replace -5 -1)
         (replace -1 1)
         (lemma "extensionality"
          ("f"
           "(LAMBDA (x_1: real_abs_lt_pi2):
                                               1 /
                                                (LAMBDA (x: real_abs_lt1): 1 / sqrt(1 - sq(x)))
                                                    ((LAMBDA (x: real_abs_lt_pi2): sin_value(x))(x_1)))"
           "g"
           "(LAMBDA (x: real_abs_lt_pi2):
                                                IF x < 0 THEN cos_value(-x) ELSE cos_value(x) ENDIF)"))
         (("1"
           (split -1)
           (("1"
             (lemma "extensionality"
              ("f"
               "LAMBDA (x: real_abs_lt_pi2): IF x < 0 THEN cos_value(-x) ELSE cos_value(x) ENDIF"
               "g"
               "LAMBDA (x: real_abs_lt_pi2): cos_value(abs(x))"))
             (("1"
               (split -1)
               (("1" (replace -1 1 rl) (propax))
                ("2"
                 (skosimp*)
                 (hide-all-but 1)
                 (expand "abs")
                 (propax))))
              ("2"
               (skosimp*)
               (hide-all-but 1)
               (typepred "x!1")
               (expand "abs")
               (case "x!1<0")
               (("1" (assert)) ("2" (assert))))
              ("3" (skosimp*) (assert)) ("4" (skosimp*) (assert))))
            ("2"
             (hide 2)
             (skosimp*)
             (hide-all-but 1)
             (typepred "x!1")
             (case "abs(sin_value(x!1)) < 1")
             (("1"
               (lemma "sq_lt_abs" ("a" "sin_value(x!1)" "b" "1"))
               (expand "abs" -1 2)
               (expand "sq" -1 2)
               (replace -1 -2 rl)
               (typepred "sq(sin_value(x!1))")
               (lemma "sqrt_pos" ("px" "1-sq(sin_value(x!1))"))
               (("1"
                 (rewrite "div_div1" 1)
                 (lemma "trichotomy" ("x" "x!1"))
                 (split -1)
                 (("1" (rewrite "cos_eqv_sqrt_sin_value") (assert))
                  ("2"
                   (replace -1)
                   (rewrite "cos_value_0")
                   (rewrite "sin_value_0")
                   (expand "sq" 1)
                   (rewrite "sqrt_1"))
                  ("3"
                   (lemma "sin_value_neg" ("xs" "-x!1"))
                   (replace -1 1)
                   (hide -1)
                   (rewrite "sq_neg" 1)
                   (rewrite "cos_eqv_sqrt_sin_value" 1)
                   (assert))))
                ("2" (assert))))
              ("2"
               (hide 2)
               (lemma "sin_value_strict_increasing")
               (expand "strict_increasing?")
               (expand "abs")
               (lemma "trichotomy" ("x" "x!1"))
               (split -1)
               (("1"
                 (inst-cp - "0" "x!1")
                 (rewrite "sin_value_0")
                 (assert)
                 (inst - "x!1" "pi/2")
                 (rewrite "sin_value_pi2")
                 (assert))
                ("2" (replace -1) (rewrite "sin_value_0") (assert))
                ("3"
                 (inst-cp - "x!1" "0")
                 (rewrite "sin_value_0")
                 (assert)
                 (inst - "-pi/2" "x!1")
                 (rewrite "sin_value_minus_pi2")
                 (assert))))))))
          ("2" (hide-all-but 1) (skosimp*) (typepred "x!1") (assert))
          ("3" (hide-all-but 1) (skosimp*) (typepred "x!1") (assert))
          ("4"
           (hide-all-but 1)
           (skosimp*)
           (lemma "sq_lt_abs" ("a" "sin_value(x!1)" "b" "1"))
           (expand "abs" -1 2)
           (expand "sq" -1 2)
           (ground)
           (grind))
          ("5"
           (hide-all-but 1)
           (skosimp*)
           (assert)
           (typepred "x!2")
           (hide -3)
           (grind)
           (mult-ineq -2 -2)
           (("1" (assert)) ("2" (lift-if) (ground))))
          ("6"
           (hide-all-but 1)
           (reveal "TCC")
           (skosimp)
           (inst? -2)
           (flatten)
           (assert))))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!1")
         (lemma "pi_bnds")
         (flatten)
         (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
         (expand "abs" -1 2)
         (expand "sq" -1 2)
         (lemma "sqrt_pos" ("px" "1-sq(x!1)"))
         (("1"
           (typepred "sq(x!1)")
           (lemma "sqrt_le" ("nny" "1-sq(x!1)" "nnz" "1"))
           (("1" (rewrite "sqrt_1") (assert)) ("2" (assert))))
          ("2" (assert) (expand "abs") (lift-if) (ground))))
        ("3"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!1")
         (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
         (expand "abs" -1 2)
         (expand "sq" -1 2)
         (lemma "sqrt_pos" ("px" "1-sq(x!1)"))
         (("1" (assert))
          ("2" (assert) (expand "abs") (lift-if) (ground))))
        ("4"
         (hide-all-but 1)
         (reveal "TCC")
         (skosimp*)
         (inst? -2)
         (flatten)
         (assert))))
      ("2"
       (split)
       (("1"
         (hide -2 -3 2)
         (expand "inverse?")
         (skosimp*)
         (typepred "r!1")
         (typepred "d!1")
         (lemma "extensionality"
          ("f"
           "inverse[real_abs_lt1, real_abs_lt_pi2](LAMBDA (x: real_abs_lt1): asin(x))"
           "g"
           "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
         (split -1)
         (("1"
           (lemma "comp_inverse_right[real_abs_lt1, real_abs_lt_pi2]"
            ("f" "LAMBDA (x: real_abs_lt1): asin(x)" "y" "r!1"))
           (("1" (replace -2 -1) (simplify -1) (propax)) ("2" (propax))))
          ("2"
           (hide 2)
           (skosimp*)
           (expand "sin_value")
           (lemma "bijective_inverse[real_abs_lt1, real_abs_lt_pi2]"
            ("f"
             "LAMBDA (x: real_abs_lt1): asin(x)"
             "y"
             "x!1"
             "x"
             "inverse(asin)(x!1)"))
           (("1"
             (replace -1 1)
             (simplify 1)
             (lemma "asin_bij")
             (lemma "comp_inverse_right[real_abs_le1, real_abs_le_pi2]"
              ("f" "asin" "y" "x!1"))
             (("1" (assert)) ("2" (propax))))
            ("2" (propax))
            ("3"
             (hide 2 -1 -2 -3 -4)
             (typepred "x!1")
             (lemma "sin_value_strict_increasing")
             (expand "strict_increasing?")
             (case "abs(sin_value(x!1)) < 1")
             (("1" (expand "sin_value" -1) (ground))
              ("2"
               (hide 2)
               (expand "abs")
               (lemma "trichotomy" ("x" "x!1"))
               (split -1)
               (("1"
                 (inst-cp - "0" "x!1")
                 (rewrite "sin_value_0")
                 (assert)
                 (inst - "x!1" "pi/2")
                 (rewrite "sin_value_pi2")
                 (assert))
                ("2" (replace -1) (rewrite "sin_value_0") (assert))
                ("3"
                 (inst-cp - "x!1" "0")
                 (rewrite "sin_value_0")
                 (assert)
                 (assert)
                 (inst - "-pi/2" "x!1")
                 (assert)
                 (rewrite "sin_value_minus_pi2")
                 (assert))))))))))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!1")
         (lemma "sin_value_strict_increasing")
         (expand "strict_increasing?")
         (lemma "trichotomy" ("x" "x!1"))
         (split -1)
         (("1"
           (inst-cp - "0" "x!1")
           (rewrite "sin_value_0")
           (assert)
           (inst - "x!1" "pi/2")
           (rewrite "sin_value_pi2")
           (assert))
          ("2" (replace -1) (rewrite "sin_value_0") (assert))
          ("3"
           (inst-cp - "x!1" "0")
           (rewrite "sin_value_0")
           (assert)
           (inst - "-pi/2" "x!1")
           (assert)
           (rewrite "sin_value_minus_pi2"))))))))
    ("2"
     (hide -1 -2 2)
     (lemma "asin_bij")
     (expand "bijective?")
     (expand "injective?")
     (expand "surjective?")
     (flatten)
     (split)
     (("1" (skosimp*) (inst -2 "x1!1" "x2!1") (assert))
      ("2"
       (hide -1)
       (skosimp*)
       (inst - "y!1")
       (typepred "y!1")
       (skosimp*)
       (typepred "x!1")
       (case-replace "abs(x!1) = 1")
       (("1" (grind)) ("2" (inst + "x!1") (grind))))))
    ("3"
     (hide -1 -2 2)
     (skosimp*)
     (typepred "x!1")
     (lemma "asin_strict_increasing")
     (expand "strict_increasing?")
     (lemma "trichotomy" ("x" "x!1"))
     (split -1)
     (("1"
       (inst-cp - "0" "x!1")
       (rewrite "asin_0")
       (assert)
       (inst - "x!1" "1")
       (rewrite "asin_1")
       (assert))
      ("2" (replace -1) (rewrite "asin_0") (assert) (assert))
      ("3"
       (inst-cp - "x!1" "0")
       (rewrite "asin_0")
       (assert)
       (inst - "-1" "x!1")
       (rewrite "asin_minus1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z1" "z2"))
   (case "FORALL (q1,q2:nnreal_quad1_closed): q1<pi/2-q2 => sin_value(q1+q2) = sin_value(q1)*cos_value(q2)+cos_value(q1)*sin_value(q2)")
   (("1"
     (lemma "trich_lt" ("x" "z1" "y" "pi/2-z2"))
     (split -1)
     (("1" (inst - "z1" "z2") (assert))
      ("2"
       (hide -2)
       (replace -1)
       (rewrite "sin_value_pi2")
       (lemma "sin_eqv_cos_quad" ("q1" "z2"))
       (lemma "cos_eqv_sin_quad" ("q1" "z2"))
       (lemma "sin2_cos2_value" ("q1" "z2"))
       (replace -2 * rl)
       (replace -3 * rl)
       (rewrite "sq_rew" 1)
       (rewrite "sq_rew" 1)
       (assert))
      ("3"
       (inst - "pi/2-z2" "pi/2-z1")
       (assert)
       (lemma "sin_eqv_cos_quad" ("q1" "z1"))
       (lemma "sin_eqv_cos_quad" ("q1" "z2"))
       (lemma "cos_eqv_sin_quad" ("q1" "z1"))
       (lemma "cos_eqv_sin_quad" ("q1" "z2"))
       (replace -1 * rl)
       (replace -2 * rl)
       (replace -3 * rl)
       (replace -4 * rl)
       (replace -6 1 rl)
       (hide -1 -2 -3 -4 -6)
       (rewrite "sin_eqv_cos_quad"))))
    ("2"
     (hide 2)
     (skolem 1 ("b" "c"))
     (flatten)
     (typepred "b")
     (expand ">=")
     (expand "<=")
     (split -1)
     (("1"
       (split -2)
       (("1"
         (typepred "c")
         (expand ">=")
         (expand "<=")
         (split -1)
         (("1"
           (split -2)
           (("1"
             (case "FORALL (b, c: {x: posreal | x < pi / 2}):
                                                                              c < pi / 4 & b < pi / 2 - c =>
                                                                               sin_value(b + c) =
                                                                                sin_value(b) * cos_value(c) + cos_value(b) * sin_value(c)")
             (("1"
               (lemma "trich_lt" ("x" "c" "y" "pi/4"))
               (split -1)
               (("1"
                 (inst - "b" "c")
                 (("1" (assert)) ("2" (assert)) ("3" (assert))))
                ("2"
                 (replace -1)
                 (hide -1 -2 -3 -4 -5)
                 (lemma "cos_eqv_sin_quad" ("q1" "b"))
                 (replace -1)
                 (hide -1)
                 (case "pi/2-pi/4 = pi/4")
                 (("1"
                   (replace -1)
                   (hide -1)
                   (lemma "identity_derivable_fun[{x:posreal|x<pi/4}]")
                   (lemma "deriv_id_fun[{x:posreal|x<pi/4}]")
                   (expand "I")
                   (lemma
                    "const_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("b" "pi/4"))
                   (lemma
                    "const_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("b" "pi/2"))
                   (lemma "deriv_const_fun[{x: posreal | x < pi / 4}]"
                    ("b" "pi/4"))
                   (lemma "deriv_const_fun[{x: posreal | x < pi / 4}]"
                    ("b" "pi/2"))
                   (lemma "sum_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("f1"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): x"
                     "f2"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi / 4"))
                   (lemma "diff_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("f2"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): x"
                     "f1"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi / 2"))
                   (assert)
                   (expand "-")
                   (expand "+")
                   (lemma "deriv_sum_fun[{x: posreal | x < pi / 4}]"
                    ("ff1"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): x"
                     "ff2"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi / 4"))
                   (lemma "deriv_diff_fun[{x: posreal | x < pi / 4}]"
                    ("ff2"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): x"
                     "ff1"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi / 2"))
                   (replace -9)
                   (replace -5)
                   (replace -6)
                   (expand "-")
                   (expand "+")
                   (hide -5 -6 -7 -8)
                   (lemma "sin_value_derivable_fun")
                   (lemma "deriv_sin_value")
                   (lemma
                    "composition_derivable_fun[{x: posreal | x < pi / 4},real_abs_lt_pi2]"
                    ("f"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): x"
                     "g"
                     "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                   (lemma
                    "composition_derivable_fun[{x: posreal | x < pi / 4},real_abs_lt_pi2]"
                    ("f"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi/2-x"
                     "g"
                     "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                   (lemma
                    "composition_derivable_fun[{x: posreal | x < pi / 4},real_abs_lt_pi2]"
                    ("f"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi/4+x"
                     "g"
                     "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                   (assert)
                   (expand "o")
                   (lemma
                    "deriv_comp_fun[{x: posreal | x < pi / 4},real_abs_lt_pi2]"
                    ("ff"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): x"
                     "gg"
                     "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                   (lemma
                    "deriv_comp_fun[{x: posreal | x < pi / 4},real_abs_lt_pi2]"
                    ("ff"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi/2-x"
                     "gg"
                     "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                   (lemma
                    "deriv_comp_fun[{x: posreal | x < pi / 4},real_abs_lt_pi2]"
                    ("ff"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): pi/4+x"
                     "gg"
                     "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                   (replace -7)
                   (replace -13)
                   (replace -9)
                   (replace -10)
                   (expand "o")
                   (expand "*")
                   (hide -7 -8 -9 -10 -11 -12 -13 -14)
                   (lemma "scal_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("f"
                     "LAMBDA (x_1: {x: posreal | x < pi / 4}): sin_value(pi / 2 - x_1)"
                     "b"
                     "sin_value(pi / 4)"))
                   (lemma "scal_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("f"
                     "LAMBDA (x_1: {x: posreal | x < pi / 4}): sin_value(x_1)"
                     "b"
                     "cos_value(pi / 4)"))
                   (assert)
                   (expand "*" (-1 -2))
                   (lemma "deriv_scal_fun[{x: posreal | x < pi / 4}]"
                    ("ff"
                     "LAMBDA (x_1: {x: posreal | x < pi / 4}): sin_value(pi / 2 - x_1)"
                     "b"
                     "sin_value(pi / 4)"))
                   (lemma "deriv_scal_fun[{x: posreal | x < pi / 4}]"
                    ("ff"
                     "LAMBDA (x_1: {x: posreal | x < pi / 4}): sin_value(x_1)"
                     "b"
                     "cos_value(pi / 4)"))
                   (expand "*")
                   (replace -7)
                   (replace -6)
                   (simplify (-1 -2))
                   (lemma "sum_derivable_fun[{x: posreal | x < pi / 4}]"
                    ("f1"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): sin_value(pi / 4) * sin_value(pi / 2 - x)"
                     "f2"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): cos_value(pi / 4) * sin_value(x)"))
                   (assert)
                   (expand "+")
                   (lemma "deriv_sum_fun[{x: posreal | x < pi / 4}]"
                    ("ff1"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): sin_value(pi / 4) * sin_value(pi / 2 - x)"
                     "ff2"
                     "LAMBDA (x: {x: posreal | x < pi / 4}): cos_value(pi / 4) * sin_value(x)"))
                   (replace -3)
                   (replace -4)
                   (expand "+" -1)
                   (lemma "derivs_eq[{x: posreal | x < pi / 4}]"
                    ("F"
                     "LAMBDA (x_1: {x: posreal | x < pi / 4}):
                                                                                                                  cos_value(pi / 4) * sin_value(x_1) +
                                                                                                                   sin_value(pi / 4) * sin_value(pi / 2 - x_1)"
                     "G"
                     "LAMBDA (x_1: {x: posreal | x < pi / 4}):
                                                                                                                  sin_value(x_1 + pi / 4)"))
                   (("1"
                     (assert)
                     (replace -2)
                     (replace -8)
                     (split -1)
                     (("1"
                       (hide-all-but (1 -14 -15 -1))
                       (skosimp*)
                       (lemma "extensionality_postulate"
                        ("f"
                         "(LAMBDA (x_1: {x: posreal | x < pi / 4}):
                                                                                                                             cos_value(pi / 4) * sin_value(x_1) +
                                                                                                                              sin_value(pi / 4) * sin_value(pi / 2 - x_1))"
                         "g"
                         "(LAMBDA (x_1: {x: posreal | x < pi / 4}): sin_value(x_1 + pi / 4)) +
                                                                                                                            const_fun(c!1)"))
                       (replace -1 -2 rl)
                       (hide -1)
                       (expand "+" -1)
                       (expand "const_fun")
                       (inst-cp - "b")
                       (inst - "pi/6")
                       (rewrite "cos_value_pi4")
                       (rewrite "sin_value_pi4")
                       (lemma "cos_eqv_sin_quad" ("q1" "pi/6"))
                       (replace -1 -2 rl)
                       (hide -1)
                       (rewrite "sin_value_pi6" -1)
                       (rewrite "cos_value_pi6" -1)
                       (case "sqrt(1 / 2) * (1+sqrt(3)) / 2 = sin_value(5*pi / 12)")
                       (("1" (replace -1 -2 rl) (assert))
                        ("2"
                         (hide-all-but 1)
                         (lemma "cos_eqv_sin_quad" ("q1" "pi/12"))
                         (replace -1 1 rl)
                         (hide -1)
                         (lemma "sq_eq"
                          ("nna"
                           "sqrt(1 / 2) * (1 + sqrt(3)) / 2"
                           "nnb"
                           "cos_value(pi / 12)"))
                         (("1"
                           (replace -1 1 rl)
                           (hide -1)
                           (lemma "sq_div"
                            ("a" "sqrt(1 / 2) * (1 + sqrt(3))" "d" "2"))
                           (lemma "sq_times"
                            ("a" "sqrt(1 / 2)" "b" "1 + sqrt(3)"))
                           (rewrite "sq_sqrt" -1)
                           (replace -1 -2)
                           (split -2)
                           (("1"
                             (replace -1 1)
                             (hide -1 -2)
                             (lemma "cos_value_sum"
                              ("q1" "pi/12" "q2" "pi/12"))
                             (rewrite "cos_value_pi6")
                             (rewrite "sq_rew")
                             (rewrite "sq_rew")
                             (lemma "sin2_cos2_value" ("q1" "pi/12"))
                             (case "1+sqrt(3)/2 = 2*sq(cos_value(pi / 12))")
                             (("1"
                               (case "1 / 2 * sq(1 + sqrt(3)) / sq(2) = 1/2+sqrt(3)/4")
                               (("1" (replace -1 1) (assert))
                                ("2"
                                 (hide-all-but 1)
                                 (expand "sq")
                                 (rewrite "sq_rew")
                                 (assert))))
                              ("2" (hide 2) (assert))))
                            ("2" (assert))))
                          ("2"
                           (lemma "cos_value_strict_decreasing")
                           (hide 2)
                           (expand "strict_decreasing?")
                           (inst - "pi/12" "pi/2")
                           (rewrite "cos_value_pi2")
                           (assert))))))
                      ("2"
                       (hide-all-but 1)
                       (lemma "extensionality"
                        ("f"
                         "(LAMBDA (x_1: {x: posreal | x < pi / 4}):
                                                                                                                             cos_value(pi / 4) * cos_value(abs(x_1)) +
                                                                                                                              sin_value(pi / 4) * (cos_value(abs(pi / 2 - x_1)) * -1))"
                         "g"
                         "(LAMBDA (x: {x: posreal | x < pi / 4}): cos_value(abs(x + pi / 4)))"))
                       (("1"
                         (split -1)
                         (("1" (assert))
                          ("2"
                           (hide 2)
                           (skosimp*)
                           (expand "abs")
                           (lemma "sin_eqv_cos_quad" ("q1" "x!1"))
                           (replace -1 1 rl)
                           (lemma "cos_value_sum"
                            ("q1" "pi/4" "q2" "x!1"))
                           (assert))))
                        ("2" (expand "abs" 1) (propax))
                        ("3" (expand "abs" 1) (propax))
                        ("4" (expand "abs" 1) (propax))))))
                    ("2" (inst + "pi/8"))
                    ("3" (expand "connected?") (skosimp*) (assert))))
                  ("2" (assert))))
                ("3"
                 (inst - "c" "b")
                 (("1" (assert)) ("2" (assert)) ("3" (assert))))))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (lemma "identity_derivable_fun[{x:posreal|x<pi/2-c!1}]")
               (("1"
                 (lemma "deriv_id_fun[{x:posreal|x<pi/2-c!1}]")
                 (expand "I")
                 (lemma "const_derivable_fun[{x:posreal|x<pi/2-c!1}]"
                  ("b" "pi/2"))
                 (lemma "const_derivable_fun[{x:posreal|x<pi/2-c!1}]"
                  ("b" "c!1"))
                 (lemma "deriv_const_fun[{x:posreal|x<pi/2-c!1}]"
                  ("b" "pi/2"))
                 (lemma "deriv_const_fun[{x:posreal|x<pi/2-c!1}]"
                  ("b" "c!1"))
                 (lemma
                  "sum_derivable_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("f1"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x"
                   "f2"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): c!1"))
                 (lemma
                  "diff_derivable_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("f2"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x"
                   "f1"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): pi/2"))
                 (assert)
                 (expand "-")
                 (expand "+")
                 (lemma "deriv_sum_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("ff1"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x"
                   "ff2"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): c!1"))
                 (lemma "deriv_diff_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("ff2"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x"
                   "ff1"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): pi/2"))
                 (replace -5)
                 (replace -6)
                 (replace -9)
                 (expand "-")
                 (expand "+")
                 (hide -5 -6 -7 -8)
                 (lemma "sin_value_derivable_fun")
                 (lemma "deriv_sin_value")
                 (lemma
                  "composition_derivable_fun[{x: posreal | x < pi / 2 - c!1},real_abs_lt_pi2]"
                  ("f"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x"
                   "g"
                   "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                 (lemma
                  "composition_derivable_fun[{x: posreal | x < pi / 2 - c!1},real_abs_lt_pi2]"
                  ("f"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x+c!1"
                   "g"
                   "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                 (lemma
                  "composition_derivable_fun[{x: posreal | x < pi / 2 - c!1},real_abs_lt_pi2]"
                  ("f"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): pi/2-x"
                   "g"
                   "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                 (expand "o")
                 (assert)
                 (lemma
                  "deriv_comp_fun[{x: posreal | x < pi / 2 - c!1},real_abs_lt_pi2]"
                  ("ff"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x"
                   "gg"
                   "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                 (lemma
                  "deriv_comp_fun[{x: posreal | x < pi / 2 - c!1},real_abs_lt_pi2]"
                  ("ff"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): x+c!1"
                   "gg"
                   "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                 (lemma
                  "deriv_comp_fun[{x: posreal | x < pi / 2 - c!1},real_abs_lt_pi2]"
                  ("ff"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}): pi/2-x"
                   "gg"
                   "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
                 (expand "o")
                 (replace -13)
                 (replace -10)
                 (replace -9)
                 (replace -7)
                 (expand "*")
                 (hide -7 -8 -9 -10 -11 -12 -12 -14)
                 (lemma "cos_eqv_sin_quad" ("q1" "b!1"))
                 (replace -1 1)
                 (hide -1)
                 (lemma
                  "scal_derivable_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("f"
                   "LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                              sin_value(pi / 2 - x_1)"
                   "b"
                   "sin_value(c!1)"))
                 (lemma
                  "scal_derivable_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("f"
                   "LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                sin_value(x_1)"
                   "b"
                   "cos_value(c!1)"))
                 (assert)
                 (lemma "deriv_scal_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("ff"
                   "LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  sin_value(pi / 2 - x_1)"
                   "b"
                   "sin_value(c!1)"))
                 (lemma "deriv_scal_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("ff"
                   "LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  sin_value(x_1)"
                   "b"
                   "cos_value(c!1)"))
                 (replace -5)
                 (expand "*")
                 (replace -7)
                 (simplify (-1 -2))
                 (hide -5 -7 -8 -10 -11)
                 (lemma
                  "sum_derivable_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("f1"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  sin_value(c!1) * sin_value(pi / 2 - x)"
                   "f2"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  cos_value(c!1) * sin_value(x)"))
                 (assert)
                 (expand "+")
                 (lemma "deriv_sum_fun[{x: posreal | x < pi / 2 - c!1}]"
                  ("ff1"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  sin_value(c!1) * sin_value(pi / 2 - x)"
                   "ff2"
                   "LAMBDA (x: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  cos_value(c!1) * sin_value(x)"))
                 (replace -4)
                 (replace -3)
                 (expand "+")
                 (lemma "derivs_eq[{x: posreal | x < pi / 2 - c!1}]"
                  ("F"
                   "LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  sin_value(x_1 + c!1)"
                   "G"
                   "LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                  cos_value(c!1) * sin_value(x_1) +
                                                                                                   sin_value(c!1) * sin_value(pi / 2 - x_1)"))
                 (("1"
                   (split -1)
                   (("1"
                     (hide -2 -3 -4 -5 -6 -7 -8 -9)
                     (skolem - ("K"))
                     (expand "const_fun")
                     (expand "+")
                     (lemma "extensionality_postulate"
                      ("f"
                       "(LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}): sin_value(x_1 + c!1))"
                       "g"
                       "(LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                              K + cos_value(c!1) * sin_value(x_1) +
                                                                                                               sin_value(c!1) * sin_value(pi / 2 - x_1))"))
                     (replace -1 -2 rl)
                     (hide -1)
                     (inst-cp - "b!1")
                     (inst - "pi/4")
                     (rewrite "sin_value_pi4")
                     (replace -2 1)
                     (case "K=0")
                     (("1" (assert))
                      ("2"
                       (hide 2 -2 -4)
                       (lemma "cos_eqv_sqrt_sin_value" ("q1" "c!1"))
                       (replace -1 -2 rl)
                       (case "sin_value(pi / 4 + c!1) = (sqrt(1 - sq(sin_value(c!1))) + sin_value(c!1)) * sqrt(1 / 2)")
                       (("1" (assert))
                        ("2"
                         (hide -2 2)
                         (case "sqrt(1 - sq(sin_value(c!1))) + sin_value(c!1) < sqrt(2)")
                         (("1"
                           (lemma "both_sides_times_pos_lt1"
                            ("x"
                             "sqrt(1 - sq(sin_value(c!1))) + sin_value(c!1)"
                             "y"
                             "sqrt(2)"
                             "pz"
                             "sqrt(1/2)"))
                           (lemma "sqrt_times" ("nny" "2" "nnz" "1/2"))
                           (lemma "div_cancel1" ("x" "1" "n0z" "2"))
                           (replace -1)
                           (rewrite "sqrt_1")
                           (replace -2 -3 rl)
                           (replace -3 -4 rl)
                           (hide -1 -2 -3)
                           (lemma "asin_bij")
                           (expand "bijective?")
                           (expand "injective?")
                           (flatten -1)
                           (inst - "sin_value(pi / 4 + c!1)"
                            "(sqrt(1 - sq(sin_value(c!1))) + sin_value(c!1)) * sqrt(1 / 2)")
                           (("1"
                             (split -1)
                             (("1" (propax))
                              ("2"
                               (hide 2)
                               (rewrite "asin_sin_value" 1)
                               (expand "asin" 1)
                               (assert)
                               (replace -3)
                               (lemma "sin_value_strict_increasing")
                               (lemma "cos_value_strict_decreasing")
                               (expand "strict_decreasing?")
                               (expand "strict_increasing?")
                               (inst - "c!1" "pi/2")
                               (inst - "0" "c!1")
                               (rewrite "cos_value_pi2")
                               (rewrite "sin_value_0")
                               (assert)
                               (lemma "posreal_times_posreal_is_posreal"
                                ("px"
                                 "cos_value(c!1) + sin_value(c!1)"
                                 "py"
                                 "sqrt(1 / 2)"))
                               (assert)
                               (rewrite "sq_rew" 1)
                               (rewrite "sq_rew" 1)
                               (lemma "atan_plus"
                                ("x"
                                 "1"
                                 "y"
                                 "sin_value(c!1)/cos_value(c!1)"))
                               (flatten -1)
                               (hide -2 -3)
                               (split -1)
                               (("1"
                                 (case
                                  "atan(sin_value(c!1) / cos_value(c!1)) = c!1")
                                 (("1"
                                   (replace -1)
                                   (case "atan(1) = pi/4")
                                   (("1"
                                     (replace -1)
                                     (case
                                      "((cos_value(c!1) * sqrt(1 / 2) + sin_value(c!1) * sqrt(1 / 2)) /
                                                                                                                                                                                                                                 sqrt(1 - sq(cos_value(c!1)) * sqrt(1 / 2) * sqrt(1 / 2) -
                                                                                                                                                                                                                                       sq(sin_value(c!1)) * sqrt(1 / 2) * sqrt(1 / 2)
                                                                                                                                                                                                                                       -
                                                                                                                                                                                                                                       2 *
                                                                                                                                                                                                                                        (cos_value(c!1) * sin_value(c!1) * sqrt(1 / 2) *
                                                                                                                                                                                                                                          sqrt(1 / 2))))=((1 + sin_value(c!1) / cos_value(c!1)) /
                                                                                                                                                                                                                                 (1 - 1 * (sin_value(c!1) / cos_value(c!1))))")
                                     (("1" (replace -1) (propax))
                                      ("2"
                                       (hide 2)
                                       (lemma
                                        "cross_mult"
                                        ("x"
                                         "(cos_value(c!1) + sin_value(c!1)) * sqrt(1 / 2)"
                                         "n0x"
                                         "sqrt(1 - sq(cos_value(c!1)) * (sqrt(1 / 2) * sqrt(1 / 2)) -
                                                                                                                                                                                                                                                 sq(sin_value(c!1)) * (sqrt(1 / 2) * sqrt(1 / 2))
                                                                                                                                                                                                                                                 -
                                                                                                                                                                                                                                                 2 *
                                                                                                                                                                                                                                                  (cos_value(c!1) * sin_value(c!1) * (sqrt(1 / 2) *
                                                                                                                                                                                                                                                    sqrt(1 / 2))))"
                                         "y"
                                         "1 + sin_value(c!1) / cos_value(c!1)"
                                         "n0y"
                                         "1 - sin_value(c!1) / cos_value(c!1)"))
                                       (("1"
                                         (replace -1 1)
                                         (hide -1 -2 -3 -4)
                                         (rewrite "sq_rew" 1)
                                         (lemma
                                          "sin2_cos2_value"
                                          ("q1" "c!1"))
                                         (case
                                          "1 - sq(cos_value(c!1)) * (1 / 2) -
                                                                                                                                                                                                                                                       sq(sin_value(c!1)) * (1 / 2)
                                                                                                                                                                                                                                                       - 2 * (cos_value(c!1) * sin_value(c!1) * (1 / 2)) = sq((cos_value(c!1)-sin_value(c!1))*sqrt(1/2))")
                                         (("1"
                                           (replace -1 1)
                                           (rewrite "sqrt_sq" 1)
                                           (("1" (assert))
                                            ("2"
                                             (hide 2)
                                             (lemma
                                              "posreal_times_posreal_is_posreal"
                                              ("px"
                                               "cos_value(c!1) - sin_value(c!1)"
                                               "py"
                                               "sqrt(1 / 2)"))
                                             (("1" (assert))
                                              ("2"
                                               (lemma
                                                "sin_value_strict_increasing")
                                               (lemma
                                                "cos_value_strict_decreasing")
                                               (expand
                                                "strict_decreasing?")
                                               (expand
                                                "strict_increasing?")
                                               (hide 2)
                                               (inst - "c!1" "pi/4")
                                               (inst - "c!1" "pi/4")
                                               (rewrite "cos_value_pi4")
                                               (rewrite "sin_value_pi4")
                                               (assert))))))
                                          ("2"
                                           (hide 2)
                                           (rewrite "sq_times" 1)
                                           (rewrite "sq_minus" 1)
                                           (replace -1)
                                           (assert))))
                                        ("2"
                                         (hide 2)
                                         (lemma
                                          "sin_value_strict_increasing")
                                         (lemma
                                          "cos_value_strict_decreasing")
                                         (expand "strict_decreasing?")
                                         (expand "strict_increasing?")
                                         (inst - "c!1" "pi/4")
                                         (inst - "c!1" "pi/4")
                                         (rewrite "cos_value_pi4")
                                         (rewrite "sin_value_pi4")
                                         (assert))
                                        ("3"
                                         (hide 1)
                                         (lemma
                                          "sin2_cos2_value"
                                          ("q1" "c!1"))
                                         (rewrite "sq_rew" -2)
                                         (case
                                          "1 - sq(cos_value(c!1)) * (1 / 2) - sq(sin_value(c!1)) * (1 / 2)
                                                                                                                                                                                                                                                    -
                                                                                                                                                                                                                                                    2 *
                                                                                                                                                                                                                                                     (cos_value(c!1) * sin_value(c!1) * sqrt(1 / 2) * sqrt(1 / 2)) = 1/2 - cos_value(c!1) * sin_value(c!1)")
                                         (("1"
                                           (replace -1)
                                           (assert)
                                           (hide -4 -1)
                                           (lemma
                                            "sin_value_strict_increasing")
                                           (lemma
                                            "cos_value_strict_decreasing")
                                           (expand "strict_decreasing?")
                                           (expand "strict_increasing?")
                                           (inst - "c!1" "pi/4")
                                           (inst - "c!1" "pi/4")
                                           (rewrite "cos_value_pi4")
                                           (rewrite "sin_value_pi4")
                                           (assert)
                                           (lemma
                                            "sq_nz_pos"
                                            ("nz"
                                             "cos_value(c!1)-sin_value(c!1)"))
                                           (rewrite "sq_minus" -1)
                                           (replace -4 -1)
                                           (lemma
                                            "both_sides_div_pos_gt1"
                                            ("x"
                                             "1 - 2 * (cos_value(c!1) * sin_value(c!1))"
                                             "y"
                                             "0"
                                             "pz"
                                             "2"))
                                           (assert))
                                          ("2" (assert))))
                                        ("4" (assert))))
                                      ("3"
                                       (assert)
                                       (tccs-formula 1)
                                       (flatten))
                                      ("4" (assert))))
                                    ("2"
                                     (hide 2)
                                     (assert)
                                     (lemma
                                      "sin_value_strict_increasing")
                                     (lemma
                                      "cos_value_strict_decreasing")
                                     (expand "strict_decreasing?")
                                     (expand "strict_increasing?")
                                     (inst - "c!1" "pi/4")
                                     (inst - "c!1" "pi/4")
                                     (rewrite "sin_value_pi4")
                                     (rewrite "cos_value_pi4")
                                     (assert)
                                     (lemma
                                      "sin2_cos2_value"
                                      ("q1" "c!1"))
                                     (lemma
                                      "sq_nz_pos"
                                      ("nz"
                                       "cos_value(c!1)-sin_value(c!1)"))
                                     (lemma
                                      "sq_minus"
                                      ("a"
                                       "cos_value(c!1)"
                                       "b"
                                       "sin_value(c!1)"))
                                     (case
                                      "sq(cos_value(c!1)) - 2 * cos_value(c!1) * sin_value(c!1) +
                                                                                                                                                                                                                                      sq(sin_value(c!1)) = 1-2 * cos_value(c!1) * sin_value(c!1)")
                                     (("1"
                                       (replace -1)
                                       (replace -2)
                                       (case
                                        "1 - sq(cos_value(c!1)) * (1 / 2) - sq(sin_value(c!1)) * (1 / 2) -
                                                                                                                                                                                                                                               2 * (cos_value(c!1) * sin_value(c!1) * (sqrt(1 / 2) * sqrt(1 / 2))) = 1/2-cos_value(c!1) * sin_value(c!1)")
                                       (("1"
                                         (assert)
                                         (assert)
                                         (rewrite "pi_value")
                                         (assert))
                                        ("2"
                                         (hide 2 -1 -2 -6)
                                         (replace -4 1 rl)
                                         (lemma
                                          "sin_value_strict_increasing")
                                         (expand "strict_increasing?")
                                         (inst - "c!1" "pi/2")
                                         (rewrite "sin_value_pi2")
                                         (assert))))
                                      ("2"
                                       (hide 2)
                                       (lemma
                                        "sin_value_strict_increasing")
                                       (expand "strict_increasing?")
                                       (inst - "c!1" "pi/4")
                                       (rewrite "sin_value_pi4")
                                       (assert))))))
                                  ("2"
                                   (hide 2 -1 -2 -6)
                                   (replace -4 1 rl)
                                   (lemma "sin_value_strict_increasing")
                                   (expand "strict_increasing?")
                                   (inst - "c!1" "pi/2")
                                   (rewrite "sin_value_pi2")
                                   (assert)
                                   (hide -2 -4 -5)
                                   (lemma "asin_sin_value" ("xs" "c!1"))
                                   (expand "asin" -1)
                                   (rewrite "sq_rew" -1))))
                                ("2"
                                 (hide 2)
                                 (lemma "sin_value_strict_increasing")
                                 (expand "strict_increasing?")
                                 (inst - "c!1" "pi/4")
                                 (rewrite "sin_value_pi4")
                                 (assert)
                                 (lemma "cos_value_strict_decreasing")
                                 (expand "strict_decreasing?")
                                 (inst - "c!1" "pi/4")
                                 (rewrite "cos_value_pi4")
                                 (lemma
                                  "div_mult_pos_lt1"
                                  ("z"
                                   "sin_value(c!1)"
                                   "py"
                                   "cos_value(c!1)"
                                   "x"
                                   "1"))
                                 (replace -1 1)
                                 (assert))))))
                            ("2"
                             (lemma "sin_value_strict_increasing")
                             (lemma "cos_value_strict_decreasing")
                             (expand "strict_decreasing?")
                             (expand "strict_increasing?")
                             (inst - "c!1" "pi/2")
                             (inst - "0" "c!1")
                             (rewrite "cos_value_pi2")
                             (rewrite "sin_value_0")
                             (assert)
                             (replace -5 1)
                             (lemma "posreal_times_posreal_is_posreal"
                              ("px"
                               "sin_value(c!1) + cos_value(c!1)"
                               "py"
                               "sqrt(1 / 2)"))
                             (assert))
                            ("3"
                             (lemma "sq_le_abs"
                              ("a" "sin_value(c!1)" "b" "1"))
                             (typepred "sin_value(c!1)")
                             (rewrite "sq_1")
                             (assert))))
                          ("2"
                           (hide 2)
                           (replace -1 1)
                           (hide -1)
                           (lemma "sin_value_strict_increasing")
                           (lemma "cos_value_strict_decreasing")
                           (expand "strict_decreasing?")
                           (expand "strict_increasing?")
                           (inst-cp - "c!1" "pi/2")
                           (rewrite "cos_value_pi2")
                           (assert)
                           (inst-cp -3 "0" "c!1")
                           (rewrite "sin_value_0")
                           (assert)
                           (lemma "sq_lt"
                            ("nna"
                             "cos_value(c!1) + sin_value(c!1)"
                             "nnb"
                             "sqrt(2)"))
                           (rewrite "sq_sqrt" -1)
                           (rewrite "sq_plus" -1)
                           (lemma "sin2_cos2_value" ("q1" "c!1"))
                           (replace -1)
                           (replace -2 1 rl)
                           (lemma "sq_minus"
                            ("a" "cos_value(c!1)" "b" "sin_value(c!1)"))
                           (lemma "sq_nz_pos"
                            ("nz" "cos_value(c!1) - sin_value(c!1)"))
                           (("1"
                             (lemma "sin_value_strict_increasing")
                             (lemma "cos_value_strict_decreasing")
                             (expand "strict_increasing?")
                             (expand "strict_decreasing?")
                             (inst - "c!1" "pi/4")
                             (inst - "c!1" "pi/4")
                             (assert))
                            ("2"
                             (lemma "sin_value_strict_increasing")
                             (lemma "cos_value_strict_decreasing")
                             (expand "strict_increasing?")
                             (expand "strict_decreasing?")
                             (hide 2)
                             (inst - "c!1" "pi/4")
                             (assert)
                             (inst - "c!1" "pi/4")
                             (assert)
                             (rewrite "cos_value_pi4")
                             (rewrite "sin_value_pi4")
                             (assert))))))
                        ("3" (assert))))))
                    ("2" (propax)) ("3" (propax))
                    ("4"
                     (replace -1)
                     (replace -7)
                     (hide-all-but (-9 -10 1))
                     (lemma "extensionality"
                      ("f"
                       "(LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                             cos_value(abs(x_1 + c!1)))"
                       "g"
                       "(LAMBDA (x_1: {x: posreal | x < pi / 2 - c!1}):
                                                                                                              cos_value(c!1) * cos_value(abs(x_1)) +
                                                                                                               sin_value(c!1) * (cos_value(abs(pi / 2 - x_1)) * -1))"))
                     (("1"
                       (split -1)
                       (("1" (assert))
                        ("2"
                         (hide 2)
                         (skosimp*)
                         (expand "abs")
                         (lemma "cos_value_sum" ("q1" "c!1" "q2" "x!1"))
                         (lemma "sin_eqv_cos_quad" ("q1" "x!1"))
                         (assert))))
                      ("2" (expand "abs" 1) (propax))
                      ("3" (expand "abs" 1) (propax))
                      ("4" (expand "abs" 1) (propax))))))
                  ("2" (inst-cp + "pi/8"))
                  ("3" (expand "connected?") (skosimp*) (assert))))
                ("2"
                 (hide-all-but 1)
                 (expand "not_one_element?")
                 (skosimp*)
                 (typepred "c!1")
                 (typepred "x!1")
                 (inst-cp + "(pi / 2 - c!1)/2")
                 (inst + "(pi / 2 - c!1)/4")
                 (flatten)
                 (assert))
                ("3"
                 (hide 2)
                 (assert)
                 (lemma "deriv_domain_posreal_lt")
                 (inst - "pi/2 - c!1"))))
              ("3" (skosimp*) (assert))))
            ("2" (replace -1) (assert))))
          ("2"
           (replace -1 * rl)
           (rewrite "sin_value_0")
           (rewrite "cos_value_0")
           (assert))))
        ("2" (replace -1) (assert))))
      ("2"
       (replace -1 * rl)
       (rewrite "sin_value_0")
       (rewrite "cos_value_0")
       (assert))))
    ("3" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z1" "z2"))
   (lemma "sin_eqv_cos_quad" ("q1" "z1"))
   (lemma "cos_eqv_sin_quad" ("q1" "z1"))
   (replace -1)
   (replace -2)
   (lemma "sin_value_sum" ("q1" "pi/2-z1" "q2" "z2"))
   (replace -1 1 rl)
   (hide -1 -2 -3)
   (case "z1-z2<0")
   (("1" (assert)) ("2" (assert) (rewrite "cos_eqv_sin_quad"))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_acos_fun")
   (lemma "acos_derivable_fun")
   (case "bijective?[real_abs_lt1,posreal_lt_pi](LAMBDA (x:real_abs_lt1): acos(x))")
   (("1"
     (tccs-step
      (case "inverse?[real_abs_lt1, posreal_lt_pi]((LAMBDA (x:posreal_lt_pi): inverse(acos)(x)),(LAMBDA (x:real_abs_lt1): acos(x)))")
      :label "TCC" :hide? t)
     (("1"
       (lemma "inverse_derivable[real_abs_lt1, posreal_lt_pi]"
        ("F"
         "LAMBDA (x: real_abs_lt1): acos(x)"
         "f"
         "deriv[real_abs_lt1](LAMBDA (x: real_abs_lt1): acos(x))"
         "G"
         "(LAMBDA (x: posreal_lt_pi): inverse(acos)(x))"))
       (("1"
         (replace -2 -1)
         (replace -3 -1)
         (replace -4 -1)
         (inst - "x!1")
         (expand "cos_value" 1)
         (propax))
        ("2"
         (lemma "deriv_asin_fun")
         (replace -1 -5)
         (replace -5 1)
         (skosimp*)
         (hide-all-but -2)
         (typepred "x1!1")
         (lemma "sq_lt_abs" ("a" "x1!1" "b" "1"))
         (expand "abs" -1 2)
         (rewrite "sq_1")
         (case "1-sq(x1!1)>0")
         (("1"
           (lemma "sqrt_pos" ("px" "1-sq(x1!1)"))
           (("1" (assert)) ("2" (assert))))
          ("2" (assert))))
        ("3" (propax))
        ("4"
         (hide-all-but 1)
         (reveal "TCC")
         (skosimp*)
         (inst? -2)
         (flatten)
         (assert))))
      ("2"
       (split +)
       (("1"
         (hide -2 -3 2)
         (expand "inverse?")
         (skosimp*)
         (typepred "r!1")
         (typepred "d!1")
         (hide -2)
         (lemma "cos_value_acos" ("xa" "d!1"))
         (expand "cos_value" -1)
         (assert))
        ("2"
         (hide -2 -3 2)
         (skosimp*)
         (lemma "cos_value_strict_decreasing")
         (expand "strict_decreasing?")
         (inst-cp - "0" "x!2")
         (inst - "x!2" "pi")
         (typepred "x!2")
         (hide -1)
         (assert)
         (rewrite "cos_value_pi")
         (rewrite "cos_value_0")
         (expand "cos_value")
         (assert))))))
    ("2"
     (hide -1 -2 2)
     (lemma "acos_bij")
     (expand "bijective?")
     (flatten)
     (lemma "acos_strict_decreasing")
     (split 1)
     (("1"
       (expand "injective?")
       (skosimp*)
       (lemma "trich_lt" ("x" "x1!1" "y" "x2!1"))
       (split -1)
       (("1"
         (expand "strict_decreasing?")
         (inst - "x1!1" "x2!1")
         (assert))
        ("2" (propax))
        ("3"
         (expand "strict_decreasing?")
         (inst - "x2!1" "x1!1")
         (assert))))
      ("2"
       (expand "surjective?")
       (hide -1 -2)
       (skosimp*)
       (inst - "y!1")
       (skosimp*)
       (inst + "x!2")
       (typepred "y!1")
       (hide -1)
       (lemma "cos_value_strict_decreasing")
       (expand "strict_decreasing?")
       (inst-cp - "0" "y!1")
       (inst - "y!1" "pi")
       (assert)
       (rewrite "cos_value_pi")
       (rewrite "cos_value_0")
       (lemma "acos_cos_value" ("xc" "y!1"))
       (lemma "acos_bij")
       (expand "bijective?")
       (expand "injective?")
       (flatten -1)
       (inst - "x!2" "cos_value(y!1)")
       (assert))))
    ("3"
     (hide-all-but 1)
     (skosimp*)
     (typepred "x!2")
     (lemma "acos_strict_decreasing")
     (expand "strict_decreasing?")
     (inst-cp - "-1" "x!2")
     (inst - "x!2" "1")
     (rewrite "acos_1")
     (rewrite "acos_minus1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_acos_fun")
   (lemma "acos_derivable_fun")
   (case "bijective?[real_abs_lt1,posreal_lt_pi](LAMBDA (x:real_abs_lt1): acos(x))")
   (("1"
     (tccs-step
      (case "inverse?[real_abs_lt1, posreal_lt_pi]((LAMBDA (x:posreal_lt_pi): inverse(acos)(x)),(LAMBDA (x:real_abs_lt1): acos(x)))")
      :label "TCC" :hide? t)
     (("1"
       (lemma "inverse_derivable_fun[real_abs_lt1, posreal_lt_pi]"
        ("F"
         "LAMBDA (x: real_abs_lt1): acos(x)"
         "f"
         "deriv[real_abs_lt1](LAMBDA (x: real_abs_lt1): acos(x))"
         "G"
         "(LAMBDA (x: posreal_lt_pi): inverse(acos)(x))"))
       (("1"
         (lemma "deriv_inverse_fun[real_abs_lt1, posreal_lt_pi]"
          ("F"
           "LAMBDA (x: real_abs_lt1): acos(x)"
           "f"
           "deriv[real_abs_lt1](LAMBDA (x: real_abs_lt1): acos(x))"
           "G"
           "(LAMBDA (x: posreal_lt_pi): inverse(acos)(x))"))
         (("1"
           (replace -3)
           (replace -4)
           (replace -5)
           (expand "cos_value" 1)
           (replace -1 1)
           (lemma "deriv_acos_fun")
           (replace -1 1)
           (lemma "deriv_asin_fun")
           (replace -1 1)
           (hide-all-but 1)
           (simplify 1)
           (lemma "extensionality"
            ("f"
             "(LAMBDA (x_1: posreal_lt_pi):
                                                   1 / -(1 / sqrt(1 - sq(inverse(acos)(x_1)))))"
             "g"
             "(LAMBDA (x: posreal_lt_pi):
                                                    IF x < pi / 2 THEN -sin_value(x) ELSE -sin_value(pi - x) ENDIF)"))
           (("1"
             (split -1)
             (("1" (propax))
              ("2"
               (hide 2)
               (skosimp*)
               (lemma "trich_lt" ("x" "x!1" "y" "pi/2"))
               (split -1)
               (("1"
                 (assert)
                 (lemma "sin_eqv_sqrt_cos_value" ("q1" "x!1"))
                 (expand "cos_value" -1)
                 (replace -1 1)
                 (lemma "sin_value_strict_increasing")
                 (expand "strict_increasing?")
                 (inst - "0" "x!1")
                 (rewrite "sin_value_0")
                 (assert))
                ("2"
                 (replace -1)
                 (rewrite "sin_value_pi2")
                 (lemma "cos_value_pi2")
                 (expand "cos_value")
                 (replace -1)
                 (rewrite "sq_0")
                 (rewrite "sqrt_1")
                 (assert))
                ("3"
                 (assert)
                 (lemma "sin_eqv_sqrt_cos_value" ("q1" "pi-x!1"))
                 (rewrite "cos_value_neg" -1)
                 (rewrite "sq_neg" -1)
                 (expand "cos_value")
                 (replace -1 1)
                 (assert))))))
            ("2" (hide 2) (skosimp*) (assert))
            ("3" (hide 2) (skosimp*) (assert))
            ("4"
             (hide 2)
             (skosimp*)
             (case "1-sq(inverse[real_abs_le1, nnreal_le_pi](acos)(x!1))>0")
             (("1"
               (lemma "sqrt_pos"
                ("px"
                 "1-sq(inverse[real_abs_le1, nnreal_le_pi](acos)(x!1))"))
               (("1" (assert)) ("2" (assert))))
              ("2"
               (hide -1)
               (typepred "x!1")
               (hide -1)
               (lemma "cos_value_strict_decreasing")
               (expand "strict_decreasing?")
               (inst-cp - "0" "x!1")
               (inst - "x!1" "pi")
               (rewrite "cos_value_0")
               (rewrite "cos_value_pi")
               (assert)
               (lemma "sq_lt_abs" ("a" "cos_value(x!1)" "b" "1"))
               (expand "abs" -1 2)
               (rewrite "sq_1")
               (expand "cos_value" -1 1)
               (expand "abs" 1)
               (case "cos_value(x!1)<0")
               (("1" (assert)) ("2" (assert))))))
            ("5"
             (hide 2)
             (skosimp*)
             (typepred "cos_value(x!1)")
             (case "abs(cos_value(x!1)) <= 1")
             (("1"
               (hide -2 -3)
               (lemma "sq_le_abs" ("a" "cos_value(x!1)" "b" "1"))
               (expand "abs" -1 2)
               (replace -2 -1)
               (flatten -1)
               (rewrite "sq_1")
               (expand "cos_value" -1)
               (assert))
              ("2" (hide 2) (expand "abs") (lift-if) (ground))))))
          ("2"
           (hide-all-but 1)
           (reveal "TCC")
           (skosimp*)
           (inst? -2)
           (flatten)
           (assert))))
        ("2"
         (replace -4 1)
         (hide-all-but 1)
         (skosimp*)
         (lemma "deriv_asin_fun")
         (replace -1 -2)
         (hide -1)
         (simplify -1)
         (lemma "sq_lt_abs" ("a" "x1!1" "b" "1"))
         (expand "abs" -1 2)
         (rewrite "sq_1")
         (case "1-sq(x1!1)>0")
         (("1"
           (lemma "sqrt_pos" ("px" "1-sq(x1!1)"))
           (("1" (assert)) ("2" (propax))))
          ("2" (assert))))
        ("3" (propax))
        ("4"
         (hide-all-but 1)
         (reveal "TCC")
         (skosimp*)
         (inst? -2)
         (flatten)
         (assert))))
      ("2"
       (split +)
       (("1"
         (hide -2 -3 2)
         (expand "inverse?")
         (skosimp*)
         (lemma "acos_cos_value" ("xc" "r!1"))
         (expand "cos_value" -1)
         (propax))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!1")
         (hide -1)
         (lemma "cos_value_strict_decreasing")
         (expand "strict_decreasing?")
         (inst-cp - "0" "x!1")
         (inst - "x!1" "pi")
         (rewrite "cos_value_0")
         (rewrite "cos_value_pi")
         (assert)
         (expand "cos_value")
         (case "inverse(acos)(x!1)<0")
         (("1" (assert)) ("2" (assert))))))))
    ("2"
     (hide -1 -2 2)
     (expand "bijective?")
     (expand "injective?")
     (expand "surjective?")
     (split 1)
     (("1"
       (skosimp*)
       (lemma "acos_bij")
       (expand "bijective?")
       (expand "injective?")
       (flatten -1)
       (inst - "x1!1" "x2!1")
       (assert))
      ("2"
       (skosimp*)
       (typepred "y!1")
       (hide -1)
       (lemma "cos_value_strict_decreasing")
       (expand "strict_decreasing?")
       (inst-cp - "0" "y!1")
       (inst - "y!1" "pi")
       (rewrite "cos_value_pi")
       (rewrite "cos_value_0")
       (assert)
       (inst + "cos_value(y!1)")
       (rewrite "acos_cos_value"))))
    ("3"
     (hide-all-but 1)
     (skosimp*)
     (lemma "acos_strict_decreasing")
     (expand "strict_decreasing?")
     (inst-cp - "-1" "x!1")
     (inst - "x!1" "1")
     (rewrite "acos_1")
     (rewrite "acos_minus1")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "xs!1")
   (expand "abs")
   (case "xs!1<0")
   (("1" (assert)) ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "q1!1")
   (lemma "cos_value_decreasing")
   (expand "decreasing?")
   (inst-cp - "q1!1" "pi/2")
   (inst - "0" "q1!1")
   (rewrite "cos_value_pi2")
   (rewrite "cos_value_0")
   (assert)
   (lemma "sq_le" ("nna" "cos_value(q1!1)" "nnb" "1"))
   (rewrite "sq_1")
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "q1!1")
   (lemma "sin_value_increasing")
   (expand "increasing?")
   (inst-cp - "0" "q1!1")
   (("1"
     (inst - "q1!1" "pi/2")
     (("1"
       (rewrite "sin_value_pi2")
       (rewrite "sin_value_0")
       (assert)
       (lemma "sq_le" ("nna" "sin_value(q1!1)" "nnb" "1"))
       (rewrite "sq_1")
       (assert))
      ("2" (expand "abs") (assert))))
    ("2" (expand "abs") (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "qo1!1")
   (lemma "cos_value_strict_decreasing")
   (expand "strict_decreasing?")
   (inst - "qo1!1" "pi/2")
   (rewrite "cos_value_pi2")
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "atan_strict_increasing")
   (expand "strict_increasing?")
   (typepred "nnx!1")
   (expand ">=")
   (expand "<=" -1)
   (split -1)
   (("1"
     (inst - "0" "nnx!1")
     (rewrite "atan_0")
     (assert)
     (typepred "atan(nnx!1)")
     (expand "abs")
     (expand "pi")
     (expand "atan")
     (assert))
    ("2" (replace -1 1 rl) (rewrite "atan_0") (assert) (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "q1!1")
   (typepred "q2!1")
   (expand "abs")
   (case "q1!1 - q2!1 < 0")
   (("1" (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: tan_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "x!1")
   (lemma "atan_bij")
   (expand "tan_value")
   (lemma "comp_inverse_right[real, real_abs_lt_pi2]"
    ("f" "atan" "y" "x!1"))
   (("1"
     (expand "bijective?")
     (expand "injective?")
     (flatten)
     (hide -3)
     (inst - "inverse(atan)(x!1)" "sin_value(x!1) / cos_value(abs(x!1))")
     (split -2)
     (("1" (propax))
      ("2"
       (lemma "cos_eqv_sqrt_sin_value" ("q1" "abs(x!1)"))
       (("1"
         (case "sq(sin_value(abs(x!1))) = sq(sin_value(x!1))")
         (("1"
           (replace -1)
           (replace -3 1)
           (replace -2 1 rl)
           (hide -1 -2 -3 2)
           (lemma "asin_sin_value" ("xs" "x!1"))
           (expand "asin")
           (lemma "sin_value_strict_increasing")
           (expand "strict_increasing?")
           (inst-cp - "-pi/2" "x!1")
           (inst - "x!1" "pi/2")
           (rewrite "sin_value_pi2")
           (rewrite "sin_value_minus_pi2")
           (case "x!1<0")
           (("1"
             (assert)
             (case "-pi / 2 < x!1")
             (("1" (rewrite "sq_rew" -5) (assert)) ("2" (propax))))
            ("2" (assert) (rewrite "sq_rew" -3) (assert))))
          ("2"
           (hide-all-but 1)
           (expand "abs")
           (case "x!1<0")
           (("1"
             (lemma "sin_value_neg" ("xs" "x!1"))
             (assert)
             (replace -1 1)
             (rewrite "sq_neg" 1))
            ("2" (assert))))))
        ("2" (expand "abs") (hide 2 3) (ground) (lift-if) (ground))))))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: tan_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "tan_value_def" ("x" "0"))
   (("1"
     (rewrite "sin_value_0")
     (expand "abs")
     (rewrite "cos_value_0")
     (assert))
    ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: tan_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "tan_value_def" ("x" "pi/4"))
   (("1"
     (rewrite "sin_value_pi4")
     (expand "abs")
     (assert)
     (rewrite "cos_value_pi4")
     (rewrite "div_simp" -1))
    ("2" (expand "abs" 1) (typepred "pi") (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: tan_quad
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "x!1")
   (lemma "cos_value_strict_decreasing")
   (expand "strict_decreasing?")
   (inst - "abs(x!1)" "pi/2")
   (rewrite "cos_value_pi2")
   (assert)
   (expand "abs")
   (lift-if)
   (ground))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "floor_def" ("x" "(2 * x!1) / pi"))
   (flatten)
   (name-replace "K1" "floor((2 * x!1) / pi)")
   (lemma "trichotomy" ("x" "K1"))
   (split -1)
   (("1"
     (case "K1=1")
     (("1"
       (replace -1)
       (lemma "div_mult_pos_le2" ("x" "1" "z" "2*x!1" "py" "pi"))
       (lemma "div_mult_pos_lt1" ("x" "2" "z" "2*x!1" "py" "pi"))
       (assert))
      ("2"
       (case "K1>1")
       (("1"
         (assert)
         (rewrite "div_mult_pos_le2")
         (lemma "both_sides_times_pos_lt1" ("x" "1" "y" "K1" "pz" "pi"))
         (assert))
        ("2" (assert))))))
    ("2"
     (replace -1)
     (rewrite "div_mult_pos_le2")
     (rewrite "div_mult_pos_lt1")
     (assert))
    ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "floor_def" ("x" "(2 * x!1) / pi"))
   (flatten)
   (name-replace "K1" "floor((2 * x!1) / pi)")
   (lemma "trich_lt" ("x" "K1" "y" "1"))
   (split -1)
   (("1"
     (assert)
     (flatten)
     (rewrite "div_mult_pos_le2")
     (rewrite "div_mult_pos_lt1")
     (assert))
    ("2"
     (replace -1)
     (rewrite "div_mult_pos_lt1")
     (rewrite "div_mult_pos_le2")
     (assert))
    ("3"
     (assert)
     (rewrite "div_mult_pos_le2")
     (rewrite "div_mult_pos_lt1")
     (assert)
     (flatten)
     (lemma "both_sides_times_pos_lt1" ("x" "1" "y" "K1" "pz" "pi"))
     (assert)
     (case "K1=2")
     (("1" (replace -1) (assert))
      ("2"
       (case "K1>2")
       (("1"
         (lemma "both_sides_times_pos_lt1" ("x" "2" "y" "K1" "pz" "pi"))
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "floor_def" ("x" "(2*x!1)/pi"))
   (flatten)
   (name-replace "K1" "floor((2 * x!1) / pi)")
   (rewrite "div_mult_pos_le2" -1)
   (lemma "both_sides_times_pos_le1" ("x" "pi" "y" "x!1" "pz" "2"))
   (replace -1 1 rl)
   (rewrite "div_mult_pos_lt1" -3)
   (rewrite "div_mult_pos_lt2" 1)
   (lemma "trich_lt" ("x" "K1" "y" "2"))
   (split -1)
   (("1"
     (lemma "both_sides_times_pos_lt1" ("x" "K1" "y" "2" "pz" "pi"))
     (assert))
    ("2" (replace -1) (assert))
    ("3"
     (case "3=K1")
     (("1" (replace -1 * rl) (assert))
      ("2"
       (case "3<K1")
       (("1"
         (lemma "both_sides_times_pos_lt1" ("x" "K1" "y" "3" "pz" "pi"))
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "floor_def" ("x" "(2*x!1)/pi"))
   (flatten)
   (name-replace "K1" "floor((2 * x!1) / pi)")
   (lemma "trich_lt" ("x" "K1" "y" "3"))
   (rewrite "div_mult_pos_le2" -2)
   (rewrite "div_mult_pos_lt1" -3)
   (rewrite "div_mult_pos_le1" 1)
   (split -1)
   (("1"
     (lemma "both_sides_times_pos_lt1" ("x" "K1" "y" "3" "pz" "pi"))
     (assert))
    ("2" (replace -1) (assert))
    ("3"
     (case "K1=4")
     (("1" (replace -1) (assert))
      ("2"
       (case "K1>4")
       (("1"
         (lemma "both_sides_times_pos_lt1" ("x" "K1" "y" "4" "pz" "pi"))
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "phase_sin_q1")
   (rewrite "phase_sin_q2")
   (rewrite "phase_sin_q3")
   (rewrite "phase_sin_q4")
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_phase")
   (assert)
   (rewrite "phase_sin_q2")
   (flatten)
   (rewrite "sin_eqv_cos_value" 1)
   (("1"
     (lemma "cos_value_neg" ("xc" "x!1-pi/2"))
     (("1" (replace -1 1) (assert)) ("2" (assert))))
    ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_phase")
   (assert)
   (rewrite "phase_sin_q4")
   (lemma "sin_eqv_cos_value" ("xs" "2*pi-x!1"))
   (("1"
     (replace -1 1)
     (lemma "cos_value_neg" ("xc" "x!1-3*pi/2"))
     (("1" (replace -1 1) (propax)) ("2" (assert))))
    ("2" (expand "abs" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "floor_def" ("x" "x!1/pi"))
   (flatten)
   (name-replace "K1" "floor(x!1/pi)")
   (rewrite "div_mult_pos_le2" -1)
   (rewrite "div_mult_pos_lt1" -2)
   (lemma "trichotomy" ("x" "K1"))
   (split -1)
   (("1"
     (case "K1=1")
     (("1" (replace -1) (assert))
      ("2"
       (case "K1>1")
       (("1"
         (lemma "both_sides_times_pos_lt1" ("x" "1" "y" "K1" "pz" "pi"))
         (assert))
        ("2" (assert))))))
    ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "x!1")
   (replace -2)
   (lemma "floor_def" ("x" "x!1/pi"))
   (flatten)
   (name-replace "K1" "floor(x!1/pi)")
   (rewrite "div_mult_pos_le2" -1)
   (lemma "div_mult_pos_lt1" ("z" "x!1" "py" "pi" "x" "K1+1"))
   (replace -3 -1)
   (flatten -1)
   (case "K1<1")
   (("1" (assert))
    ("2"
     (case "K1=1")
     (("1" (replace -1) (assert))
      ("2"
       (case "K1>1")
       (("1"
         (case "K1=2")
         (("1" (replace -1) (assert))
          ("2"
           (case "K1>2")
           (("1"
             (lemma "both_sides_times_pos_lt1"
              ("x" "2" "y" "K1" "pz" "pi"))
             (assert))
            ("2" (assert))))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "cos_phase")
   (assert)
   (rewrite "phase_sin_q1")
   (rewrite "phase_cos_q1")
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "cos_phase")
   (rewrite "phase_sin_q2")
   (flatten)
   (rewrite "phase_cos_q1")
   (assert)
   (lemma "sin_eqv_cos_value" ("xs" "x!1-pi/2"))
   (("1" (replace -1) (assert)) ("2" (expand "abs") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "phase_sin_q3" -1)
   (flatten)
   (expand "cos_phase")
   (lemma "phase_cos_q1" ("x" "x!1"))
   (replace -1 1)
   (assert)
   (lemma "cos_value_neg" ("xc" "x!1-pi"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "cos_phase")
   (rewrite "phase_sin_q4")
   (rewrite "phase_cos_q1")
   (assert)
   (lemma "sin_value_neg" ("xs" "3*pi/2-x!1"))
   (("1"
     (replace -1)
     (lemma "sin_eqv_cos_value" ("xs" "3*pi/2-x!1"))
     (assert))
    ("2"
     (expand "abs")
     (assert)
     (expand "<=" -1)
     (split -1)
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "phase_cos_q2")
   (lemma "phases_sin" ("x" "x!1"))
   (split -1)
   (("1" (rewrite "phase_sin_q1") (assert))
    ("2" (rewrite "phase_sin_q2") (assert))
    ("3"
     (lemma "sin_q3" ("x" "x!1"))
     (assert)
     (lemma "sin_q1" ("x" "x!1-pi"))
     (rewrite "phase_sin_q1")
     (rewrite "phase_sin_q3")
     (assert))
    ("4"
     (lemma "sin_q4" ("x" "x!1"))
     (assert)
     (lemma "sin_q2" ("x" "x!1-pi"))
     (rewrite "phase_sin_q4")
     (rewrite "phase_sin_q2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin_h2" ("x" "x!1+pi"))
   (("1" (rewrite "phase_cos_q1") (rewrite "phase_cos_q2") (assert))
    ("2" (assert) (rewrite "phase_cos_q1"))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "cos_phase")
   (assert)
   (rewrite "phase_cos_q1")
   (rewrite "phase_cos_q1")
   (rewrite "cos_value_neg")
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "phase_cos_q2")
   (lemma "cos_h1" ("x" "x!1-pi"))
   (("1" (rewrite "phase_cos_q1") (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "px!1")
   (hide -1)
   (expand "sin_phase")
   (lemma "phases_sin" ("x" "px!1"))
   (split -1)
   (("1"
     (assert)
     (lemma "phase_sin_q1" ("x" "px!1"))
     (replace -2)
     (flatten -1)
     (lemma "phase_sin_q4" ("x" "2*pi-px!1"))
     (assert))
    ("2"
     (assert)
     (lemma "floor_def" ("x" "(2 * px!1) / pi"))
     (replace -2)
     (flatten -1)
     (expand "<=" -1)
     (split -1)
     (("1" (lemma "phase_sin_q3" ("x" "2*pi-px!1")) (assert))
      ("2"
       (lemma "both_sides_times1"
        ("x" "1" "y" "(2 * px!1) / pi" "n0z" "pi/2"))
       (flatten -1)
       (replace -3 -2 rl)
       (hide -1)
       (replace -1 * rl)
       (lemma "minus_div2" ("x" "4*pi" "y" "2*px!1" "n0x" "pi"))
       (replace -1 * rl)
       (replace -2 * rl)
       (lemma "div_cancel1" ("x" "4" "n0z" "pi"))
       (replace -1)
       (rewrite "floor_int" 1)
       (assert))))
    ("3"
     (assert)
     (lemma "floor_def" ("x" "(2 * px!1) / pi"))
     (flatten)
     (replace -3)
     (rewrite "div_mult_pos_le2" -1)
     (rewrite "div_mult_pos_lt1" -2)
     (expand "<=" -1)
     (split -1)
     (("1" (lemma "phase_sin_q2" ("x" "2*pi-px!1")) (assert))
      ("2"
       (replace -1 * rl)
       (simplify 1)
       (lemma "div_cancel1" ("x" "2" "n0z" "pi"))
       (replace -1)
       (rewrite "floor_int" 1)
       (assert)
       (lemma "sin_value_neg" ("xs" "px!1-pi"))
       (("1" (replace -1 1) (propax))
        ("2" (hide 2) (expand "abs") (assert))))))
    ("4"
     (assert)
     (lemma "floor_def" ("x" "(2 * px!1) / pi"))
     (flatten)
     (replace -3)
     (rewrite "div_mult_pos_le2" -1)
     (lemma "div_mult_pos_lt1" ("z" "2*px!1" "py" "pi" "x" "4"))
     (replace -3 -1)
     (flatten -1)
     (lemma "phase_sin_q1" ("x" "2*pi-px!1"))
     (expand "<=" -3)
     (split -3)
     (("1" (assert))
      ("2"
       (replace -1 * rl)
       (simplify 1)
       (rewrite "div_simp" 1)
       (rewrite "floor_int" 1)
       (simplify 1)
       (lemma "both_sides_div1" ("x" "3 * pi" "y" "2 * px!1" "n0z" "2"))
       (flatten -1)
       (lemma "div_cancel1" ("x" "px!1" "n0z" "2"))
       (replace -1)
       (replace -4 -3 rl)
       (hide -1 -2)
       (replace -1 * rl)
       (simplify 1)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "cos_phase")
   (lemma "phases_cos" ("x" "px!1"))
   (split -1)
   (("1"
     (assert)
     (lemma "phase_cos_q1" ("x" "px!1"))
     (replace -2 -1)
     (flatten -1)
     (typepred "px!1")
     (hide -1 -4)
     (hide -2)
     (assert))
    ("2"
     (assert)
     (lemma "phase_cos_q2" ("x" "px!1"))
     (assert)
     (typepred "px!1")
     (assert)
     (expand ">=")
     (expand "<=" -4)
     (split -4)
     (("1" (lemma "phase_cos_q1" ("x" "2*pi-px!1")) (assert))
      ("2" (replace -1 * rl) (simplify 1) (propax))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_phase")
   (expand "cos_phase")
   (lemma "phases_sin" ("x" "x!1"))
   (split -1)
   (("1"
     (replace -1)
     (lemma "phase_sin_q1" ("x" "x!1"))
     (replace -2)
     (flatten -1)
     (lemma "phase_cos_q1" ("x" "pi/2+x!1"))
     (("1"
       (assert)
       (rewrite "sin_eqv_cos_value")
       (expand "abs" 1)
       (assert))
      ("2" (hide 2) (assert))))
    ("2"
     (replace -1 1)
     (simplify 1)
     (lemma "phase_sin_q2" ("x" "x!1"))
     (replace -2 -1)
     (flatten -1)
     (assert)
     (lemma "phase_cos_q2" ("x" "pi/2+x!1"))
     (assert)
     (lemma "sin_eqv_cos_value" ("xs" "pi - x!1"))
     (("1" (assert)) ("2" (expand "abs" 1) (assert))))
    ("3"
     (assert)
     (lemma "phase_sin_q3" ("x" "x!1"))
     (replace -2 -1)
     (flatten -1)
     (lemma "phase_cos_q2" ("x" "x!1+pi/2"))
     (("1"
       (assert)
       (lemma "sin_value_neg" ("xs" "pi-x!1"))
       (("1" (replace -1 1) (rewrite "sin_eqv_cos_value" 1) (assert))
        ("2"
         (expand "abs" 1)
         (expand "<=" -2)
         (split -2)
         (("1" (assert)) ("2" (replace -1 * rl) (assert))))))
      ("2" (assert))))
    ("4"
     (assert)
     (lemma "phase_sin_q4" ("x" "x!1"))
     (replace -2 -1)
     (flatten -1)
     (assert)
     (expand "<=" -1)
     (split -1)
     (("1"
       (lemma "sin_value_neg" ("xs" "2*pi-x!1"))
       (("1"
         (replace -1 1 rl)
         (hide -1)
         (rewrite "sin_eqv_cos_value" 1)
         (("1" (simplify 1) (assert)) ("2" (expand "abs" 1) (assert))))
        ("2" (expand "abs" 1) (assert))))
      ("2"
       (replace -1 * rl)
       (simplify 1)
       (rewrite "floor_int" 1)
       (rewrite "cos_value_0")
       (rewrite "sin_value_pi2")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "x!1 < 3 * pi / 2")
   (("1"
     (assert)
     (lemma "sin_eqv_cos_phase" ("x" "pi/2+x!1"))
     (case "x!1<pi")
     (("1"
       (assert)
       (lemma "div_cancel1" ("x" "pi" "n0z" "2"))
       (replace -1)
       (replace -3 1)
       (hide -1 -3 -4)
       (expand "cos_phase")
       (rewrite "phase_cos_q1")
       (rewrite "phase_cos_q1")
       (lemma "cos_value_neg" ("xc" "x!1"))
       (assert))
      ("2"
       (assert)
       (case "pi / 2 - 3 * pi / 2 + x!1 = x!1-pi")
       (("1"
         (replace -1)
         (replace -2)
         (case "x!1>=pi")
         (("1"
           (hide -2 -3 1)
           (expand "cos_phase")
           (rewrite "phase_cos_q1")
           (rewrite "phase_cos_q1")
           (lemma "cos_value_neg" ("xc" "x!1-pi"))
           (assert))
          ("2" (assert))))
        ("2" (assert))))))
    ("2"
     (assert)
     (lemma "sin_eqv_cos_phase" ("x" "x!1-3 * pi / 2"))
     (assert)
     (replace -1 2)
     (case "x!1>=3*pi/2")
     (("1"
       (case "pi / 2 - 3 * pi / 2 + x!1 = x!1-pi")
       (("1"
         (replace -1)
         (hide -1 -3 1)
         (expand "cos_phase")
         (rewrite "phase_cos_q1")
         (rewrite "phase_cos_q1")
         (lemma "cos_value_neg" ("xc" "x!1-pi"))
         (assert))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "sin_eqv_cos_phase")
   (case "x!1<pi")
   (("1" (assert) (rewrite "cos_eqv_sin_phase") (assert))
    ("2"
     (assert)
     (case "x!1 < 3 * pi / 2")
     (("1" (assert) (rewrite "cos_eqv_sin_phase") (assert))
      ("2" (assert) (rewrite "cos_eqv_sin_phase") (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "x!1<pi")
   (("1"
     (rewrite "cos_eqv_sin_phase")
     (assert)
     (rewrite "sin_eqv_cos_phase")
     (assert))
    ("2"
     (rewrite "cos_eqv_sin_phase")
     (case "x!1 < 3 * pi / 2")
     (("1" (assert) (rewrite "sin_eqv_cos_phase") (assert))
      ("2" (assert) (rewrite "sin_eqv_cos_phase") (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin_phase")
   (lemma "div_cancel1" ("x" "3*pi" "n0z" "2"))
   (replace -1)
   (lemma "div_cancel2" ("x" "3" "n0z" "pi"))
   (replace -1)
   (rewrite "floor_int" 1)
   (assert)
   (rewrite "sin_value_pi2"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin_phase")
   (rewrite "sin_value_0")
   (lemma "floor_int" ("i" "0"))
   (replace -1)
   (propax))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (rewrite "sin_phase")
   (rewrite "sin_value_pi4")
   (lemma "div_cancel1" ("x" "2/4" "n0z" "pi"))
   (replace -1 1)
   (lemma "floor_val" ("i" "2" "j" "4" "k" "0"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin_phase")
   (lemma "div_cancel1" ("x" "pi" "n0z" "2"))
   (replace -1)
   (rewrite "div_simp")
   (rewrite "floor_int")
   (rewrite "sin_value_pi2")
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_phase")
   (rewrite "floor_int")
   (("1" (rewrite "cos_value_0") (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_phase")
   (rewrite "div_div2" 1)
   (lemma "div_cancel1" ("x" "1/4" "n0z" "pi"))
   (replace -1 1)
   (lemma "floor_val" ("i" "1" "j" "4" "k" "0"))
   (assert)
   (rewrite "cos_value_pi4"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "cos_phase")
   (rewrite "div_div2")
   (lemma "floor_val" ("i" "1" "j" "2" "k" "0"))
   (lemma "div_cancel1" ("x" "1/2" "n0z" "pi"))
   (rewrite "div_div2")
   (replace -1 1)
   (assert)
   (rewrite "cos_value_pi2"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "xa!1<0")
   (("1"
     (assert)
     (expand "sin_phase")
     (typepred "asin(xa!1)")
     (lemma "asin_strict_increasing")
     (expand "strict_increasing?")
     (inst-cp - "xa!1" "0")
     (rewrite "asin_0")
     (assert)
     (lemma "phase_sin_q4" ("x" "2*pi+asin(xa!1)"))
     (assert)
     (lemma "sin_value_neg" ("xs" "asin(xa!1)"))
     (replace -1 1)
     (rewrite "sin_value_asin" 1))
    ("2"
     (assert)
     (expand "sin_phase")
     (typepred "asin(xa!1)")
     (lemma "asin_strict_increasing")
     (expand "strict_increasing?")
     (case "xa!1=0")
     (("1"
       (replace -1)
       (rewrite "asin_0")
       (rewrite "sin_value_0")
       (assert)
       (rewrite "floor_int" 2)
       (assert))
      ("2"
       (inst-cp - "0" "xa!1")
       (inst - "xa!1" "1")
       (rewrite "asin_1")
       (rewrite "asin_0")
       (assert)
       (expand "<=" -4)
       (split -4)
       (("1"
         (lemma "phase_sin_q1" ("x" "asin(xa!1)"))
         (assert)
         (rewrite "sin_value_asin"))
        ("2"
         (case "floor((2 * asin(xa!1)) / pi) = 1")
         (("1"
           (assert)
           (lemma "asin_1")
           (lemma "asin_bij")
           (expand "bijective?")
           (expand "injective?")
           (flatten)
           (inst - "xa!1" "1")
           (assert)
           (replace -5)
           (rewrite "sin_value_pi2")
           (assert))
          ("2"
           (hide 4)
           (replace -1 1)
           (lemma "div_cancel1" ("x" "pi" "n0z" "2"))
           (replace -1)
           (rewrite "div_simp" 1)
           (rewrite "floor_int" 1))))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "xa!1")
   (typepred "acos(xa!1)")
   (expand "cos_phase")
   (rewrite "phase_cos_q1" 1)
   (expand ">=")
   (replace -1)
   (expand "<=" -2)
   (split)
   (("1" (assert) (rewrite "cos_value_acos"))
    ("2"
     (replace -1)
     (assert)
     (rewrite "cos_value_pi")
     (lemma "acos_bij")
     (expand "bijective?")
     (expand "injective?")
     (flatten)
     (inst - "-1" "xa!1")
     (("1" (rewrite "acos_minus1") (assert))
      ("2" (expand "abs" 1) (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_phase")
   (expand "cos_phase")
   (lemma "phases_sin" ("x" "x!1"))
   (split -1)
   (("1"
     (lemma "phase_sin_q1" ("x" "x!1"))
     (replace -2)
     (flatten -1)
     (lemma "phase_cos_q1" ("x" "x!1"))
     (assert)
     (lemma "sin2_cos2_value" ("q1" "x!1"))
     (assert))
    ("2"
     (lemma "phase_sin_q2" ("x" "x!1"))
     (replace -2)
     (flatten -1)
     (lemma "phase_cos_q1" ("x" "x!1"))
     (assert)
     (lemma "sin2_cos2_value" ("q1" "pi-x!1"))
     (rewrite "cos_value_neg" -1)
     (rewrite "sq_neg")
     (assert))
    ("3"
     (lemma "phase_sin_q3" ("x" "x!1"))
     (replace -2)
     (flatten -1)
     (lemma "phase_cos_q2" ("x" "x!1"))
     (assert)
     (lemma "sin2_cos2_value" ("q1" "x!1-pi"))
     (lemma "cos_value_neg" ("xc" "x!1-pi"))
     (replace -1 1)
     (rewrite "sq_neg" 1)
     (assert)
     (rewrite "sq_neg" 1)
     (expand "abs" 1)
     (assert))
    ("4"
     (lemma "phase_sin_q4" ("x" "x!1"))
     (replace -2)
     (flatten -1)
     (lemma "phase_cos_q2" ("x" "x!1"))
     (assert)
     (lemma "sin2_cos2_value" ("q1" "2*pi-x!1"))
     (assert)
     (rewrite "sq_neg" 1)
     (expand "abs" 1)
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (x,y:{x:nnreal|x<pi}): sin_phase(x) * cos_phase(y) - cos_phase(x) * sin_phase(y) =
                  IF x - y < 0 THEN sin_phase(x - y + 2 * pi)
                  ELSE sin_phase(x - y)
                  ENDIF")
   (("1"
     (skosimp*)
     (lemma "phases_cos" ("x" "x!1"))
     (lemma "phases_cos" ("x" "y!1"))
     (split -1)
     (("1"
       (split -2)
       (("1"
         (inst - "x!1" "y!1")
         (("1"
           (rewrite "phase_cos_q1" -2)
           (case "x!1 - y!1 < 0")
           (("1" (assert)) ("2" (assert))))
          ("2" (rewrite "phase_cos_q1" -1) (rewrite "phase_cos_q1" -2))
          ("3" (rewrite "phase_cos_q1" -1))))
        ("2"
         (inst - "x!1-pi" "y!1")
         (("1"
           (lemma "cos_h2" ("x" "x!1"))
           (lemma "sin_h2" ("x" "x!1"))
           (assert)
           (replace -1 1)
           (replace -2 1)
           (case "x!1<y!1")
           (("1"
             (assert)
             (lemma "sin_h1" ("x" "pi - y!1 + x!1"))
             (("1"
               (rewrite "phase_cos_q1")
               (("1"
                 (rewrite "phase_cos_q1")
                 (rewrite "phase_cos_q2")
                 (assert))
                ("2" (rewrite "phase_cos_q2"))))
              ("2"
               (rewrite "phase_cos_q2")
               (rewrite "phase_cos_q1")
               (assert))))
            ("2"
             (assert)
             (case "x!1-y!1<pi")
             (("1"
               (assert)
               (lemma "phase_cos_q1" ("x" "x!1-y!1"))
               (replace -2 -1)
               (case "0 <= x!1-y!1")
               (("1"
                 (replace -1 -2)
                 (flatten -2)
                 (lemma "sin_h1" ("x" "x!1-y!1"))
                 (assert))
                ("2" (assert))))
              ("2"
               (assert)
               (lemma "phase_cos_q2" ("x" "x!1-y!1"))
               (assert)
               (lemma "sin_h2" ("x" "x!1-y!1"))
               (assert))))))
          ("2" (rewrite "phase_cos_q1" -2))
          ("3" (rewrite "phase_cos_q2" -1) (assert))))))
      ("2"
       (split -2)
       (("1"
         (inst - "x!1" "y!1-pi")
         (("1"
           (lemma "sin_h2" ("x" "y!1"))
           (lemma "cos_h1" ("x" "x!1"))
           (assert)
           (replace -1)
           (replace -2)
           (hide -1 -2)
           (rewrite "phase_cos_q1" -1)
           (rewrite "phase_cos_q2" -2)
           (assert)
           (lemma "cos_h2" ("x" "y!1"))
           (rewrite "phase_cos_q2" -1)
           (replace -1)
           (hide -1)
           (case "pi - y!1 + x!1 < 0")
           (("1"
             (assert)
             (lemma "sin_h2" ("x" "3 * pi - y!1 + x!1"))
             (rewrite "phase_cos_q2" -1)
             (assert))
            ("2"
             (assert)
             (lemma "sin_h1" ("x" "pi - y!1 + x!1"))
             (rewrite "phase_cos_q1" -1)
             (assert))))
          ("2" (rewrite "phase_cos_q2" -2) (assert))
          ("3" (rewrite "phase_cos_q1" -1))))
        ("2"
         (inst - "x!1-pi" "y!1-pi")
         (("1"
           (lemma "sin_h2" ("x" "x!1"))
           (lemma "cos_h2" ("x" "x!1"))
           (lemma "cos_h2" ("x" "y!1"))
           (lemma "sin_h2" ("x" "y!1"))
           (assert)
           (replace -1)
           (replace -2)
           (replace -3)
           (replace -4)
           (hide (-1 -2 -3 -4))
           (case "x!1<y!1")
           (("1" (assert)) ("2" (assert))))
          ("2" (rewrite "phase_cos_q2" -2) (assert))
          ("3" (rewrite "phase_cos_q2" -1) (assert))))))))
    ("2"
     (hide 2)
     (skosimp*)
     (typepred "x!1")
     (typepred "y!1")
     (expand "cos_phase")
     (rewrite "phase_cos_q1")
     (rewrite "phase_cos_q1")
     (lemma "phases_sin" ("x" "x!1"))
     (split -1)
     (("1"
       (lemma "sin_q1" ("x" "x!1"))
       (assert)
       (replace -1)
       (lemma "phases_sin" ("x" "y!1"))
       (split -1)
       (("1"
         (lemma "sin_q1" ("x" "y!1"))
         (assert)
         (replace -1)
         (lemma "sin_value_diff" ("q1" "x!1" "q2" "y!1"))
         (("1"
           (replace -1 1 rl)
           (case "x!1-y!1<0")
           (("1"
             (assert)
             (lemma "phase_sin_q4" ("x" "2 * pi - y!1 + x!1"))
             (rewrite "phase_sin_q1" -5)
             (rewrite "phase_sin_q1" -7)
             (assert)
             (lemma "sin_q4" ("x" "2 * pi - y!1 + x!1"))
             (assert)
             (replace -1 1)
             (replace -1 1 rl)
             (lemma "sin_phase_neg" ("px" "y!1-x!1"))
             (replace -1 1)
             (lemma "sin_value_neg" ("xs" "y!1-x!1"))
             (("1"
               (replace -1 1)
               (lemma "sin_q1" ("x" "y!1-x!1"))
               (rewrite "phase_sin_q1" -1)
               (assert))
              ("2" (expand "abs" 1) (assert))))
            ("2"
             (assert)
             (lemma "sin_q1" ("x" "x!1-y!1"))
             (rewrite "phase_sin_q1" -1)
             (assert)
             (rewrite "phase_sin_q1" -3)
             (rewrite "phase_sin_q1" -4))))
          ("2" (rewrite "phase_sin_q1" -2) (assert))
          ("3" (rewrite "phase_sin_q1" -4) (assert))))
        ("2"
         (hide -2)
         (case "x!1<pi/2")
         (("1"
           (case "pi/2<=y!1")
           (("1"
             (hide -5 -8)
             (lemma "sin_q2" ("x" "y!1"))
             (assert)
             (replace -1 1)
             (hide -1)
             (lemma "sin_phase_neg" ("px" "y!1-x!1"))
             (replace -1 1)
             (hide -1)
             (case "y!1-x!1<pi/2")
             (("1"
               (lemma "sin_q1" ("x" "y!1-x!1"))
               (rewrite "phase_sin_q1" -1)
               (assert)
               (replace -1)
               (hide -1)
               (case "cos_value(y!1) = -sin_value(y!1 - pi / 2)")
               (("1"
                 (replace -1 1)
                 (hide -1)
                 (lemma "cos_value_diff" ("q1" "x!1" "q2" "y!1-pi/2"))
                 (assert)
                 (lemma "sin_eqv_cos_quad" ("q1" "y!1-x!1"))
                 (assert))
                ("2"
                 (hide-all-but (-2 -6 1))
                 (lemma "cos_value_neg" ("xc" "y!1"))
                 (lemma "cos_eqv_sin_quad" ("q1" "pi-y!1"))
                 (assert))
                ("3" (expand "abs" 1) (assert))))
              ("2"
               (lemma "sin_q2" ("x" "y!1-x!1"))
               (rewrite "phase_sin_q2" -1)
               (assert)
               (replace -1 2)
               (hide -1)
               (case "cos_value(y!1) = -sin_value(y!1 - pi / 2)")
               (("1"
                 (replace -1 2)
                 (lemma "cos_value_diff" ("q1" "x!1" "q2" "y!1-pi/2"))
                 (assert)
                 (case "pi / 2 - y!1 + x!1 < 0")
                 (("1" (assert)) ("2" (assert))))
                ("2"
                 (hide-all-but (-1 -5 1))
                 (lemma "cos_value_neg" ("xc" "y!1"))
                 (lemma "cos_eqv_sin_quad" ("q1" "pi-y!1"))
                 (assert))
                ("3" (expand "abs" 1) (assert))))))
            ("2" (rewrite "phase_sin_q2" -2))))
          ("2" (rewrite "phase_sin_q1" -2))))
        ("3" (rewrite "phase_sin_q3" -1))
        ("4" (rewrite "phase_sin_q4" -1))))
      ("2"
       (lemma "sin_q2" ("x" "x!1"))
       (assert)
       (replace -1 1)
       (case "pi/2<= x!1")
       (("1"
         (hide -6 -2)
         (lemma "phases_sin" ("x" "y!1"))
         (split -1)
         (("1"
           (case "y!1<pi/2")
           (("1"
             (hide -6)
             (assert)
             (case "cos_value(x!1) = -sin_value(x!1 - pi / 2)")
             (("1"
               (replace -1)
               (hide -1)
               (lemma "sin_q1" ("x" "y!1"))
               (assert)
               (replace -1)
               (hide -1)
               (lemma "cos_value_diff" ("q1" "x!1-pi/2" "q2" "y!1"))
               (case "x!1 - pi / 2 - y!1 < 0")
               (("1"
                 (assert)
                 (replace -2 1 rl)
                 (hide -2)
                 (lemma "sin_q1" ("x" "x!1-y!1"))
                 (rewrite "phase_sin_q1" -1)
                 (rewrite "sin_eqv_cos_quad" -1)
                 (assert))
                ("2"
                 (assert)
                 (replace -1 2 rl)
                 (hide -1)
                 (lemma "sin_q2" ("x" "x!1-y!1"))
                 (rewrite "phase_sin_q2" -1)
                 (assert))))
              ("2"
               (hide-all-but (-3 -6 1))
               (lemma "cos_value_neg" ("xc" "x!1"))
               (lemma "cos_eqv_sin_quad" ("q1" "pi-x!1"))
               (assert))
              ("3" (expand "abs" 1) (assert))))
            ("2" (rewrite "phase_sin_q1" -1))))
          ("2"
           (case "pi/2<= y!1")
           (("1"
             (hide -5)
             (lemma "sin_q2" ("x" "y!1"))
             (assert)
             (replace -1 1)
             (hide -1)
             (case "FORALL (x:real): pi/2<=x & x < pi => cos_value(x) = -sin_value(x-pi/2)")
             (("1"
               (inst-cp - "x!1")
               (inst - "y!1")
               (assert)
               (replace -1)
               (replace -2)
               (lemma "sin_value_diff" ("q1" "x!1-pi/2" "q2" "y!1-pi/2"))
               (case "x!1<y!1")
               (("1"
                 (lemma "sin_phase_neg" ("px" "y!1-x!1"))
                 (("1"
                   (assert)
                   (replace -1 1)
                   (lemma "sin_q1" ("x" "y!1-x!1"))
                   (rewrite "phase_sin_q1" -1)
                   (lemma "sin_value_neg" ("xs" "y!1-x!1"))
                   (("1" (assert)) ("2" (expand "abs" 1) (assert))))
                  ("2" (assert))))
                ("2"
                 (assert)
                 (lemma "sin_q1" ("x" "x!1-y!1"))
                 (rewrite "phase_sin_q1" -1)
                 (assert))))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (lemma "cos_value_neg" ("xc" "x!2"))
               (("1"
                 (lemma "cos_eqv_sin_quad" ("q1" "pi-x!2"))
                 (("1" (assert)) ("2" (assert))))
                ("2" (assert))))
              ("3" (skosimp*) (expand "abs" 1) (assert))
              ("4" (skosimp*) (assert))))
            ("2" (rewrite "phase_sin_q2" -1))))
          ("3" (rewrite "phase_sin_q3" -1))
          ("4" (rewrite "phase_sin_q4" -1))))
        ("2" (rewrite "phase_sin_q2" -2))))
      ("3" (rewrite "phase_sin_q3" -1))
      ("4" (rewrite "phase_sin_q4" -1))))
    ("3" (hide 2) (skosimp*) (assert))
    ("4" (hide 2) (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (x,y:{x:nnreal|x<pi}): cos_phase(x) * cos_phase(y) - sin_phase(x) * sin_phase(y) = cos_phase(x + y)")
   (("1"
     (skosimp*)
     (lemma "phases_cos" ("x" "x!1"))
     (lemma "phases_cos" ("x" "y!1"))
     (split -2)
     (("1"
       (split -2)
       (("1"
         (case "x!1<pi")
         (("1"
           (case "y!1<pi")
           (("1" (inst - "x!1" "y!1") (assert))
            ("2" (rewrite "phase_cos_q1" -2))))
          ("2" (rewrite "phase_cos_q1" -2))))
        ("2"
         (case "pi<=y!1")
         (("1"
           (case "x!1<pi")
           (("1"
             (inst - "x!1" "y!1-pi")
             (("1"
               (case "cos_phase(y!1 - pi) = -cos_phase(y!1)")
               (("1"
                 (case "sin_phase(y!1 - pi) = -sin_phase(y!1)")
                 (("1"
                   (replace -1)
                   (replace -2)
                   (hide -1 -2)
                   (case "x!1+y!1<2*pi")
                   (("1"
                     (assert)
                     (case "cos_phase(x!1 + y!1)=-cos_phase(x!1 - pi + y!1)")
                     (("1" (assert))
                      ("2" (hide -6 2) (rewrite "cos_phase_inv" 1))))
                    ("2"
                     (assert)
                     (lemma "cos_phase_inv" ("x" "x!1 - pi + y!1"))
                     (assert))))
                  ("2" (hide 2) (rewrite "sin_phase_inv" 1))
                  ("3" (assert))))
                ("2" (hide 2) (rewrite "cos_phase_inv" 1))
                ("3" (assert))))
              ("2" (assert))))
            ("2" (rewrite "phase_cos_q1" -3))))
          ("2" (rewrite "phase_cos_q2" -1))))))
      ("2"
       (case "pi<=x!1")
       (("1"
         (split -3)
         (("1"
           (case "y!1< pi")
           (("1"
             (case "x!1 + y!1 < 2 * pi")
             (("1"
               (assert)
               (inst - "x!1-pi" "y!1")
               (lemma "cos_phase_inv" ("x" "x!1-pi"))
               (lemma "sin_phase_inv" ("x" "x!1-pi"))
               (lemma "cos_phase_inv" ("x" "x!1+y!1"))
               (assert)
               (replace -2)
               (replace -3)
               (replace -1)
               (replace -9 1 rl)
               (assert))
              ("2"
               (inst - "x!1-pi" "y!1")
               (("1"
                 (lemma "cos_phase_inv" ("x" "x!1-pi"))
                 (("1"
                   (lemma "sin_phase_inv" ("x" "x!1-pi"))
                   (("1"
                     (lemma "cos_phase_inv" ("x" "x!1+y!1-pi"))
                     (("1" (assert)) ("2" (assert))))
                    ("2" (assert))))
                  ("2" (assert))))
                ("2" (assert))))))
            ("2" (rewrite "phase_cos_q1" -1))))
          ("2"
           (case "pi<=y!1")
           (("1"
             (inst - "x!1-pi" "y!1-pi")
             (("1"
               (assert)
               (lemma "sin_phase_inv" ("x" "x!1"))
               (lemma "cos_phase_inv" ("x" "x!1"))
               (lemma "sin_phase_inv" ("x" "y!1"))
               (lemma "cos_phase_inv" ("x" "y!1"))
               (assert))
              ("2" (assert)) ("3" (assert))))
            ("2" (rewrite "phase_cos_q2" -1))))))
        ("2" (rewrite "phase_cos_q2" -1))))))
    ("2"
     (hide 2)
     (skosimp*)
     (lemma "phases_sin" ("x" "x!1"))
     (split -1)
     (("1"
       (case "x!1<pi/2")
       (("1"
         (lemma "phases_sin" ("x" "y!1"))
         (split -1)
         (("1"
           (case "y!1<pi/2")
           (("1"
             (lemma "sin_q1" ("x" "x!1"))
             (lemma "sin_q1" ("x" "y!1"))
             (lemma "cos_q1" ("x" "x!1"))
             (lemma "cos_q1" ("x" "y!1"))
             (assert)
             (replace -1)
             (replace -2)
             (replace -3)
             (replace -4)
             (hide -1 -2 -3 -4)
             (lemma "cos_value_sum" ("q1" "x!1" "q2" "y!1"))
             (replace -1 1 rl)
             (hide -1)
             (expand "cos_phase" 1)
             (rewrite "phase_cos_q1" 1))
            ("2" (rewrite "phase_sin_q1" -1))))
          ("2"
           (case "pi/2<= y!1")
           (("1"
             (lemma "sin_q1" ("x" "x!1"))
             (lemma "cos_q1" ("x" "x!1"))
             (lemma "sin_q2" ("x" "y!1"))
             (lemma "cos_q2" ("x" "y!1"))
             (assert)
             (replace -1)
             (replace -2)
             (replace -3)
             (replace -4)
             (hide -1 -2 -3 -4)
             (lemma "sin_value_sum" ("q1" "x!1" "q2" "y!1-pi/2"))
             (expand "cos_phase" 1)
             (rewrite "phase_cos_q1" 1)
             (lemma "trich_lt" ("x" "x!1+y!1" "y" "pi"))
             (split -1)
             (("1"
               (assert)
               (lemma "sin_eqv_cos_value" ("xs" "x!1 - pi / 2 + y!1"))
               (("1" (assert)) ("2" (expand "abs" 1) (assert))))
              ("2"
               (replace -1)
               (assert)
               (lemma "sin_value_pi2")
               (case "x!1=pi-y!1")
               (("1"
                 (replace -1)
                 (simplify (-4 1))
                 (rewrite "cos_value_pi")
                 (replace -2)
                 (assert))
                ("2" (assert))))
              ("3"
               (assert)
               (lemma "cos_value_neg" ("xc" "x!1+y!1-pi"))
               (assert))))
            ("2" (rewrite "phase_sin_q2" -1))))
          ("3" (rewrite "phase_sin_q3" -1))
          ("4" (rewrite "phase_sin_q4" -1))))
        ("2" (rewrite "phase_sin_q1" -1))))
      ("2"
       (case "pi/2<=x!1")
       (("1"
         (lemma "phases_sin" ("x" "y!1"))
         (split -1)
         (("1"
           (case "y!1<pi/2")
           (("1"
             (lemma "sin_q2" ("x" "x!1"))
             (lemma "cos_q2" ("x" "x!1"))
             (lemma "sin_q1" ("x" "y!1"))
             (lemma "cos_q1" ("x" "y!1"))
             (assert)
             (lemma "cos_q2" ("x" "x!1+y!1"))
             (lemma "cos_q3" ("x" "x!1+y!1"))
             (replace -3)
             (replace -4)
             (replace -5)
             (replace -6)
             (rewrite "phase_sin_q2" -2)
             (rewrite "phase_sin_q3" -1)
             (case "x!1+y!1<pi")
             (("1"
               (assert)
               (hide -2 -4 -5 -6 -7)
               (lemma "sin_value_sum" ("q1" "x!1-pi/2" "q2" "y!1"))
               (assert))
              ("2"
               (assert)
               (hide -2 -3 -4 -5 -6)
               (lemma "sin_value_sum" ("q1" "x!1-pi/2" "q2" "y!1"))
               (assert)
               (case "x!1=pi-y!1")
               (("1"
                 (replace -1)
                 (assert)
                 (rewrite "sin_value_pi2" -2)
                 (rewrite "cos_value_0")
                 (assert))
                ("2" (assert))))))
            ("2" (rewrite "phase_sin_q1" -1))))
          ("2"
           (case "pi/2<=y!1")
           (("1"
             (lemma "cos_value_sum" ("q1" "x!1-pi/2" "q2" "y!1-pi/2"))
             (("1"
               (simplify -1)
               (lemma "div_cancel1" ("x" "pi" "n0z" "2"))
               (replace -1)
               (hide -1)
               (lemma "sin_q2" ("x" "x!1"))
               (lemma "cos_q2" ("x" "x!1"))
               (lemma "sin_q2" ("x" "y!1"))
               (lemma "cos_q2" ("x" "y!1"))
               (assert)
               (replace -1)
               (replace -2)
               (replace -3)
               (replace -4)
               (rewrite "cos_phase_inv" 1)
               (hide -1 -2 -3 -4)
               (expand "cos_phase" 1)
               (rewrite "phase_cos_q1" 1)
               (assert))
              ("2" (assert)) ("3" (assert))))
            ("2" (rewrite "phase_sin_q2" -1))))
          ("3" (rewrite "phase_sin_q3" -1))
          ("4" (rewrite "phase_sin_q4" -1))))
        ("2" (rewrite "phase_sin_q2" -1))))
      ("3" (rewrite "phase_sin_q3" -1))
      ("4" (rewrite "phase_sin_q4" -1))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "y!1=0")
   (("1"
     (replace -1)
     (rewrite "cos_phase_0")
     (rewrite "sin_phase_0")
     (assert))
    ("2"
     (lemma "cos_phase_sum" ("x" "x!1" "y" "2*pi-y!1"))
     (("1"
       (lemma "sin_phase_neg" ("px" "y!1"))
       (("1"
         (lemma "cos_phase_neg" ("px" "y!1"))
         (("1"
           (replace -1)
           (replace -2)
           (hide -1 -2)
           (replace -1 2)
           (case "x!1 - y!1 >= 0")
           (("1" (assert)) ("2" (assert))))
          ("2" (assert))))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin_phase_diff" ("x" "x!1" "y" "2*pi-y!1"))
   (("1"
     (case "x!1 + y!1 < 2 * pi")
     (("1"
       (assert)
       (case "y!1=0")
       (("1"
         (replace -1)
         (rewrite "sin_phase_0")
         (rewrite "cos_phase_0")
         (assert))
        ("2"
         (lemma "sin_phase_neg" ("px" "y!1"))
         (("1"
           (lemma "cos_phase_neg" ("px" "y!1"))
           (("1" (assert)) ("2" (assert))))
          ("2" (typepred "y!1") (assert))))))
      ("2"
       (assert)
       (lemma "sin_phase_neg" ("px" "y!1"))
       (lemma "cos_phase_neg" ("px" "y!1"))
       (assert))))
    ("2"
     (case "y!1=0")
     (("1"
       (replace -1)
       (rewrite "cos_phase_0")
       (rewrite "sin_phase_0")
       (assert))
      ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (replace -2)
   (hide -2)
   (lemma "floor_def" ("x" "(2*x!1)/pi"))
   (flatten)
   (assert)
   (replace -3)
   (hide -3)
   (expand "abs")
   (lemma "div_mult_pos_le1" ("z" "x!1" "x" "1" "py" "pi/2"))
   (replace -1 1 rl)
   (hide -1)
   (rewrite "div_div1")
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (replace -2)
   (hide -2 1)
   (lemma "floor_def" ("x" "(2 * x!1) / pi"))
   (replace -2 * rl)
   (flatten)
   (replace -3)
   (hide -3)
   (expand "abs")
   (lemma "div_mult_pos_lt1" ("x" "1" "z" "x!1" "py" "pi"))
   (lemma "both_sides_times_pos_lt1" ("x" "x!1/pi" "y" "1" "pz" "2"))
   (replace -1 -2 rl)
   (replace -4 -2)
   (flatten -2)
   (hide -1 -4)
   (assert)
   (lemma "div_mult_pos_le2" ("x" "1" "z" "2*x!1" "py" "pi"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (replace -2)
   (hide -2 1 2)
   (lemma "floor_def" ("x" "(2*x!1)/pi"))
   (flatten)
   (replace -3)
   (hide -3)
   (lemma "div_mult_pos_le2" ("x" "2" "z" "2*x!1" "py" "pi"))
   (lemma "both_sides_times_pos_le1" ("x" "pi" "y" "x!1" "pz" "2"))
   (expand "abs" 1)
   (assert)
   (lemma "div_mult_pos_lt1" ("z" "2*x!1" "py" "pi" "x" "3"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: fix
script:
  (""
   (skosimp*)
   (case "floor((2 * x!1) / pi) = 0")
   (("1" (replace -1) (propax))
    ("2"
     (assert)
     (case "floor((2 * x!1) / pi) = 1")
     (("1" (replace -1) (propax))
      ("2"
       (case "floor((2 * x!1) / pi) = 2")
       (("1" (rewrite "abs_neg") (assert))
        ("2"
         (lemma "floor_def" ("x" "(2*x!1)/pi"))
         (flatten)
         (replace -3)
         (lemma "div_mult_pos_le2" ("z" "2*x!1" "py" "pi" "x" "2"))
         (assert))))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "floor_def" ("x" "(2 * x!1) / pi"))
   (replace -2 * rl)
   (flatten)
   (hide -3)
   (lemma "div_mult_pos_le2" ("x" "i!1" "py" "pi" "z" "2*x!1"))
   (lemma "div_mult_pos_lt1" ("x" "i!1+1" "py" "pi" "z" "2*x!1"))
   (typepred "x!1")
   (replace -6)
   (replace -5)
   (flatten)
   (expand "abs")
   (lemma "both_sides_times_pos_lt1" ("x" "x!1" "y" "2*pi" "pz" "2"))
   (replace -3 -1)
   (flatten)
   (lemma "div_mult_pos_le2" ("z" "pi" "py" "2" "x" "2*pi-x!1"))
   (replace -1 4)
   (hide -1)
   (lemma "both_sides_plus_le1"
    ("x" "(2*pi-x!1)*2" "y" "pi" "z" "2*x!1-pi"))
   (replace -1 4 rl)
   (hide -1)
   (assert)
   (case "i!1 < 0")
   (("1" (assert))
    ("2"
     (case "i!1 = 3")
     (("1" (assert))
      ("2"
       (case "i!1=4")
       (("1" (assert))
        ("2"
         (case "i!1>4")
         (("1"
           (assert)
           (lemma "div_mult_pos_le2" ("x" "4" "z" "2*x!1" "py" "pi"))
           (assert))
          ("2" (assert))))))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "floor((2 * x!1) / pi) = 0")
   (("1" (replace -1) (propax))
    ("2"
     (assert)
     (case "floor((2 * x!1) / pi) = 1")
     (("1" (replace -1) (propax))
      ("2"
       (case "floor((2 * x!1) / pi) = 2")
       (("1" (assert)) ("2" (rewrite "abs_neg") (assert))))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (replace -2)
   (lemma "floor_def" ("x" "x!1/pi"))
   (flatten)
   (replace -3 * rl)
   (rewrite "div_mult_pos_lt1" -2)
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "i!1 = 1")
   (("1"
     (replace -1)
     (lemma "floor_def" ("x" "x!1/pi"))
     (replace -3 * rl)
     (flatten)
     (rewrite "div_mult_pos_le2")
     (lemma "div_mult_pos_lt1" ("z" "x!1" "py" "pi" "x" "2"))
     (assert))
    ("2"
     (case "i!1<0")
     (("1" (assert))
      ("2"
       (case "i!1 = 2")
       (("1"
         (lemma "floor_def" ("x" "x!1/pi"))
         (replace -3 * rl)
         (replace -2)
         (flatten)
         (rewrite "div_mult_pos_le2" -1))
        ("2"
         (case "i!1>2")
         (("1"
           (lemma "floor_def" ("x" "x!1/pi"))
           (replace -3 -1 rl)
           (flatten)
           (rewrite "div_mult_pos_le2" -1)
           (rewrite "div_mult_pos_lt1" -2)
           (assert)
           (lemma "both_sides_times_pos_lt1"
            ("x" "2" "y" "i!1" "pz" "pi"))
           (assert))
          ("2" (assert))))))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "xa!1")
   (expand "abs")
   (assert)
   (lemma "asin_strict_increasing")
   (expand "strict_increasing?")
   (inst-cp - "xa!1" "0")
   (("1"
     (rewrite "asin_0")
     (case "xa!1=-1")
     (("1" (replace -1) (rewrite "asin_minus1") (assert))
      ("2"
       (inst - "-1" "xa!1")
       (("1" (rewrite "asin_minus1") (assert))
        ("2" (expand "abs") (assert))))))
    ("2" (expand "abs") (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_phase
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "asin_strict_increasing")
   (expand "strict_increasing?")
   (case "xa!1=0")
   (("1"
     (replace -1)
     (rewrite "asin_0")
     (assert)
     (typepred "pi")
     (assert))
    ("2"
     (inst - "0" "xa!1")
     (("1"
       (rewrite "asin_0")
       (assert)
       (typepred "asin(xa!1)")
       (expand "abs")
       (assert))
      ("2" (expand "abs") (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("a"))
   (flatten)
   (expand "sin")
   (lemma "floor_0" ("x" "a/(2*pi)"))
   (rewrite "div_mult_pos_lt1" -1)
   (assert)
   (rewrite "div_mult_pos_le2" 1))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("a"))
   (flatten)
   (expand "cos")
   (lemma "floor_0" ("x" "a/(2*pi)"))
   (rewrite "div_mult_pos_le2" -1)
   (rewrite "div_mult_pos_lt1" -1)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "0<=a!1")
   (("1"
     (rewrite "sin_sin_phase")
     (expand "sin_phase")
     (lemma "floor_0" ("x" "(2 * a!1) / pi"))
     (rewrite "div_mult_pos_le2" -4)
     (rewrite "div_mult_pos_le2" -1)
     (rewrite "div_mult_pos_lt1" -1)
     (assert)
     (case-replace "a!1=pi/2")
     (("1" (assert)) ("2" (rewrite "div_cancel4" 1) (assert))))
    ("2"
     (expand "sin")
     (lemma "floor_div" ("x" "a!1" "py" "2*pi" "i" "-1"))
     (assert)
     (replace -1)
     (assert)
     (case "a!1<0")
     (("1"
       (hide -2 -4 1)
       (expand "sin_phase")
       (lemma "floor_div" ("x" "2*a!1+4*pi" "py" "pi" "i" "3"))
       (assert)
       (rewrite "sin_value_neg" 1 :dir rl)
       (("1" (assert)) ("2" (expand "abs") (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "cos_cos_phase")
   (expand "cos_phase")
   (lemma "floor_0" ("x" "a!1/pi"))
   (rewrite "div_mult_pos_lt1")
   (rewrite "div_mult_pos_le2")
   (case-replace "a!1=pi")
   (("1" (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "Tan?")
   (skosimp)
   (case "0<=a!1")
   (("1"
     (lemma "cos_cos_value" ("a" "a!1"))
     (assert)
     (lemma "cos_value_strict_decreasing")
     (expand "strict_decreasing?")
     (inst - "a!1" "pi/2")
     (rewrite "cos_value_pi2")
     (assert))
    ("2"
     (case-replace "a!1=0")
     (("1" (rewrite "cos_cos_value") (rewrite "cos_value_0") (assert))
      ("2"
       (expand "cos")
       (lemma "floor_div" ("x" "a!1" "py" "2*pi" "i" "-1"))
       (lemma "cos_phase_neg" ("px" "-a!1"))
       (("1"
         (lemma "cos_cos_phase" ("a" "-a!1"))
         (lemma "cos_cos_value" ("a" "-a!1"))
         (lemma "cos_value_strict_decreasing")
         (expand "strict_decreasing?")
         (inst - "-a!1" "pi/2")
         (("1" (rewrite "cos_value_pi2") (assert)) ("2" (assert))
          ("3" (assert))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "tan")
   (rewrite "tan_value_def")
   (("1"
     (rewrite "sin_sin_value")
     (case-replace "cos(a!1) = cos_value(abs(a!1))")
     (("1"
       (hide 2)
       (expand "abs")
       (case-replace "a!1<0")
       (("1"
         (expand "cos")
         (lemma "floor_div" ("x" "a!1" "py" "2*pi" "i" "-1"))
         (assert)
         (replace -1)
         (lemma "cos_phase_neg" ("px" "-a!1"))
         (replace -1)
         (lemma "cos_cos_phase" ("a" "-a!1"))
         (lemma "cos_cos_value" ("a" "-a!1"))
         (assert))
        ("2" (rewrite "cos_cos_value") (assert))))
      ("2"
       (expand "abs")
       (case-replace "a!1<0")
       (("1" (assert)) ("2" (assert))))))
    ("2"
     (expand "abs")
     (case-replace "a!1<0")
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (case "-pi/2 < x!1 & x!1 < pi/2")
   (("1"
     (flatten)
     (lemma "atan_bij")
     (lemma "bijective_inverse[real, real_abs_lt_pi2]"
      ("f" "atan" "x" "tan(x!1)" "y" "x!1"))
     (("1"
       (assert)
       (hide 2)
       (rewrite "tan_tan_value" 1)
       (expand "tan_value")
       (propax))
      ("2" (propax))))
    ("2"
     (hide 2)
     (case-replace "x!1<0")
     (("1" (assert)) ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (name "DRL1" "floor(x!1 / (2 * pi))")
   (lemma "floor_div" ("x" "x!1" "py" "2*pi" "i" "DRL1"))
   (replace -2)
   (flatten)
   (assert))


proof_type: j_proof
decl_type: tcc
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin")
   (skosimp)
   (name "DRL1" "floor(a!1 / (2 * pi))")
   (lemma "floor_div" ("x" "a!1" "py" "2*pi" "i" "DRL1"))
   (replace -2)
   (flatten)
   (name-replace "DRL2" "a!1 - 2 * (DRL1 * pi)")
   (typepred "sin_phase(DRL2)")
   (("1"
     (case-replace "sin_phase(DRL2) < 0")
     (("1" (assert)) ("2" (assert)) ("3" (assert))))
    ("2" (hide 2) (expand "DRL2") (assert))))


proof_type: j_proof
decl_type: tcc
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "cos")
   (name "DRL1" "floor(a!1 / (2 * pi))")
   (lemma "floor_div" ("x" "a!1" "py" "2*pi" "i" "DRL1"))
   (replace -2)
   (flatten)
   (name "DRL2" "a!1 - 2 * (DRL1 * pi)")
   (replace -1)
   (typepred "cos_phase(DRL2)")
   (("1"
     (case-replace "cos_phase(DRL2) < 0")
     (("1" (assert)) ("2" (assert)) ("3" (assert))))
    ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: sincos_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "atan(a!1)")
   (lemma "tan_value_TCC" ("a" "atan(a!1)"))
   (expand "abs")
   (expand "pi")
   (expand "atan")
   (case-replace "atan_value(a!1) < 0")
   (("1" (assert)) ("2" (assert) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "atan_pos_le1_ub")
   (expand "atan_series_n")
   (expand "sigma" 1 1)
   (expand "sigma" 1 1)
   (move-terms 1 r 1)
   (assert)
   (expand "atan_series_term")
   (expand "atan_series_coef")
   (lemma "not_even_m1_pow")
   (inst?)
   (split -1)
   (("1"
     (replaces -1)
     (lemma "even_m1_pow")
     (inst?)
     (split -1)
     (("1"
       (replaces -1)
       (case "(x ^ (5 + 4 * n)) * (1 / (5 + 4 * n)) < (x ^ (5 + 4 * n)) / (3 + 4 * n)")
       (("1"
         (case "(x ^ (5 + 4 * n)) / (3 + 4 * n) <= (x ^ (3 + 4 * n)) / (3 + 4 * n)")
         (("1" (assert))
          ("2"
           (hide -1 2)
           (grind-reals)
           (rewrite "both_sides_expt_lt1_le")
           (case "x=1")
           (("1" (replaces -1) (grind)) ("2" (assert))))))
        ("2"
         (hide 2)
         (case "x ^ (5+4 *n) > 0")
         (("1" (name-replace "aa" "x^(5+4*n)") (grind-reals))
          ("2" (hide 2) (rewrite "expt_pos"))))))
      ("2" (hide-all-but 1) (grind))))
    ("2" (hide-all-but -1) (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "atan_pos_le1_lb")
   (expand "atan_series_n")
   (expand "sigma" 1 2)
   (expand "sigma" 1 2)
   (move-terms 1 r 3)
   (assert)
   (expand "atan_series_term")
   (expand "atan_series_coef")
   (lemma "not_even_m1_pow")
   (inst -1 "3+2*n")
   (split -1)
   (("1"
     (replaces -1)
     (lemma "even_m1_pow")
     (inst?)
     (split -1)
     (("1"
       (replaces -1)
       (case "(x ^ (5 + 4 * n))/(7 + 4 * n) < (x ^ (5 + 4 * n)) * (1 / (5 + 4 * n))")
       (("1"
         (case "(x ^ (7 + 4 * n))/(7+4*n) <=  (x ^ (5 + 4 * n))/(7+4*n)")
         (("1" (assert))
          ("2"
           (hide -1 2)
           (grind-reals)
           (rewrite "both_sides_expt_lt1_le")
           (case-replace "x=1")
           (("1" (grind)) ("2" (assert))))))
        ("2"
         (hide 2)
         (case "x ^ (5+4*n) > 0")
         (("1" (name-replace "aa" "x^(5+4*n)") (grind-reals))
          ("2" (hide 2) (rewrite "expt_pos"))))))
      ("2" (hide-all-but 1) (grind))))
    ("2" (hide-all-but -1) (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (n: nat, px: posreal):
                               px <= 1 => atan_pos_le1_lb(n, px) < atan_pos_le1_lb(n+1, px)")
   (("1"
     (case "FORALL (n: nat,pn:posnat, px: posreal):
                                     px <= 1 => atan_pos_le1_lb(n, px) < atan_pos_le1_lb(n+pn, px)")
     (("1"
       (skosimp)
       (inst - "n!1" "m!1-n!1" "px!1")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (hide 2)
       (induct "pn")
       (("1" (assert)) ("2" (assert))
        ("3"
         (skosimp*)
         (case-replace "j!1=0")
         (("1" (assert) (hide -1 -2 -3) (inst - "n!1" "px!1") (assert))
          ("2"
           (assert)
           (inst - "n!1" "px!1")
           (assert)
           (inst - "j!1+n!1" "px!1")
           (assert))))))))
    ("2"
     (hide 2)
     (skosimp)
     (expand "atan_pos_le1_lb")
     (expand "atan_series_n")
     (expand "sigma" 1 2)
     (expand "sigma" 1 2)
     (name-replace "SUM" "sigma(0, 1 + 2 * n!1, atan_series_term(px!1))")
     (expand "atan_series_term")
     (expand "atan_series_coef")
     (expand "^")
     (expand "expt" 1 3)
     (expand "expt" 1 3)
     (expand "expt" 1 4)
     (case-replace "expt((-1), 2 + 2 * n!1)=1")
     (("1"
       (typepred "expt(px!1, 5 + 4 * n!1)")
       (hide -1 -3)
       (name-replace "PX" "expt(px!1, 5 + 4 * n!1)")
       (lemma "posreal_times_posreal_is_posreal"
        ("px" "PX" "py" "1 / (5 + 4 * n!1)-sq(px!1)/(7 + 4 * n!1)"))
       (("1" (expand "sq") (assert))
        ("2"
         (hide 2)
         (lemma "div_mult_pos_lt1"
          ("py" "7+4*n!1" "z" "sq(px!1)" "x" "1/(5+4*n!1)"))
         (lemma "sq_nz_pos" ("nz" "px!1"))
         (lemma "div_mult_pos_lt2"
          ("py" "5 + 4 * n!1" "z" "7 + 4 * n!1" "x" "1"))
         (lemma "sq_le" ("nna" "px!1" "nnb" "1"))
         (rewrite "sq_1")
         (assert)
         (name-replace "LHS" "sq(px!1) / (7 + 4 * n!1)")
         (name-replace "RHS" "1 / (5 + 4 * n!1)")
         (assert))))
      ("2"
       (hide-all-but 1)
       (lemma "expt_times" ("n0x" "-1" "i" "2" "j" "1+n!1"))
       (expand "^" -1 1)
       (expand "^" -1 1)
       (replace -1)
       (hide -1)
       (expand "expt")
       (expand "expt")
       (expand "expt")
       (rewrite "sq_rew")
       (rewrite "sq_neg")
       (assert)
       (rewrite "sq_1")
       (rewrite "expt_1i"))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (n: nat, px: posreal):
                                                                  px <= 1 => atan_pos_le1_ub(n, px) > atan_pos_le1_ub(n+1, px)")
   (("1"
     (case "FORALL (n: nat,pn:posnat, px: posreal):
                                                                                  px <= 1 => atan_pos_le1_ub(n, px) > atan_pos_le1_ub(n+pn, px)")
     (("1"
       (skosimp)
       (inst - "n!1" "m!1-n!1" "px!1")
       (("1" (assert)) ("2" (assert))))
      ("2"
       (hide 2)
       (induct "pn")
       (("1" (assert)) ("2" (assert))
        ("3"
         (skosimp*)
         (case-replace "j!1=0")
         (("1" (assert) (hide -1 -2 -3) (inst - "n!1" "px!1") (assert))
          ("2"
           (assert)
           (inst - "n!1" "px!1")
           (assert)
           (inst - "j!1+n!1" "px!1")
           (assert))))))))
    ("2"
     (hide 2)
     (skosimp)
     (expand "atan_pos_le1_ub")
     (expand "atan_series_n")
     (expand "sigma" 1 2)
     (expand "sigma" 1 2)
     (name-replace "SUM" "sigma(0, 2 * n!1, atan_series_term(px!1))")
     (move-terms 1 l)
     (assert)
     (expand "atan_series_term")
     (expand "atan_series_coef")
     (expand "^")
     (expand "expt" 1 3)
     (expand "expt" 1 3)
     (expand "expt" 1 4)
     (case-replace "expt((-1), 1 + 2 * n!1)= -1")
     (("1"
       (hide -1)
       (cancel-by 1 "expt(px!1, 3 + 4 * n!1)")
       (hide -1 2)
       (case "5 > 3 * (px!1 * px!1)")
       (("1"
         (case "4 * n!1 >=  4 * (n!1 * px!1 * px!1)")
         (("1" (assert) (grind-reals))
          ("2"
           (hide -1 2)
           (cancel-by 1 "n!1")
           (cancel-by 2 "4")
           (rewrite "sq" :dir rl)
           (lemma "sq_le")
           (inst?)
           (rewrite "sq_1")
           (assert))))
        ("2"
         (hide 2)
         (rewrite "sq" :dir rl)
         (lemma "sq_le")
         (inst?)
         (assert))))
      ("2"
       (hide-all-but 1)
       (lemma "not_even_m1_pow")
       (inst -1 "1+2*n!1")
       (split -1)
       (("1" (expand "^" -1 1) (propax)) ("2" (hide 1) (grind))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: closer bounds
script:
  (""
   (skosimp)
   (expand "pi_lbn")
   (expand "pi_ubn")
   (lemma "atan_1")
   (lemma "atan_pos_le1_bounds" ("x" "1/5" "n" "n!1"))
   (lemma "atan_pos_le1_bounds" ("x" "1/239" "n" "n!1"))
   (assert)
   (flatten)
   (rewrite "pi_value")
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "atan_pos_lb")
   (expand "atan_pos_ub")
   (case-replace "x!1<=1")
   (("1" (lemma "atan_pos_le1_bounds" ("x" "x!1" "n" "n!1")) (assert))
    ("2"
     (assert)
     (lemma "atan_inv" ("px" "x!1"))
     (lemma "pi_bounds" ("n" "n!1"))
     (lemma "atan_pos_le1_bounds" ("x" "1/x!1" "n" "n!1"))
     (rewrite "div_mult_pos_lt2" -1)
     (rewrite "div_mult_pos_le1" -1)
     (flatten)
     (assert)
     (expand "max")
     (lift-if)
     (assert)
     (lift-if)
     (assert)
     (ground)
     (("1"
       (expand "atan_pos_le1_lb")
       (lemma "atan_strict_increasing")
       (expand "strict_increasing?")
       (inst - "1" "x!1")
       (assert)
       (assert)
       (invoke (case "%1 <= %2") (! 1 1) (! -1 1))
       (("1" (assert))
        ("2"
         (hide-all-but 1)
         (lemma "atan_pos_le1_bounds")
         (expand "atan_pos_le1_lb")
         (inst - "n!1" "1")
         (assert))))
      ("2" (lift-if) (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "increasing?")
   (skolem 1 ("xx" "yy"))
   (flatten)
   (expand "atan_lb")
   (assert)
   (expand "atan_pos_lb")
   (expand "atan_pos_le1_ub")
   (expand "atan_pos_le1_lb")
   (expand "atan_pos_ub")
   (expand "atan_pos_le1_ub")
   (expand "atan_pos_le1_lb")
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (assert)
   (ground)
   (("1" (lemma "atan_series_n_increasing") (inst?) (assert))
    ("2"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "xx" "1")
     (assert))
    ("3"
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "1/yy" "1/xx")
     (("1"
       (ground)
       (("1" (expand "max") (lift-if) (lift-if) (lift-if) (assert))
        ("2" (cross-mult 1)) ("3" (cross-mult 1))))
      ("2" (cross-mult 1)) ("3" (cross-mult 1))))
    ("4"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "xx" "yy")
     (assert)
     (replace -4)
     (rewrite "atan_series_n_a0"))
    ("5"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "xx" "1")
     (assert)
     (replace -3)
     (rewrite "atan_series_n_a0")
     (assert))
    ("6"
     (lemma "atan_series_n_increasing")
     (inst-cp - "2*n" "0" "-xx")
     (inst - "1+2*n" "0" "yy")
     (assert)
     (rewrite "atan_series_n_a0")
     (rewrite "atan_series_n_a0")
     (assert))
    ("7"
     (lemma "atan_series_n_increasing")
     (inst-cp - "2*n" "0" "-xx")
     (inst - "1+2*n" "0" "1")
     (assert)
     (rewrite "atan_series_n_a0")
     (rewrite "atan_series_n_a0")
     (assert))
    ("8"
     (lemma "atan_series_n_increasing")
     (inst-cp - "2*n" "0" "-xx")
     (assert)
     (rewrite "atan_series_n_a0")
     (assert))
    ("9"
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "-yy" "-xx")
     (assert))
    ("10"
     (invoke (case "%1 >= %2 AND %3 >= 0") (! 1 1 1 2 1) (! 1 1 1 2 2)
      (! 1 2))
     (("1" (flatten) (assert))
      ("2"
       (hide 2)
       (split)
       (("1"
         (lemma "atan_series_n_increasing")
         (inst - "1+2*n" "1/(-xx)" "1")
         (("1"
           (assert)
           (ground)
           (("1"
             (lemma "atan_bounds")
             (inst - "1+2*n" "1")
             (flatten)
             (expand "atan_lb" -1)
             (expand "atan_pos_lb")
             (expand "atan_pos_le1_lb")
             (invoke (case "%1 <= %2") (! -3 2) (! 1 1))
             (("1" (assert))
              ("2"
               (hide-all-but 1)
               (lemma "atan_bounds")
               (inst - "n" "1")
               (flatten)
               (case "NOT atan(1) = pi/4")
               (("1"
                 (hide-all-but 1)
                 (expand "pi")
                 (expand "atan")
                 (assert))
                ("2"
                 (expand "atan_lb")
                 (expand "atan_pos_lb")
                 (expand "atan_pos_le1_lb")
                 (case "atan(1) <= pi/2")
                 (("1"
                   (assert)
                   (lemma "pi_bounds")
                   (inst - "n")
                   (flatten)
                   (assert))
                  ("2" (assert))))))))
            ("2" (cross-mult 1))))
          ("2" (cross-mult 1))))
        ("2"
         (lemma "atan_series_n_increasing")
         (inst - "1+2*n" "0" "yy")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))))))
    ("11"
     (invoke (case "%1 >= 0 AND %2 >= 0") (! 2 1 1) (! 2 2 1))
     (("1" (flatten) (assert))
      ("2"
       (hide 3)
       (split +)
       (("1"
         (assert)
         (lemma "atan_series_n_increasing")
         (inst - "2*n" "0" "1")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))
        ("2"
         (lemma "atan_series_n_increasing")
         (inst - "1+2*n" "0" "1")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))))))
    ("12"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "1/(-xx)" "1")
     (("1"
       (assert)
       (ground)
       (("1"
         (lemma "atan_bounds")
         (inst - "n" "1")
         (expand "atan_lb")
         (expand "atan_pos_lb")
         (expand "atan_pos_le1_lb")
         (flatten)
         (lemma "pi_bounds")
         (inst - "n")
         (assert))
        ("2" (cross-mult 1))))
      ("2" (cross-mult 1))))
    ("13"
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "-yy" "1")
     (assert))
    ("14"
     (neg-formula 2)
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "1/-xx" "1/-yy")
     (("1"
       (ground)
       (("1" (expand "max") (lift-if) (lift-if) (lift-if) (assert))
        ("2" (cross-mult 1)) ("3" (cross-mult 1))))
      ("2" (cross-mult 1)) ("3" (cross-mult 1))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "increasing?")
   (skolem 1 ("xx" "yy"))
   (flatten)
   (expand "atan_ub")
   (assert)
   (expand "atan_pos_ub")
   (expand "atan_pos_le1_ub")
   (expand "atan_pos_le1_lb")
   (expand "atan_pos_lb")
   (expand "atan_pos_le1_ub")
   (expand "atan_pos_le1_lb")
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (lift-if)
   (assert)
   (ground)
   (("1" (lemma "atan_series_n_increasing") (inst?) (assert))
    ("2"
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "xx" "1")
     (assert))
    ("3"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "1/yy" "1/xx")
     (("1"
       (ground)
       (("1" (expand "max") (lift-if) (lift-if) (lift-if) (assert))
        ("2" (cross-mult 1)) ("3" (cross-mult 1))))
      ("2" (cross-mult 1)) ("3" (cross-mult 1))))
    ("4"
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "xx" "yy")
     (assert)
     (replace -4)
     (rewrite "atan_series_n_a0"))
    ("5"
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "xx" "1")
     (assert)
     (replace -3)
     (rewrite "atan_series_n_a0")
     (assert))
    ("6"
     (lemma "atan_series_n_increasing")
     (inst-cp - "1+2*n" "0" "-xx")
     (inst - "2*n" "0" "yy")
     (assert)
     (rewrite "atan_series_n_a0")
     (rewrite "atan_series_n_a0")
     (assert))
    ("7"
     (lemma "atan_series_n_increasing")
     (inst-cp - "1+2*n" "0" "-xx")
     (inst - "2*n" "0" "1")
     (assert)
     (rewrite "atan_series_n_a0")
     (rewrite "atan_series_n_a0")
     (assert))
    ("8"
     (lemma "atan_series_n_increasing")
     (inst-cp - "1+2*n" "0" "-xx")
     (assert)
     (rewrite "atan_series_n_a0")
     (assert))
    ("9"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "-yy" "-xx")
     (assert))
    ("10"
     (invoke (case "%1 >=0 AND %2 >= 0") (! 1 1 1 1) (! 1 2))
     (("1" (flatten) (assert))
      ("2"
       (hide 2)
       (split)
       (("1"
         (lemma "atan_series_n_increasing")
         (inst - "1+2*n" "0" "1")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))
        ("2"
         (lemma "atan_series_n_increasing")
         (inst - "2*n" "0" "yy")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))))))
    ("11"
     (invoke (case "%1 >= 0 AND %2 >= 0") (! 2 1 1) (! 2 2 1))
     (("1" (flatten) (assert))
      ("2"
       (hide 3)
       (split +)
       (("1"
         (assert)
         (lemma "atan_series_n_increasing")
         (inst - "1+2*n" "0" "1")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))
        ("2"
         (lemma "atan_series_n_increasing")
         (inst - "2*n" "0" "1")
         (assert)
         (rewrite "atan_series_n_a0")
         (assert))))))
    ("12"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "0" "1")
     (assert)
     (rewrite "atan_series_n_a0")
     (assert))
    ("13"
     (lemma "atan_series_n_increasing")
     (inst - "1+2*n" "-yy" "1")
     (assert))
    ("14"
     (neg-formula 2)
     (lemma "atan_series_n_increasing")
     (inst - "2*n" "1/-xx" "1/-yy")
     (("1"
       (ground)
       (("1" (expand "max") (lift-if) (lift-if) (lift-if) (assert))
        ("2" (cross-mult 1)) ("3" (cross-mult 1))))
      ("2" (cross-mult 1)) ("3" (cross-mult 1))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "atan_pos_lb")
   (case-replace "px!1 <= 1")
   (("1"
     (lemma "atan_pos_le1_lb_inc" ("px" "px!1" "n" "n!1" "m" "m!1"))
     (assert))
    ("2"
     (assert)
     (case "1<px!1")
     (("1"
       (hide 1)
       (lemma "div_mult_pos_lt1" ("py" "px!1" "z" "1" "x" "1"))
       (assert)
       (lemma "atan_pos_le1_ub_dec" ("px" "1/px!1" "n" "n!1" "m" "m!1"))
       (assert)
       (lemma "pi_lb_inc" ("n" "n!1" "m" "m!1"))
       (assert)
       (lemma "atan_pos_le1_lb_inc")
       (inst - "m!1" "n!1" "1")
       (assert)
       (expand "max")
       (lift-if)
       (lift-if)
       (lift-if)
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "atan_pos_ub")
   (case-replace "px!1 <= 1")
   (("1"
     (lemma "atan_pos_le1_ub_dec" ("px" "px!1" "n" "n!1" "m" "m!1"))
     (assert))
    ("2"
     (assert)
     (case "1<px!1")
     (("1"
       (hide 1)
       (lemma "div_mult_pos_lt1" ("py" "px!1" "z" "1" "x" "1"))
       (assert)
       (lemma "atan_pos_le1_lb_inc" ("px" "1/px!1" "n" "n!1" "m" "m!1"))
       (assert)
       (lemma "pi_ub_dec" ("n" "n!1" "m" "m!1"))
       (lemma "atan_pos_le1_ub_dec")
       (inst - "m!1" "n!1" "1")
       (assert)
       (expand "max")
       (lift-if)
       (lift-if)
       (lift-if)
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "pi_lbn")
   (rewrite "pi_value")
   (rewrite "atan_1")
   (lemma "atan_pos_le1_bounds" ("x" "1/5" "n" "n!1"))
   (lemma "atan_pos_le1_bounds" ("x" "1/239" "n" "n!1"))
   (assert)
   (flatten)
   (hide -1 -4)
   (expand "atan_pos_le1_ub")
   (expand "atan_pos_le1_lb")
   (lemma "atan_series" ("x" "1/5" "n" "2*n!1+1"))
   (expand "abs" -1 1)
   (assert)
   (lemma "atan_series" ("x" "1/239" "n" "2*n!1"))
   (expand "abs" -1 1)
   (lemma "expt_pos" ("px" "1/5" "i" "5+4*n!1"))
   (lemma "posreal_div_posreal_is_posreal"
    ("px" "(1 / 5) ^ (5 + 4 * n!1)" "py" "5 + 4 * n!1"))
   (expand "abs" -4)
   (lemma "expt_pos" ("px" "1/239" "i" "3+4*n!1"))
   (lemma "posreal_div_posreal_is_posreal"
    ("px" "(1 / 239) ^ (3 + 4 * n!1)" "py" "3 + 4 * n!1"))
   (expand "abs" -5)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "pi_ubn")
   (rewrite "pi_value")
   (rewrite "atan_1")
   (lemma "atan_pos_le1_bounds" ("x" "1/5" "n" "n!1"))
   (lemma "atan_pos_le1_bounds" ("x" "1/239" "n" "n!1"))
   (assert)
   (flatten)
   (hide -2 -3)
   (expand "atan_pos_le1_ub")
   (expand "atan_pos_le1_lb")
   (lemma "atan_series" ("x" "1/239" "n" "2*n!1+1"))
   (expand "abs" -1 1)
   (assert)
   (lemma "atan_series" ("x" "1/5" "n" "2*n!1"))
   (expand "abs" -1 1)
   (lemma "expt_pos" ("px" "1/239" "i" "5+4*n!1"))
   (lemma "posreal_div_posreal_is_posreal"
    ("px" "(1 / 239) ^ (5 + 4 * n!1)" "py" "5 + 4 * n!1"))
   (expand "abs" -4)
   (lemma "expt_pos" ("px" "1/5" "i" "3+4*n!1"))
   (lemma "posreal_div_posreal_is_posreal"
    ("px" "(1 / 5) ^ (3 + 4 * n!1)" "py" "3 + 4 * n!1"))
   (expand "abs" -5)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "pi_lbn")
   (expand "atan_pos_le1_lb")
   (expand "atan_pos_le1_ub")
   (expand "atan_series_n")
   (name "SUM1" "sigma(0, 1 + 2 * n!1, atan_series_term(1 / 5))")
   (replace -1)
   (name "SUM2" "sigma(0, 2 * n!1, atan_series_term(1 / 239))")
   (replace -1)
   (expand "sigma" 1)
   (expand "sigma" 1)
   (replace -1)
   (replace -2)
   (assert)
   (expand "atan_series_term")
   (expand "atan_series_coef")
   (hide -1 -2)
   (lemma "expt_times" ("n0x" "-1" "i" "2" "j" "n!1+1"))
   (expand "^" -1 2)
   (expand "expt" -1)
   (expand "expt" -1)
   (expand "expt" -1)
   (rewrite "sq_rew")
   (rewrite "sq_neg")
   (rewrite "expt_1i")
   (replace -1)
   (assert)
   (lemma "expt_plus" ("n0x" "-1" "i" "2+2*n!1" "j" "1"))
   (replace -2)
   (rewrite "expt_x1")
   (replace -1)
   (lemma "expt_plus" ("n0x" "-1" "i" "1" "j" "2*n!1"))
   (rewrite "expt_x1")
   (lemma "expt_times" ("n0x" "-1" "i" "2" "j" "n!1"))
   (expand "^" -1 2)
   (expand "expt" -1)
   (expand "expt" -1)
   (expand "expt" -1)
   (rewrite "sq_rew")
   (rewrite "sq_neg")
   (rewrite "expt_1i")
   (replace -1)
   (replace -2)
   (hide-all-but 1)
   (lemma "expt_plus" ("n0x" "1/5" "i" "2" "j" "5+4*n!1"))
   (lemma "expt_plus" ("n0x" "1/239" "i" "2" "j" "3+4*n!1"))
   (expand "^" -1 2)
   (expand "^" -2 2)
   (expand "expt")
   (expand "expt")
   (expand "expt")
   (replace -1)
   (replace -2)
   (hide -1 -2)
   (assert)
   (name-replace "DRL1" "(1 / 239) ^ (3 + 4 * n!1)")
   (name-replace "DRL2" "(1 / 5) ^ (5 + 4 * n!1)")
   (assert)
   (case-replace
    "16 * ((1 / 5 * (1 / 5) * (-1 / (7 + 4 * n!1))) * DRL2) = -16*(DRL2 * (1 / (175 + 100 * n!1)))")
   (("1"
     (hide -1)
     (assert)
     (case-replace
      "-4 * (DRL1 * (-1 / (3 + 4 * n!1))) = 4 * (DRL1 * (1 / (3 + 4 * n!1)))")
     (("1"
       (hide -1)
       (assert)
       (assert)
       (lemma "both_sides_times1"
        ("n0z"
         "DRL1"
         "x"
         "-4 * ((1 / 239 * (1 / 239) * (1 / (5 + 4 * n!1))))"
         "y"
         "-4*(1 / (285605 + 228484 * n!1))"))
       (replace -1 1)
       (hide -1)
       (assert))
      ("2" (hide 2) (assert))))
    ("2"
     (hide 2)
     (assert)
     (grind)
     (lemma "both_sides_times1"
      ("n0z"
       "DRL2"
       "x"
       "16 * ((1 / 5 * (1 / 5) * (-1 / (7 + 4 * n!1))))"
       "y"
       "-16 *(1 / (175 + 100 * n!1))"))
     (replace -1 1)
     (hide -1)
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (invoke (name "K1" "%1") (! 1 2))
   (replaces -1)
   (expand "pi_ubn")
   (expand "atan_pos_le1_lb")
   (expand "atan_pos_le1_ub")
   (expand "atan_series_n")
   (expand "sigma" + 1)
   (expand "sigma" + 1)
   (expand "sigma" + 2)
   (expand "sigma" + 2)
   (expand "atan_series_term")
   (expand "atan_series_coef")
   (case "FORALL (nn:nat): (-1)^(2*nn+1) = -1 AND (-1)^(2*nn)=1")
   (("1"
     (inst-cp - "n+1")
     (flatten)
     (assert)
     (replaces -2)
     (replaces -2)
     (inst - "n")
     (flatten)
     (replaces -1)
     (replaces -1)
     (assert)
     (expand "K1")
     (assert))
    ("2"
     (hide 2)
     (induct "nn")
     (("1" (grind)) ("2" (grind))
      ("3"
       (skeep)
       (expand "^")
       (expand "expt" +)
       (expand "expt" +)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skoletin 1)
   (label "xdiffname" -1)
   (rewrite "pi_lb_diff")
   (name "A1" "(1/5)^(4*n+5)")
   (name "A2" "(1/239)^(4*n+3)")
   (replace -2)
   (replace -1)
   (name "B1" "1/(4*n+5)")
   (replace -1)
   (name "B2" "1/(4*n+3)")
   (replace -1)
   (name "C1" "1/(25*(4*n+7))")
   (replace -1)
   (name "C2" "1/(57121*(4*n+5))")
   (replace -1)
   (name "D1" "B1-C1")
   (name "D2" "B2-C2")
   (case "A1 > 0 AND A2 > 0 AND B1 > 0 AND B2 > 0 AND C1 > 0 AND C2 > 0 AND B1 > 0 AND B2 > 0 AND A1 > 0 AND A2 > 0 AND D1 > 0 AND D2 > 0")
   (("1"
     (label "tps" -1)
     (hide "tps")
     (case "NOT xdiff = 16*A1*D1 + 4*A2*D2")
     (("1"
       (assert)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (replaces -1 :dir rl)
       (assert))
      ("2"
       (replace -1)
       (hide "xdiffname")
       (hide -1)
       (reveal "tps")
       (flatten)
       (split)
       (("1"
         (case "16*A1*D1 > 14 * (1 / 5) ^ (5 * n + 5) AND 4*A2*D2 > 0")
         (("1" (ground))
          ("2"
           (hide 2)
           (split)
           (("1"
             (case "A1*D1 > (1 / 5) ^ (5 * n + 5)")
             (("1" (assert))
              ("2"
               (hide 2)
               (case "D1 > (1/5)^n")
               (("1"
                 (mult-by -1 "A1")
                 (expand "A1" (-1 1))
                 (rewrite "expt_plus" :dir rl)
                 (assert))
                ("2"
                 (hide 2)
                 (expand "D1")
                 (expand "B1" +)
                 (expand "C1" +)
                 (rewrite "div_expt")
                 (case "1^n=1")
                 (("1"
                   (replace -1)
                   (case "(1/2)*(1/(5+4*n)) > 1/5^n AND 1 / (175 + 100 * n) < (1/2)*(1/(5+4*n))")
                   (("1" (flatten) (assert))
                    ("2"
                     (hide 2)
                     (split)
                     (("1"
                       (cross-mult 1)
                       (case "FORALL (nk:nat): 5^(nk+5) > 10+8*(nk+5)")
                       (("1"
                         (inst - "n-5")
                         (("1" (assert)) ("2" (assert))))
                        ("2"
                         (induct "nk")
                         (("1" (assert) (hide-all-but 1) (grind))
                          ("2"
                           (skeep)
                           (assert)
                           (expand "^")
                           (expand "expt" 1)
                           (mult-by -1 "5")
                           (assert))))))
                      ("2" (cross-mult 1))))))
                  ("2"
                   (assert)
                   (case "FORALL (nk:nat): 1^nk = 1")
                   (("1" (inst?))
                    ("2"
                     (induct "nk")
                     (("1" (hide-all-but 1) (grind))
                      ("2"
                       (skeep)
                       (expand "^")
                       (expand "expt" +)
                       (assert))))))))))))
            ("2"
             (assert)
             (lemma "posreal_times_posreal_is_posreal")
             (inst - "A2" "D2")
             (assert))))))
        ("2"
         (assert)
         (case "A2*D2 < (1 / 5) ^ (3 + 4 * n) AND A1*D1 < (1/25)*(1 / 5) ^ (3 + 4 * n)")
         (("1" (flatten) (assert))
          ("2"
           (hide 2)
           (split)
           (("1"
             (expand "D2" +)
             (lemma "posreal_times_posreal_is_posreal")
             (inst - "A2" "C2")
             (case "A2*B2 < (1 / 5) ^ (3 + 4 * n)")
             (("1" (assert))
              ("2"
               (hide (-1 2))
               (case "A2 < (1 / 5) ^ (3 + 4 * n)")
               (("1"
                 (case "B2 < 1")
                 (("1" (mult-ineq -1 -2) (assert))
                  ("2" (hide 2) (expand "B2" +) (cross-mult 1))))
                ("2"
                 (hide 2)
                 (expand "A2" +)
                 (rewrite "div_expt")
                 (rewrite "div_expt")
                 (case "1^(3+4*n) = 1")
                 (("1"
                   (replaces -1)
                   (cross-mult 1)
                   (lemma "both_sides_expt_pos_lt_aux")
                   (inst - "2+4*n" _ _)
                   (inst - "5" "239")
                   (expand "^")
                   (ground))
                  ("2"
                   (case "FORALL (nk:nat): 1^nk = 1")
                   (("1" (inst?))
                    ("2"
                     (hide-all-but 1)
                     (induct "nk")
                     (("1" (expand "^") (expand "expt") (propax))
                      ("2"
                       (skeep)
                       (expand "^")
                       (expand "expt" +)
                       (assert))))))))))))
            ("2"
             (case "A1 <= (1/25) * (1 / 5) ^ (3 + 4 * n) AND D1 < 1")
             (("1" (flatten) (mult-ineq -1 -2) (assert))
              ("2"
               (hide 2)
               (split)
               (("1"
                 (expand "A1" +)
                 (expand "^")
                 (expand "expt" + 1)
                 (expand "expt" + 1)
                 (assert))
                ("2"
                 (case "B1 < 1")
                 (("1" (assert))
                  ("2"
                   (hide 2)
                   (expand "B1" +)
                   (cross-mult 1))))))))))))))))
    ("2"
     (hide 2)
     (split)
     (("1" (expand "A1" +) (rewrite "expt_pos"))
      ("2" (expand "A2" +) (rewrite "expt_pos"))
      ("3" (expand "B1" +) (cross-mult 1))
      ("4" (expand "B2" +) (cross-mult 1))
      ("5" (expand "C1" +) (cross-mult 1))
      ("6" (expand "C2" +) (cross-mult 1))
      ("7" (expand "B1" +) (cross-mult 1))
      ("8" (expand "B2" +) (cross-mult 1))
      ("9" (expand "A1" +) (cross-mult 1))
      ("10" (expand "A2" +) (rewrite "expt_pos"))
      ("11"
       (case "B1 > C1")
       (("1" (assert))
        ("2" (expand "B1" +) (expand "C1" +) (cross-mult 1))))
      ("12"
       (case "B2 > C2")
       (("1" (assert))
        ("2" (expand "B2" +) (expand "C2" +) (cross-mult 1))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "NOT FORALL (nb6:below(6)): LET xquot = pi_lbn(nb6) / pi_lbn(nb6 + 1) IN
                   1 - 14.5 * (1 / 5) ^ (4 * nb6 + 3) <= xquot AND xquot <= 1")
   (("1" (hide 2) (eval-formula))
    ("2"
     (skeep)
     (case "NOT n>5")
     (("1" (inst - "n") (assert))
      ("2"
       (hide -2)
       (skoletin 1)
       (name "xdiff" "pi_lbn(n+1)-pi_lbn(n)")
       (case "NOT xquot = 1 - xdiff/pi_lbn(n+1)")
       (("1" (assert) (replace -2) (replace -1 :dir rl) (assert))
        ("2"
         (case "xquot <= 1")
         (("1"
           (assert)
           (case "xdiff/pi_lbn(n+1) <= 14.5 * (1 / 5) ^ (3 + 4 * n)")
           (("1" (assert))
            ("2"
             (hide 2)
             (lemma "pi_lb_diff_bounds")
             (inst?)
             (assert)
             (replace -4)
             (flatten)
             (case "25/8 <= pi_lbn(1+n)")
             (("1" (cross-mult 1) (mult-ineq -1 -3) (assert))
              ("2"
               (hide-all-but 1)
               (case "FORALL (kk:nat): 25/8 <= pi_lbn(kk)")
               (("1" (inst?))
                ("2"
                 (hide 2)
                 (induct "kk")
                 (("1" (eval-formula))
                  ("2"
                   (skeep)
                   (lemma "pi_lb_inc")
                   (inst - "j+1" "j")
                   (assert))))))))))
          ("2"
           (lemma "pi_lb_inc")
           (inst - "n+1" "n")
           (assert)
           (expand "xquot" 1)
           (cross-mult 1))))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (skoletin 1)
   (label "xdiffname" -1)
   (rewrite "pi_ub_diff")
   (case "(1/5)^(5+4*n) = (1/25)*(1/5)^(3+4*n)")
   (("1"
     (replaces -1)
     (assert)
     (case "(1/239)^(7+4*n) = (1/239^2)*(1/239)^(5+4*n)")
     (("1"
       (replaces -1)
       (assert)
       (invoke (name "K1" "%1") (! -1 2 1))
       (invoke (name "K2" "%1") (! -2 2 2))
       (invoke (name "K3" "%1") (! -3 2 3))
       (invoke (name "K4" "%1") (! -4 2 4))
       (replace -1)
       (replace -2)
       (replace -3)
       (replace -4)
       (case "K1/2 >= 32 * (1 / 5) ^ (3 + 5 * n)")
       (("1"
         (case "K2 < K1")
         (("1"
           (case "2*K1 < (7/5) * (1 / 5) ^ (3 + 4 * n)")
           (("1"
             (assert)
             (case "K4 < K2/2")
             (("1"
               (case "K3 < K1/2")
               (("1"
                 (assert)
                 (case "K1 > 0 AND K2 > 0 AND K4 > 0 AND K3 > 0")
                 (("1"
                   (flatten)
                   (case "K1 + K2 - K4 - K3 >= K1/2")
                   (("1"
                     (case "K1 + K2 - K4 - K3 < 2*K1")
                     (("1"
                       (assert)
                       (replace "xdiffname" :dir rl)
                       (assert)
                       (grind :exclude "^"))
                      ("2" (assert))))
                    ("2" (assert))))
                  ("2" (assert))))
                ("2"
                 (assert)
                 (hide (-1 -2 -3 -4 -5 -6 2))
                 (hide (-1 -2 -3))
                 (expand "K1")
                 (expand "K3")
                 (case "1/(5+4*n) < 1/(3+4*n)")
                 (("1"
                   (case "16 * ((1 / 5) ^ (3 + 4 * n) * (1 / 25)) <
                                                                                                                                                                                           16 * (((1 / 5) ^ (3 + 4 * n)) ) / 2")
                   (("1" (mult-ineq -1 -2) (assert)) ("2" (assert))))
                  ("2" (cross-mult 1))))))
              ("2"
               (hide (-1 -2 -3 -4 -5))
               (hide (-1 -2 -3))
               (expand "K4")
               (expand "K2")
               (case "1/(7+4*n) < 1/(5+4*n)")
               (("1"
                 (case "4 * ((1 / 239) ^ (5 + 4 * n) * (1 / 239 ^ 2)) <
                                                                                                                                                                           4 * (((1 / 239) ^ (5 + 4 * n))) / 2")
                 (("1" (mult-ineq -1 -2) (assert))
                  ("2"
                   (assert)
                   (expand "^" + 2)
                   (expand "expt" 1)
                   (expand "expt" 1)
                   (expand "expt" 1)
                   (assert))))
                ("2" (cross-mult 1))))))
            ("2"
             (hide (-1 -2 -3 -4 -5 2))
             (hide -1)
             (hide -1)
             (expand "K1")
             (case "1/(3+4*n) <= 1/23")
             (("1" (mult-by -1 "(1/5)^(3+4*n)") (assert))
              ("2"
               (hide 2)
               (case "EXISTS (kk:nat): n = kk+5")
               (("1" (skeep -1) (replaces -1) (cross-mult 1))
                ("2" (inst + "n-5") (assert))))))))
          ("2"
           (hide (-1 -2 -3 -4 -5 -6 2))
           (expand "K1")
           (expand "K2")
           (case "(1/239)^(4*n+5) < (1/5)^(3+4*n) AND 1/(5+4*n) < 1/(3+4*n)")
           (("1" (flatten) (mult-ineq -1 -2) (assert))
            ("2"
             (hide 2)
             (split)
             (("1"
               (lemma "both_sides_expt_pos_lt_aux")
               (inst - "2+4*n" "1/239" "1/5")
               (assert)
               (expand "^")
               (expand "expt" + 1)
               (expand "expt" + 1)
               (assert))
              ("2" (cross-mult 1))))))))
        ("2"
         (hide (-1 -2 -3 -4 -5 2))
         (expand "K1")
         (assert)
         (lemma "expt_plus")
         (inst - "3+4*n" "n" "1/5")
         (assert)
         (replace -1)
         (case "(1/(3+4*n)) > 4*(1/5)^n")
         (("1" (mult-by -1 "8 * (((1 / 5) ^ (3 + 4 * n)))") (assert))
          ("2"
           (hide-all-but (-2 1))
           (case "FORALL (kk:nat): 1/(3+4*(kk+5)) > 4*(1/5)^(kk+5)")
           (("1" (inst - "n-5") (assert))
            ("2"
             (hide 2)
             (induct "kk")
             (("1" (assert) (grind))
              ("2"
               (skeep)
               (expand "^")
               (expand "expt" +)
               (assert)
               (case "(23+4*j)/(27+4*j) > 4/5")
               (("1" (cross-mult -2) (cross-mult 1))
                ("2" (cross-mult 1))))))))))))
      ("2"
       (hide (-1 2))
       (lemma "expt_plus")
       (inst - "2" "5+4*n" "1/239")
       (assert)
       (replaces -1)
       (rewrite "div_expt")
       (rewrite "div_expt")
       (assert)
       (case "1^2 = 1")
       (("1" (assert)) ("2" (hide-all-but 1) (grind))))))
    ("2"
     (hide-all-but 1)
     (lemma "expt_plus")
     (inst - "3+4*n" "2" "1/5")
     (assert)
     (replaces -1)
     (rewrite "div_expt")
     (rewrite "div_expt")
     (case "FORALL (kk:nat): 1^kk = 1")
     (("1"
       (inst?)
       (replaces -1)
       (case "1^2 = 1")
       (("1"
         (replaces -1)
         (assert)
         (case "5^2 = 25")
         (("1" (replaces -1) (assert)) ("2" (hide-all-but 1) (grind))))
        ("2" (hide-all-but 1) (grind))))
      ("2"
       (hide 2)
       (induct "kk")
       (("1" (grind))
        ("2" (skeep) (expand "^") (expand "expt" 1) (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "NOT FORALL (nn:subrange(0,15)): LET xquot = pi_ubn(nn + 1) / pi_ubn(nn) IN
                                        1 - (9/5) * (1 / 5) ^ (4 * nn + 3) <= xquot AND xquot <= 1")
   (("1" (eval-formula))
    ("2"
     (skeep)
     (case "NOT n>=15")
     (("1" (inst - "n") (assert))
      ("2"
       (hide -2)
       (lemma "pi_ub_diff_bounds")
       (inst - "n")
       (split -)
       (("1"
         (skoletin 1)
         (skoletin -2 :old? t)
         (flatten)
         (split)
         (("1"
           (mult-by -3 "1/pi_ubn(n)")
           (assert)
           (case "NOT xdiff * (1/pi_ubn(n)) = 1 - xquot")
           (("1" (assert))
            ("2"
             (replaces -1)
             (assert)
             (case "1/pi_ubn(n) < 1/2")
             (("1" (mult-by -1 " ((1 / 5) ^ (3 + 4 * n))") (assert))
              ("2"
               (case "FORALL (nn:nat): pi_ubn(nn+15) > 2")
               (("1" (inst - "n-15") (assert) (cross-mult 1))
                ("2"
                 (hide-all-but 1)
                 (case "FORALL (nn:nat): pi_lbn(nn+15) > 2")
                 (("1"
                   (skeep)
                   (inst - "nn")
                   (lemma "pi_bounds")
                   (inst - "nn+15")
                   (assert)
                   (ground))
                  ("2"
                   (hide 2)
                   (induct "nn")
                   (("1" (assert) (eval-formula))
                    ("2"
                     (skeep)
                     (assert)
                     (lemma "pi_lb_inc")
                     (inst - "16+j" "15+j")
                     (assert))))))))))))
          ("2"
           (expand "xquot" +)
           (cross-mult 1)
           (lemma "pi_ub_dec")
           (inst - "1+n" "n")
           (assert))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_basic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "sin")
   (lemma "div_cancel1" ("x" "1/2" "n0z" "pi"))
   (replace -1 1)
   (lemma "floor_val" ("i" "1" "j" "2" "k" "0"))
   (split -1)
   (("1"
     (replace -1)
     (assert)
     (expand "sin_phase")
     (lemma "div_cancel1" ("x" "2" "n0z" "pi"))
     (replace -1)
     (rewrite "sin_value_0")
     (rewrite "floor_int" 1)
     (assert))
    ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_basic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "c!1=0")
   (("1"
     (replace -1)
     (inst + "0")
     (rewrite "zero_times1" 1)
     (lemma "sq_eq_0" ("a" "a!1"))
     (lemma "sq_eq_0" ("a" "b!1"))
     (rewrite "sq_0")
     (assert))
    ("2"
     (typepred "sq(b!1)")
     (typepred "sq(a!1)")
     (lemma "sq_nz_pos" ("nz" "c!1"))
     (("1"
       (case "sq(a!1)<=sq(c!1)")
       (("1"
         (lemma "div_mult_pos_le1"
          ("z" "sq(a!1)" "py" "sq(c!1)" "x" "1"))
         (("1"
           (lemma "sq_div" ("a" "a!1" "d" "c!1"))
           (assert)
           (replace -1 -2 rl)
           (hide -1)
           (lemma "sq_le_abs" ("a" "a!1/c!1" "b" "1"))
           (rewrite "sq_1")
           (replace -2 -1)
           (flatten -1)
           (expand "abs" -1 2)
           (case "sq(b!1) <= sq(c!1)")
           (("1"
             (lemma "div_mult_pos_le1"
              ("z" "sq(b!1)" "py" "sq(c!1)" "x" "1"))
             (replace -2 -1)
             (flatten -1)
             (lemma "sq_le_abs" ("a" "b!1/c!1" "b" "1"))
             (rewrite "sq_div" -1)
             (rewrite "sq_1" -1)
             (replace -2 -1)
             (flatten)
             (expand "abs" -1 2)
             (case "sq(a!1/c!1)+sq(b!1/c!1) =1")
             (("1"
               (case "FORALL (x,y: {x: nnreal | x <= 1}): sq(x) + sq(y) = 1 => (EXISTS (z: {z: nnreal | z <= pi / 2}): x = cos(z) & y = sin(z))")
               (("1"
                 (expand "abs" (-3 -6))
                 (case "b!1 / c!1 < 0")
                 (("1"
                   (case "a!1 / c!1 < 0")
                   (("1"
                     (inst - "-(a!1/c!1)" "-(b!1/c!1)")
                     (("1"
                       (rewrite "sq_neg")
                       (rewrite "sq_neg")
                       (assert)
                       (skosimp*)
                       (inst + "z!1+pi")
                       (lemma "neg_cos" ("a" "z!1"))
                       (lemma "neg_sin" ("a" "z!1"))
                       (assert))
                      ("2" (assert)) ("3" (assert))))
                    ("2"
                     (inst - "-(b!1/c!1)" "a!1/c!1")
                     (("1"
                       (rewrite "sq_neg")
                       (assert)
                       (skosimp*)
                       (lemma "cos_sin" ("a" "z!1-pi/2"))
                       (lemma "sin_cos" ("a" "z!1-pi/2"))
                       (assert)
                       (inst + "z!1-pi/2")
                       (assert))
                      ("2" (assert)) ("3" (assert))))))
                  ("2"
                   (case "a!1 / c!1 < 0")
                   (("1"
                     (inst - "b!1/c!1" "-(a!1/c!1)")
                     (("1"
                       (rewrite "sq_neg")
                       (assert)
                       (skosimp*)
                       (rewrite "cos_sin" -2)
                       (rewrite "sin_cos" -3)
                       (inst + "pi/2+z!1")
                       (assert))
                      ("2" (assert)) ("3" (assert))))
                    ("2"
                     (inst - "a!1/c!1" "b!1/c!1")
                     (("1" (assert) (skosimp*) (inst + "z!1") (assert))
                      ("2" (assert)) ("3" (assert))))))))
                ("2"
                 (hide-all-but 1)
                 (skosimp*)
                 (typepred "x!1")
                 (typepred "y!1")
                 (inst + "acos(x!1)")
                 (("1"
                   (case "x!1 = cos(acos(x!1))")
                   (("1"
                     (assert)
                     (typepred "acos(x!1)")
                     (expand ">=" -6)
                     (expand "<=" -6)
                     (split -6)
                     (("1"
                       (lemma "acos_strict_decreasing")
                       (expand "strict_decreasing?")
                       (inst - "0" "x!1")
                       (("1"
                         (assert)
                         (rewrite "acos_0")
                         (expand "cos")
                         (expand "sin")
                         (case "floor(acos(x!1) / (2 * pi)) = 0")
                         (("1"
                           (replace -1)
                           (assert)
                           (lemma "sin_q1" ("x" "acos(x!1)"))
                           (rewrite "phase_sin_q1" -1)
                           (replace -1)
                           (lemma "sin_eqv_sqrt_cos_value"
                            ("q1" "acos(x!1)"))
                           (replace -1 * rl)
                           (rewrite "cos_value_acos" 1)
                           (lemma "sq_eq"
                            ("nna" "y!1" "nnb" "sqrt(1 - sq(x!1))"))
                           (replace -1 1 rl)
                           (rewrite "sq_sqrt")
                           (assert))
                          ("2"
                           (hide -5 2)
                           (lemma "floor_def" ("x" "acos(x!1)/(2*pi)"))
                           (rewrite "div_mult_pos_le2" -1)
                           (flatten)
                           (lemma "div_mult_pos_lt1"
                            ("x"
                             "floor(acos(x!1) / (2 * pi)) + 1"
                             "py"
                             "2*pi"
                             "z"
                             "acos(x!1)"))
                           (replace -1 -3)
                           (hide -1)
                           (name-replace "K1"
                            "floor(acos(x!1) / (2 * pi))")
                           (lemma "trichotomy" ("x" "K1"))
                           (split -1)
                           (("1"
                             (case "K1=1")
                             (("1" (assert))
                              ("2"
                               (case "K1>1")
                               (("1"
                                 (lemma
                                  "both_sides_times_pos_lt1"
                                  ("x" "1" "y" "K1" "pz" "2*pi"))
                                 (assert))
                                ("2" (assert))))))
                            ("2" (propax)) ("3" (assert))))))
                        ("2" (expand "abs") (assert))))
                      ("2"
                       (replace -1 * rl)
                       (rewrite "acos_0")
                       (lemma "sin_pi2")
                       (expand "pi")
                       (replace -1)
                       (rewrite "sq_0")
                       (lemma "sq_eq" ("nna" "y!1" "nnb" "1"))
                       (rewrite "sq_1")
                       (assert))))
                    ("2"
                     (hide 2)
                     (hide -1 -2 -5)
                     (expand "cos")
                     (case "floor(acos(x!1) / (2 * pi))=0")
                     (("1"
                       (replace -1)
                       (assert)
                       (rewrite "cos_phase_acos"))
                      ("2"
                       (hide 2)
                       (typepred "acos(x!1)")
                       (lemma "floor_def" ("x" "acos(x!1) / (2 * pi)"))
                       (rewrite "div_mult_pos_lt1" -1)
                       (rewrite "div_mult_pos_le2" -1)
                       (flatten)
                       (name-replace "K1" "floor(acos(x!1) / (2 * pi))")
                       (lemma "trichotomy" ("x" "K1"))
                       (split -1)
                       (("1"
                         (case "K1=1")
                         (("1" (assert))
                          ("2"
                           (case "K1>1")
                           (("1"
                             (lemma "both_sides_times_pos_lt1"
                              ("x" "1" "y" "K1" "pz" "2*pi"))
                             (assert))
                            ("2" (assert))))))
                        ("2" (propax)) ("3" (assert))))))
                    ("3" (expand "abs") (propax))))
                  ("2"
                   (lemma "acos_strict_decreasing")
                   (expand "strict_decreasing?")
                   (expand ">=" -4)
                   (expand "<=" -4)
                   (split -4)
                   (("1"
                     (inst - "0" "x!1")
                     (("1" (rewrite "acos_0") (assert))
                      ("2" (expand "abs") (assert))))
                    ("2" (replace -1 * rl) (rewrite "acos_0") (assert))))
                  ("3" (expand "abs") (propax))))))
              ("2"
               (hide 3)
               (rewrite "sq_div")
               (rewrite "sq_div")
               (assert))))
            ("2" (assert))))
          ("2" (propax))))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_basic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin")
   (lemma "floor_plus_int" ("x" "a!1/(2*pi)" "i" "j!1"))
   (lemma "div_cancel1" ("x" "j!1" "n0z" "2*pi"))
   (lemma "div_distributes" ("x" "2*j!1*pi" "y" "a!1" "n0z" "2*pi"))
   (replace -2)
   (replace -1)
   (replace -3)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_basic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (split 1)
   (("1"
     (flatten)
     (expand "<=" -3)
     (split -3)
     (("1"
       (expand "sin")
       (case "floor(a!1 / (2 * pi))=0")
       (("1"
         (replace -1)
         (assert)
         (hide -1)
         (lemma "sin_value_bij")
         (expand "bijective?")
         (expand "injective?")
         (flatten)
         (hide -2)
         (inst - "0" "_")
         (("1"
           (rewrite "sin_value_0")
           (lemma "cos_value_strict_decreasing")
           (expand "strict_decreasing?")
           (inst - "_" "pi/2")
           (rewrite "cos_value_pi2")
           (lemma "phases_sin" ("x" "a!1"))
           (split -1)
           (("1"
             (rewrite "sin_q1" -5)
             (inst -3 "a!1")
             (("1" (assert))
              ("2" (expand "abs" 1) (rewrite "phase_sin_q1") (assert))))
            ("2"
             (rewrite "sin_q2" -5)
             (rewrite "phase_sin_q2")
             (inst -2 "a!1-pi/2")
             (("1" (assert) (flatten -1) (assert))
              ("2" (flatten -1) (assert))))
            ("3"
             (rewrite "sin_q3" -5)
             (rewrite "phase_sin_q3")
             (flatten -1)
             (inst -4 "a!1-pi")
             (("1" (assert)) ("2" (expand "abs" 1) (assert))))
            ("4"
             (rewrite "sin_q4" -5)
             (rewrite "phase_sin_q4")
             (inst -2 "a!1-3*pi/2")
             (("1" (assert)) ("2" (assert))))))
          ("2" (expand "abs") (assert))))
        ("2"
         (hide -2 2 3 4)
         (lemma "floor_def" ("x" "a!1/(2*pi)"))
         (rewrite "div_mult_pos_lt1" -1)
         (rewrite "div_mult_pos_le2" -1)
         (flatten)
         (name-replace "K1" "floor(a!1 / (2 * pi))")
         (lemma "trichotomy" ("x" "K1"))
         (split -1)
         (("1"
           (case "K1=1")
           (("1" (assert))
            ("2"
             (case "K1>1")
             (("1"
               (lemma "both_sides_times_pos_lt1"
                ("x" "1" "y" "K1" "pz" "2*pi"))
               (assert))
              ("2" (assert))))))
          ("2" (propax))
          ("3"
           (assert)
           (case "K1=-1")
           (("1" (assert))
            ("2"
             (case "K1<-1")
             (("1"
               (assert)
               (lemma "both_sides_times_pos_lt1"
                ("x" "K1" "y" "-1" "pz" "2*pi"))
               (assert))
              ("2" (assert))))))))))
      ("2" (propax))))
    ("2"
     (flatten)
     (split -1)
     (("1" (replace -1) (rewrite "sin_0"))
      ("2" (replace -1) (rewrite "sin_pi"))
      ("3" (replace -1) (rewrite "sin_2pi"))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_basic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin")
   (split)
   (("1"
     (flatten)
     (lemma "floor_def" ("x" "a!1 / (2 * pi)"))
     (rewrite "div_mult_pos_lt1" -1)
     (rewrite "div_mult_pos_le2" -1)
     (flatten -1)
     (lemma "sin_eq_0_2pi"
      ("a" "a!1 - 2 * (floor(a!1 / (2 * pi)) * pi)"))
     (split -1)
     (("1"
       (flatten -1)
       (hide -2)
       (split -1)
       (("1" (inst + "2 * floor(a!1 / (2 * pi))") (assert))
        ("2" (inst + "2 * (floor(a!1 / (2 * pi))) +1") (assert))
        ("3" (inst + "2 * (floor(a!1 / (2 * pi))) +2") (assert))
        ("4"
         (hide 2)
         (expand "sin")
         (case "(floor((a!1 - 2 * (floor(a!1 / (2 * pi)) * pi)) /
                                                                  (2 * pi))) = 0")
         (("1" (replace -1) (assert))
          ("2"
           (hide 2)
           (lemma "div_cancel1"
            ("x" "floor(a!1 / (2 * pi))" "n0z" "2*pi"))
           (replace -1)
           (lemma "minus_div2"
            ("x"
             "a!1"
             "y"
             "2 * (floor(a!1 / (2 * pi)) * pi)"
             "n0x"
             "2 * pi"))
           (replace -1 1 rl)
           (replace -2)
           (assert))))))
      ("2" (assert)) ("3" (assert))))
    ("2"
     (flatten)
     (skosimp*)
     (replace -1)
     (lemma "div_cancel1" ("x" "i!1/2" "n0z" "pi"))
     (replace -1)
     (lemma "odd_or_even_int" ("x" "i!1"))
     (split -1)
     (("1"
       (expand "odd?")
       (skosimp*)
       (replace -1)
       (hide -1 -2 -3)
       (lemma "floor_val" ("i" "1+2*j!1" "j" "2" "k" "j!1"))
       (split -1)
       (("1"
         (replace -1)
         (assert)
         (lemma "sin_pi")
         (expand "sin")
         (lemma "div_cancel1" ("x" "1/2" "n0z" "pi"))
         (replace -1)
         (lemma "floor_val" ("i" "1" "j" "2" "k" "0"))
         (split -1)
         (("1" (replace -1) (assert)) ("2" (assert)) ("3" (assert))))
        ("2" (assert)) ("3" (assert))))
      ("2"
       (expand "even?")
       (skosimp*)
       (replace -1)
       (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
       (replace -1)
       (rewrite "floor_int")
       (assert)
       (rewrite "sin_phase_0"))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_basic
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (split)
   (("1"
     (flatten)
     (expand "sin")
     (lemma "floor_def" ("x" "a!1/(2*pi)"))
     (rewrite "div_mult_pos_lt1")
     (rewrite "div_mult_pos_le2")
     (flatten)
     (inst + "floor(a!1/(2*pi))")
     (lemma "phases_sin")
     (inst - "a!1 - 2 * (floor(a!1 / (2 * pi)) * pi)")
     (("1"
       (lemma "cos_value_bij")
       (expand "bijective?")
       (expand "injective?")
       (flatten -1)
       (hide -2)
       (lemma "sin_value_strict_increasing")
       (expand "strict_increasing?")
       (split -3)
       (("1"
         (rewrite "sin_q1" -6)
         (rewrite "phase_sin_q1" -1)
         (flatten -1)
         (inst -3 "a!1 - 2 * (floor(a!1 / (2 * pi)) * pi)" "pi/2")
         (("1" (assert) (rewrite "sin_value_pi2") (assert))
          ("2" (expand "abs" 1) (assert))
          ("3" (expand "abs" 1) (assert))))
        ("2"
         (rewrite "sin_q2" -6)
         (rewrite "phase_sin_q2" -1)
         (flatten -1)
         (inst -4
          "-1 * (pi / 2) - 2 * (floor(a!1 / (2 * pi)) * pi) + a!1" "0")
         (("1" (rewrite "cos_value_0") (assert)) ("2" (assert))))
        ("3"
         (rewrite "sin_q3" -6)
         (rewrite "phase_sin_q3" -1)
         (flatten -1)
         (inst -3 "-pi/2"
          "-1 * pi - 2 * (floor(a!1 / (2 * pi)) * pi) + a!1")
         (("1" (assert) (rewrite "sin_value_minus_pi2") (assert))
          ("2" (expand "abs" 1) (assert))
          ("3" (expand "abs" 1) (assert))))
        ("4"
         (rewrite "sin_q4" -6)
         (rewrite "phase_sin_q4" -1)
         (flatten -1)
         (inst -4 "pi"
          "-1 * (3 * pi / 2) - 2 * (floor(a!1 / (2 * pi)) * pi) +
                                    a!1")
         (("1" (rewrite "cos_value_pi") (assert)) ("2" (assert))))))
      ("2" (assert))))
    ("2"
     (flatten)
     (skosimp*)
     (replace -1)
     (hide -1)
     (lemma "sin_period" ("a" "pi/2" "j" "i!1"))
     (rewrite "sin_pi2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_co")
   (inst - "0" "pi/2")
   (assert)
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst?))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_co")
   (inst - "pi/2" "pi")
   (assert)
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst?))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_open")
   (inst - "0" "pi")
   (assert)
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst?))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_co")
   (inst - "pi/4" "pi")
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst?))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "deriv_domain_co")
   (inst - "0" "pi/4")
   (expand "deriv_domain?")
   (skosimp*)
   (inst - "e!1" "x!1")
   (skosimp*)
   (inst?))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("px"))
   (case "px<=1")
   (("1"
     (expand "sin")
     (lemma "floor_def" ("x" "px/(2*pi)"))
     (rewrite "div_mult_pos_lt1")
     (rewrite "div_mult_pos_le2")
     (flatten)
     (lemma "trichotomy" ("x" "floor(px / (2 * pi))"))
     (split -1)
     (("1"
       (case "floor(px / (2 * pi)) =1")
       (("1" (lemma "pi_bnds") (flatten) (assert))
        ("2"
         (case "floor(px / (2 * pi))>1")
         (("1"
           (lemma "pi_bnds")
           (flatten)
           (assert)
           (lemma "both_sides_times_pos_lt1"
            ("x" "1" "y" "floor(px / (2 * pi))" "pz" "2*pi"))
           (assert))
          ("2" (assert))))))
      ("2"
       (replace -1)
       (hide -1 -2 -3)
       (simplify 1)
       (lemma "pi_bnds")
       (flatten)
       (lemma "phases_sin" ("x" "px"))
       (split -1)
       (("1"
         (rewrite "sin_q1")
         (hide -1)
         (lemma "sin_value_derivable_fun")
         (lemma "deriv_sin_value")
         (lemma "identity_derivable_fun[real_abs_lt_pi2]")
         (("1"
           (lemma "deriv_id_fun[real_abs_lt_pi2]")
           (expand "I")
           (expand "const_fun")
           (lemma "diff_derivable_fun[real_abs_lt_pi2]"
            ("f1"
             "LAMBDA (x: real_abs_lt_pi2): x"
             "f2"
             "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
           (lemma "deriv_diff_fun[real_abs_lt_pi2]"
            ("ff1"
             "LAMBDA (x: real_abs_lt_pi2): x"
             "ff2"
             "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
           (("1"
             (replace -3 -1)
             (replace -5 -1)
             (expand "-")
             (assert)
             (lemma "identity_derivable_fun[{x:nnreal|x<pi/2}]")
             (("1"
               (lemma "deriv_id_fun[{x:nnreal|x<pi/2}]")
               (expand "I")
               (expand "const_fun")
               (lemma
                "composition_derivable_fun[{x: nnreal | x < pi / 2},real_abs_lt_pi2]"
                ("f"
                 "LAMBDA (x: {x: nnreal | x < pi / 2}): x"
                 "g"
                 "LAMBDA (x_1: real_abs_lt_pi2): x_1 - sin_value(x_1)"))
               (replace -3)
               (replace -5)
               (expand "o")
               (lemma
                "deriv_comp_fun[{x: nnreal | x < pi / 2},real_abs_lt_pi2]"
                ("ff"
                 "LAMBDA (x: {x: nnreal | x < pi / 2}): x"
                 "gg"
                 "LAMBDA (x_1: real_abs_lt_pi2): x_1 - sin_value(x_1)"))
               (("1"
                 (expand "o")
                 (replace -3 -1)
                 (replace -5 -1)
                 (expand "*" -1)
                 (lemma "minimum_derivative[{x: nnreal | x < pi / 2}]"
                  ("g"
                   "LAMBDA (x_1: {x: nnreal | x < pi / 2}): x_1 - sin_value(x_1)"
                   "x"
                   "0"
                   "y1"
                   "px"))
                 (("1"
                   (split -1)
                   (("1" (simplify -1) (rewrite "sin_value_0") (assert))
                    ("2"
                     (replace -1 1)
                     (assert)
                     (expand "abs")
                     (rewrite "cos_value_0")
                     (assert))
                    ("3" (assert))
                    ("4"
                     (replace -1 1)
                     (hide-all-but 1)
                     (skosimp*)
                     (expand "abs")
                     (lemma "cos_value_strict_decreasing")
                     (expand "strict_decreasing?")
                     (inst - "0" "y!1")
                     (rewrite "cos_value_0")
                     (assert)
                     (lemma "posreal_times_posreal_is_posreal"
                      ("px" "1-cos_value(y!1)" "py" "y!1"))
                     (assert))))
                  ("2" (propax)) ("3" (skosimp*) (assert))))
                ("2" (propax))))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (case "x!1=0")
               (("1" (inst + "pi/4") (assert))
                ("2" (inst + "0") (assert))))
              ("3"
               (hide-all-but 1)
               (lemma deriv_domain_nnreal_lt)
               (inst - pi/2))))
            ("2" (propax)) ("3" (propax))))
          ("2"
           (hide-all-but 1)
           (skosimp*)
           (case "x!1=0")
           (("1" (inst + "pi/4") (assert)) ("2" (inst + "0") (assert))))
          ("3"
           (hide-all-but 1)
           (lemma deriv_domain_open)
           (inst - -pi/2 pi/2))))
        ("2" (rewrite "phase_sin_q2") (flatten) (assert))
        ("3" (rewrite "phase_sin_q3") (flatten) (assert))
        ("4" (rewrite "phase_sin_q4") (flatten) (assert))))
      ("3" (assert))))
    ("2" (typepred "sin(px)") (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("px"))
   (case "px<pi")
   (("1"
     (case "derivable?[{x:real| -pi/4<x&x<pi/4}](LAMBDA (x:{x:real| -pi/4<x&x<pi/4}): cos(x))")
     (("1"
       (case "deriv[{x: real | -pi / 4 < x & x < pi / 4}](LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): cos(x)) = (LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): -sin(x))")
       (("1"
         (case "1 - (pi/4) * (pi/4) / 2 < cos(pi/4)")
         (("1"
           (lemma "trich_lt" ("x" "px" "y" "pi/4"))
           (split -1)
           (("1"
             (hide -5)
             (hide -2)
             (lemma
              "identity_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]")
             (lemma "deriv_id_fun[{x: real | -pi / 4 < x & x < pi / 4}]")
             (expand "I")
             (lemma
              "const_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("b" "1"))
             (lemma
              "deriv_const_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("b" "1"))
             (lemma
              "prod_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("f1"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"
               "f2"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"))
             (assert)
             (expand "*")
             (lemma
              "deriv_prod_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("ff1"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"
               "ff2"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"))
             (replace -5)
             (expand "*")
             (expand "+")
             (lemma
              "scal_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("b"
               "1/2"
               "f"
               "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1 * x_1"))
             (assert)
             (expand "*")
             (lemma
              "deriv_scal_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("b"
               "1/2"
               "ff"
               "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1 * x_1"))
             (replace -3)
             (expand "*")
             (lemma
              "diff_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("f1"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): 1"
               "f2"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                               1 / 2 * (x * x)"))
             (assert)
             (expand "-")
             (lemma
              "deriv_diff_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("ff1"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): 1"
               "ff2"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                               1 / 2 * (x * x)"))
             (expand "-")
             (replace -3)
             (replace -7)
             (simplify -1)
             (lemma
              "diff_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("f1"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): cos(x)"
               "f2"
               "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                           1 - 1 / 2 * (x_1 * x_1)"))
             (assert)
             (expand "-")
             (lemma
              "deriv_diff_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
              ("ff1"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): cos(x)"
               "ff2"
               "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                           1 - 1 / 2 * (x_1 * x_1)"))
             (replace -3)
             (replace -14)
             (expand "-")
             (hide-all-but (-1 -2 -13 1))
             (lemma "identity_derivable_fun[{x:nnreal|x<pi/4}]")
             (lemma "deriv_id_fun[{x:nnreal|x<pi/4}]")
             (expand "I")
             (lemma
              "composition_derivable_fun[{x: nnreal | x < pi / 4},{x: real | -pi / 4 < x & x < pi / 4}]"
              ("f"
               "LAMBDA (x: {x: nnreal | x < pi / 4}): x"
               "g"
               "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): cos(x_1) - 1 + 1 / 2 * (x_1 * x_1)"))
             (assert)
             (expand "o")
             (lemma
              "deriv_comp_fun[{x: nnreal | x < pi / 4},{x: real | -pi / 4 < x & x < pi / 4}]"
              ("ff"
               "LAMBDA (x: {x: nnreal | x < pi / 4}): x"
               "gg"
               "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): cos(x_1) - 1 + 1 / 2 * (x_1 * x_1)"))
             (replace -5)
             (replace -3)
             (expand "o")
             (expand "*")
             (lemma "minimum_derivative[{x: nnreal | x < pi / 4}]"
              ("g"
               "LAMBDA (x_1: {x: nnreal | x < pi / 4}): cos(x_1) - 1 + 1 / 2 * (x_1 * x_1)"
               "x"
               "0"
               "y1"
               "px"))
             (("1"
               (split -1)
               (("1" (simplify -1) (rewrite "cos_0") (assert))
                ("2"
                 (replace -1 1)
                 (simplify 1)
                 (rewrite "sin_0")
                 (assert))
                ("3" (assert))
                ("4"
                 (hide 2)
                 (skosimp*)
                 (replace -1)
                 (simplify 2)
                 (hide-all-but (1 2))
                 (lemma "sin_ub" ("px" "y!1"))
                 (("1"
                   (lemma "posreal_times_posreal_is_posreal"
                    ("px" "y!1" "py" "y!1-sin(y!1)"))
                   (("1" (assert)) ("2" (assert))))
                  ("2" (assert))))))
              ("2" (propax))))
            ("2" (replace -1) (propax))
            ("3"
             (hide -3 -4)
             (expand "cos")
             (lemma "floor_0" ("x" "px / (2 * pi)"))
             (flatten -1)
             (hide -1)
             (split -1)
             (("1"
               (replace -1)
               (lemma "floor_0" ("x" "pi / 4 / (2 * pi)"))
               (flatten -1)
               (hide -1)
               (split -1)
               (("1"
                 (replace -1)
                 (simplify (-4 1))
                 (hide -1 -2)
                 (rewrite "cos_phase_pi4")
                 (expand "cos_phase")
                 (rewrite "phase_cos_q1" 1)
                 (assert)
                 (lemma
                  "identity_derivable_fun[{x:nnreal|pi/4<=x&x<pi}]")
                 (lemma "deriv_id_fun[{x:nnreal|pi/4<=x&x<pi}]")
                 (lemma "const_derivable_fun[{x:nnreal|pi/4<=x&x<pi}]"
                  ("b" "1"))
                 (lemma "deriv_const_fun[{x:nnreal|pi/4<=x&x<pi}]"
                  ("b" "1"))
                 (expand "I")
                 (lemma
                  "prod_derivable_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("f1"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): x"
                   "f2"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): x"))
                 (assert)
                 (expand "*")
                 (lemma
                  "deriv_prod_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("ff1"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): x"
                   "ff2"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): x"))
                 (replace -5)
                 (expand "*")
                 (expand "+")
                 (lemma
                  "scal_derivable_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("b"
                   "1/2"
                   "f"
                   "LAMBDA (x_1: {x: nnreal | pi / 4 <= x & x < pi}): x_1 * x_1"))
                 (assert)
                 (expand "*")
                 (lemma
                  "deriv_scal_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("b"
                   "1/2"
                   "ff"
                   "LAMBDA (x_1: {x: nnreal | pi / 4 <= x & x < pi}): x_1 * x_1"))
                 (replace -3)
                 (expand "*")
                 (lemma
                  "diff_derivable_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("f1"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): 1"
                   "f2"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): 1 / 2 * (x * x)"))
                 (assert)
                 (expand "-")
                 (lemma
                  "deriv_diff_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("ff1"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): 1"
                   "ff2"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): 1 / 2 * (x * x)"))
                 (replace -7)
                 (replace -3)
                 (expand "-")
                 (lemma "cos_value_derivable_fun")
                 (lemma "deriv_cos_value")
                 (lemma
                  "composition_derivable_fun[{x: nnreal | pi / 4 <= x & x < pi},posreal_lt_pi]"
                  ("f"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): x"
                   "g"
                   "LAMBDA (x: posreal_lt_pi): cos_value(x)"))
                 (assert)
                 (expand "o")
                 (lemma
                  "deriv_comp_fun[{x: nnreal | pi / 4 <= x & x < pi},posreal_lt_pi]"
                  ("ff"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}): x"
                   "gg"
                   "LAMBDA (x: posreal_lt_pi): cos_value(x)"))
                 (expand "o")
                 (replace -3 -1)
                 (replace -13)
                 (expand "*")
                 (hide -7 -8 -9 -10 -11 -12 -13 -14)
                 (lemma
                  "diff_derivable_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("f1"
                   "LAMBDA (x_1: {x: nnreal | pi / 4 <= x & x < pi}): cos_value(x_1)"
                   "f2"
                   "LAMBDA (x_1: {x: nnreal | pi / 4 <= x & x < pi}): 1 - 1 / 2 * (x_1 * x_1)"))
                 (assert)
                 (expand "-")
                 (lemma
                  "deriv_diff_fun[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("ff1"
                   "LAMBDA (x_1: {x: nnreal | pi / 4 <= x & x < pi}): cos_value(x_1)"
                   "ff2"
                   "LAMBDA (x_1: {x: nnreal | pi / 4 <= x & x < pi}): 1 - 1 / 2 * (x_1 * x_1)"))
                 (replace -3)
                 (replace -7)
                 (expand "-")
                 (lemma
                  "positive_derivative[{x: nnreal | pi / 4 <= x & x < pi}]"
                  ("g"
                   "LAMBDA (x: {x: nnreal | pi / 4 <= x & x < pi}):
                                                                                                                                                               cos_value(x) - 1 + 1 / 2 * (x * x)"))
                 (("1"
                   (split -1)
                   (("1"
                     (expand "strict_increasing?")
                     (hide-all-but (-1 -10 -11 -12 1))
                     (inst - "pi/4" "px")
                     (rewrite "cos_value_pi4")
                     (assert))
                    ("2"
                     (skosimp*)
                     (hide 2)
                     (expand "deriv" -1)
                     (decompose-equality -1)
                     (("1"
                       (inst -1 "x!1")
                       (replaces -1 1)
                       (hide-all-but (-8 -9 -10 1))
                       (case "x!1 < pi / 2")
                       (("1"
                         (hide -2 -3 -4)
                         (assert)
                         (lemma "sin_ub" ("px" "x!1"))
                         (expand "sin")
                         (lemma "floor_0" ("x" "x!1/(2*pi)"))
                         (assert)
                         (rewrite "div_mult_pos_lt1" -1)
                         (flatten -1)
                         (replace -1)
                         (simplify -2)
                         (rewrite "sin_q1" -2)
                         (("1" (assert))
                          ("2" (rewrite "phase_sin_q1" 1))))
                        ("2"
                         (assert)
                         (case "pi/2<=x!1")
                         (("1"
                           (hide -2 -3 -4 1)
                           (lemma "sin_ub" ("px" "x!1"))
                           (expand "sin")
                           (lemma "floor_0" ("x" "x!1 / (2 * pi)"))
                           (assert)
                           (rewrite "div_mult_pos_lt1" -1)
                           (flatten -1)
                           (replace -1)
                           (simplify -2)
                           (hide -1)
                           (case "sin_value(pi - x!1) = sin_phase(x!1)")
                           (("1" (replace -1) (assert))
                            ("2"
                             (hide -1 2)
                             (rewrite "sin_q2" 1)
                             (("1"
                               (rewrite "sin_eqv_cos_value")
                               (lemma "cos_value_neg" ("xc" "x!1-pi/2"))
                               (assert))
                              ("2" (rewrite "phase_sin_q2"))))))
                          ("2" (assert))))))
                      ("2" (expand "derivable?" -6) (inst?))))))
                  ("2" (propax))))
                ("2"
                 (hide-all-but 1)
                 (rewrite "div_div2")
                 (lemma "div_cancel1" ("x" "1/8" "n0z" "pi"))
                 (replace -1)
                 (assert))
                ("3"
                 (hide-all-but 1)
                 (lemma "div_cancel1" ("x" "1/8" "n0z" "pi"))
                 (rewrite "div_div2" 1)
                 (assert))))
              ("2" (assert))
              ("3" (assert) (rewrite "div_mult_pos_lt1" 1))))))
          ("2"
           (hide-all-but 1)
           (expand "cos")
           (lemma "floor_0" ("x" "pi / 4 / (2 * pi)"))
           (rewrite "div_div2")
           (lemma "div_cancel1" ("x" "1/8" "n0z" "pi"))
           (replace -1)
           (hide -1)
           (flatten -1)
           (hide -1)
           (split -1)
           (("1"
             (replace -1)
             (simplify 1)
             (hide -1)
             (rewrite "cos_phase_pi4")
             (case "314/100<=pi&pi<=315/100")
             (("1"
               (flatten)
               (lemma "le_times_le_pos"
                ("nnx" "pi/4" "y" "315/400" "nnz" "pi/4" "w" "315/400"))
               (assert)
               (lemma "le_times_le_pos"
                ("y" "pi/4" "nnx" "314/400" "w" "pi/4" "nnz" "314/400"))
               (assert)
               (case "1 - (pi / 4) * (pi / 4) / 2<=221404/320000")
               (("1"
                 (lemma "sq_lt"
                  ("nna" "221404 / 320000" "nnb" "sqrt(1/2)"))
                 (flatten -1)
                 (hide -2)
                 (rewrite "sq_sqrt")
                 (split -1)
                 (("1" (assert)) ("2" (hide-all-but 1) (grind))))
                ("2" (assert))))
              ("2"
               (hide 2)
               (typepred "pi")
               (expand "pi_lb")
               (expand "pi_ub")
               (assert))))
            ("2" (assert)) ("3" (assert))))))
        ("2"
         (hide -2 2)
         (lemma "extensionality"
          ("f"
           "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): cos(x)"
           "g"
           "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): sqrt(1/2)*(cos(x+pi/4)+sin(x+pi/4))"))
         (split -1)
         (("1"
           (replace -1)
           (hide -1)
           (lemma
            "identity_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]")
           (lemma "deriv_id_fun[{x: real | -pi / 4 < x & x < pi / 4}]")
           (expand "I")
           (lemma
            "const_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("b" "pi/4"))
           (lemma "deriv_const_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("b" "pi/4"))
           (lemma "sin_value_derivable_fun")
           (lemma "cos_value_derivable_fun")
           (lemma "deriv_sin_value")
           (lemma "deriv_cos_value")
           (lemma
            "sum_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("f1"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): pi / 4"
             "f2"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"))
           (assert)
           (expand "+")
           (lemma "deriv_sum_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("ff1"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): pi / 4"
             "ff2"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"))
           (replace -9)
           (replace -7)
           (expand "+")
           (lemma
            "composition_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4},posreal_lt_pi]"
            ("f"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1+pi/4"
             "g"
             "LAMBDA (x: posreal_lt_pi): cos_value(x)"))
           (assert)
           (expand "o")
           (lemma
            "composition_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4},real_abs_lt_pi2]"
            ("f"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1+pi/4"
             "g"
             "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
           (assert)
           (expand "o")
           (lemma
            "deriv_comp_fun[{x: real | -pi / 4 < x & x < pi / 4},real_abs_lt_pi2]"
            ("ff"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1+pi/4"
             "gg"
             "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
           (lemma
            "deriv_comp_fun[{x: real | -pi / 4 < x & x < pi / 4},posreal_lt_pi]"
            ("ff"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1+pi/4"
             "gg"
             "LAMBDA (x: posreal_lt_pi): cos_value(x)"))
           (replace -5)
           (replace -7)
           (replace -8)
           (expand "o")
           (expand "*")
           (lemma
            "sum_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("f1"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                     cos_value(x_1 + pi / 4)"
             "f2"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                     sin_value(x_1 + pi / 4)"))
           (expand "+")
           (hide (-8 -9 -10 -11 -12 -13 -14 -15))
           (assert)
           (lemma "deriv_sum_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("ff1"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                           cos_value(x_1 + pi / 4)"
             "ff2"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                           sin_value(x_1 + pi / 4)"))
           (replace -3)
           (replace -4)
           (expand "abs" (-1 -4))
           (expand "+")
           (lemma
            "scal_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("f"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                           cos_value(x + pi / 4) + sin_value(x + pi / 4)"
             "b"
             "sqrt(1/2)"))
           (assert)
           (expand "*")
           (lemma "deriv_scal_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("ff"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                           cos_value(x + pi / 4) + sin_value(x + pi / 4)"
             "b"
             "sqrt(1/2)"))
           (replace -3)
           (expand "*")
           (hide-all-but (-1 -2 -11 1))
           (lemma "extensionality"
            ("f"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                           cos_value(x_1 + pi / 4) * sqrt(1 / 2) +
                                                                                                                            sin_value(x_1 + pi / 4) * sqrt(1 / 2)"
             "g"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                          cos(x + pi / 4) * sqrt(1 / 2) + sin(x + pi / 4) * sqrt(1 / 2)"))
           (split -1)
           (("1"
             (replace -1)
             (lemma "extensionality"
              ("f"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                                     cos_value(x + pi / 4) * sqrt(1 / 2) +
                                                                                                                                      sqrt(1 / 2) * -sin_value(x + pi / 4)"
               "g"
               "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): -sin(x)"))
             (split -1)
             (("1" (replace -1 :dir rl) (assert))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (lemma "sin_minus" ("a" "x!1+pi/4" "b" "pi/4"))
               (replace -1 1)
               (hide -1)
               (expand "sin")
               (expand "cos")
               (rewrite "div_div2")
               (lemma "div_cancel1" ("x" "1/8" "n0z" "pi"))
               (replace -1)
               (lemma "floor_0" ("x" "1/8"))
               (flatten -1)
               (hide -1 -3)
               (split -1)
               (("1"
                 (replace -1)
                 (hide -1)
                 (simplify)
                 (rewrite "cos_phase_pi4")
                 (rewrite "sin_phase_pi4")
                 (typepred "x!1")
                 (lemma "floor_0" ("x" "(pi / 4 + x!1) / (2 * pi)"))
                 (rewrite "div_mult_pos_lt1" -1)
                 (rewrite "div_mult_pos_le2" -1)
                 (flatten -1)
                 (replace -1)
                 (simplify 1)
                 (rewrite "sin_q1")
                 (("1"
                   (rewrite "cos_q1")
                   (("1" (assert))
                    ("2"
                     (hide 2)
                     (assert)
                     (lemma "phase_sin_q1" ("x" "(pi / 4) + x!1"))
                     (assert))))
                  ("2"
                   (hide-all-but (-2 -3 1))
                   (lemma "phase_sin_q1" ("x" "(pi / 4) + x!1"))
                   (assert))))
                ("2" (assert)) ("3" (assert))))))
            ("2"
             (hide-all-but 1)
             (skosimp*)
             (expand "cos")
             (expand "sin")
             (lemma "floor_0" ("x" "(pi / 4 + x!1) / (2 * pi)"))
             (flatten -1)
             (split -2)
             (("1"
               (replace -1)
               (hide -1 -2)
               (simplify)
               (rewrite "sin_q1")
               (("1"
                 (rewrite "cos_q1")
                 (hide 2)
                 (typepred "x!1")
                 (lemma "phase_sin_q1" ("x" "pi/4+x!1"))
                 (assert))
                ("2" (lemma "phase_sin_q1" ("x" "pi/4+x!1")) (assert))))
              ("2"
               (hide-all-but 1)
               (assert)
               (rewrite "div_mult_pos_le2"))
              ("3" (rewrite "div_mult_pos_lt1" 1))))))
          ("2"
           (hide -1 2)
           (skosimp*)
           (lemma "cos_minus" ("a" "x!1 + pi / 4" "b" "pi/4"))
           (replace -1 1)
           (hide -1)
           (expand "cos")
           (expand "sin")
           (rewrite "div_div2")
           (lemma "div_cancel1" ("x" "1/8" "n0z" "pi"))
           (replace -1)
           (lemma "floor_0" ("x" "1/8"))
           (flatten -1)
           (hide -1 -3)
           (split -1)
           (("1"
             (replace -1)
             (simplify 1)
             (rewrite "sin_phase_pi4")
             (rewrite "cos_phase_pi4"))
            ("2" (assert)) ("3" (assert))))))
        ("3" (propax))))
      ("2"
       (lemma "extensionality"
        ("f"
         "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): cos(x)"
         "g"
         "LAMBDA (x:{x: real | -pi / 4 < x & x < pi / 4}):sqrt(1/2)*(cos_value(x+pi/4)+sin_value(x+pi/4))"))
       (split -1)
       (("1"
         (replace -1 1)
         (hide-all-but 1)
         (lemma "cos_value_derivable_fun")
         (lemma "sin_value_derivable_fun")
         (lemma
          "identity_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]")
         (lemma "deriv_id_fun[{x: real | -pi / 4 < x & x < pi / 4}]")
         (expand "I")
         (lemma
          "const_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
          ("b" "pi/4"))
         (lemma "deriv_const_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
          ("b" "pi/4"))
         (lemma "sum_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
          ("f1"
           "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"
           "f2"
           "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): pi/4"))
         (lemma "deriv_sum_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
          ("ff1"
           "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): x"
           "ff2"
           "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}): pi/4"))
         (("1"
           (replace -3 -1)
           (replace -5 -1)
           (expand "+")
           (assert)
           (lemma
            "composition_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4},real_abs_lt_pi2]"
            ("f"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1 + pi / 4"
             "g"
             "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
           (lemma
            "composition_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4},posreal_lt_pi]"
            ("f"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}): x_1 + pi / 4"
             "g"
             "LAMBDA (x: posreal_lt_pi): cos_value(x)"))
           (assert)
           (expand "o")
           (lemma
            "sum_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("f1"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                               cos_value(x_1 + pi / 4)"
             "f2"
             "LAMBDA (x_1: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                               sin_value(x_1 + pi / 4)"))
           (assert)
           (expand "+")
           (lemma
            "scal_derivable_fun[{x: real | -pi / 4 < x & x < pi / 4}]"
            ("b"
             "sqrt(1/2)"
             "f"
             "LAMBDA (x: {x: real | -pi / 4 < x & x < pi / 4}):
                                                                                                                               cos_value(x + pi / 4) + sin_value(x + pi / 4)"))
           (assert)
           (expand "*")
           (propax))
          ("2" (propax)) ("3" (propax))))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (lemma "cos_minus" ("a" "x!1+pi/4" "b" "pi/4"))
         (replace -1 1)
         (hide -1)
         (typepred "x!1")
         (expand "cos")
         (expand "sin")
         (rewrite "div_div2" 1)
         (lemma "div_cancel1" ("x" "1/8" "n0z" "pi"))
         (replace -1)
         (lemma "floor_0" ("x" "1/8"))
         (flatten -1)
         (hide -1)
         (simplify -1)
         (replace -1)
         (simplify 1)
         (lemma "floor_0" ("x" "(pi / 4 + x!1) / (2 * pi)"))
         (flatten -1)
         (hide -1 -3 -4)
         (split -1)
         (("1"
           (replace -1)
           (simplify 1)
           (hide -1)
           (rewrite "cos_phase_pi4")
           (rewrite "sin_phase_pi4")
           (lemma "phase_sin_q1" ("x" "pi/4+x!1"))
           (assert)
           (rewrite "sin_q1" 1)
           (rewrite "cos_q1" 1))
          ("2"
           (hide 2)
           (lemma "div_mult_pos_le2"
            ("z" "pi / 4 + x!1" "py" "2*pi" "x" "0"))
           (assert))
          ("3"
           (hide 2)
           (lemma "div_mult_pos_lt1"
            ("z" "pi / 4 + x!1" "py" "2*pi" "x" "1"))
           (assert))))))))
    ("2"
     (case "pi<=px")
     (("1"
       (hide 1)
       (lemma "pi_bnds")
       (flatten)
       (typepred "cos(px)")
       (lemma "lt_times_lt_pos1"
        ("px" "306/100" "y" "px" "nnz" "306/100" "w" "px"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("px"))
   (lemma "sin_value_derivable_fun")
   (lemma "deriv_sin_value")
   (lemma "identity_derivable_fun[real]")
   (lemma "deriv_id_fun[real]")
   (expand "I")
   (expand "const_fun")
   (lemma "prod_derivable_fun[real]"
    ("f1" "LAMBDA (x: real): x" "f2" "LAMBDA (x: real): x"))
   (assert)
   (expand "*")
   (lemma "deriv_prod_fun[real]"
    ("ff1" "LAMBDA (x: real): x" "ff2" "LAMBDA (x: real): x"))
   (expand "*")
   (replace -3 -1)
   (expand "+")
   (lemma "prod_derivable_fun[real]"
    ("f1" "LAMBDA (x: real): x" "f2" "LAMBDA (x: real): x*x"))
   (assert)
   (expand "*")
   (lemma "deriv_prod_fun[real]"
    ("ff1" "LAMBDA (x: real): x" "ff2" "LAMBDA (x: real): x*x"))
   (expand "*")
   (replace -3)
   (replace -5)
   (expand "+")
   (lemma "scal_derivable_fun[real]"
    ("f" "LAMBDA (x_1: real): x_1 * (x_1 * x_1)" "b" "1/6"))
   (assert)
   (expand "*")
   (lemma "deriv_scal_fun[real]"
    ("ff" "LAMBDA (x_1: real): x_1 * (x_1 * x_1)" "b" "1/6"))
   (expand "*")
   (replace -3 -1)
   (simplify -1)
   (lemma "diff_derivable_fun[real]"
    ("f1"
     "LAMBDA (x: real): 1 / 6 * (x * (x * x))"
     "f2"
     "LAMBDA (x: real): x"))
   (assert)
   (expand "-")
   (lemma "deriv_diff_fun[real]"
    ("ff1"
     "LAMBDA (x: real): 1 / 6 * (x * (x * x))"
     "ff2"
     "LAMBDA (x: real): x"))
   (replace -3)
   (replace -9)
   (expand "-")
   (hide -3 -4 -5 -6 -7 -8 -9 -10)
   (typepred "sin(px)")
   (case "px<pi")
   (("1"
     (expand "sin")
     (lemma "floor_def" ("x" "px / (2 * pi)"))
     (rewrite "div_mult_pos_lt1" -1)
     (rewrite "div_mult_pos_le2" -1)
     (flatten -1)
     (lemma "trichotomy" ("x" "floor(px/(2*pi))"))
     (split -1)
     (("1"
       (case "floor(px/(2*pi))=1")
       (("1" (assert))
        ("2"
         (case "floor(px/(2*pi))>1")
         (("1"
           (lemma "both_sides_times_pos_lt1"
            ("x" "1" "y" "floor(px/(2*pi))" "pz" "2*pi"))
           (assert))
          ("2" (assert))))))
      ("2"
       (replace -1)
       (simplify 1)
       (hide -1 -2 -3)
       (simplify (-2 -3))
       (case "px<pi/2")
       (("1"
         (hide -2 -3 -4)
         (rewrite "sin_q1" 1)
         (("1"
           (lemma "identity_derivable_fun[{x:nnreal|x<pi/2}]")
           (("1"
             (lemma "deriv_id_fun[{x:nnreal|x<pi/2}]")
             (expand "I")
             (expand "const_fun")
             (lemma
              "composition_derivable_fun[{x: nnreal | x < pi / 2},real_abs_lt_pi2]"
              ("f"
               "LAMBDA (x: {x: nnreal | x < pi / 2}): x"
               "g"
               "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
             (("1"
               (expand "o")
               (replace -3 -1)
               (lemma
                "deriv_comp_fun[{x: nnreal | x < pi / 2},real_abs_lt_pi2]"
                ("ff"
                 "LAMBDA (x: {x: nnreal | x < pi / 2}): x"
                 "gg"
                 "LAMBDA (x: real_abs_lt_pi2): sin_value(x)"))
               (("1"
                 (expand "o")
                 (expand "*")
                 (lemma
                  "composition_derivable_fun[{x: nnreal | x < pi / 2},real]"
                  ("f"
                   "LAMBDA (x: {x: nnreal | x < pi / 2}): x"
                   "g"
                   "LAMBDA (x_1: real): 1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                 (("1"
                   (expand "o")
                   (assert)
                   (lemma "deriv_comp_fun[{x: nnreal | x < pi / 2},real]"
                    ("ff"
                     "LAMBDA (x: {x: nnreal | x < pi / 2}): x"
                     "gg"
                     "LAMBDA (x_1: real): 1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                   (expand "o")
                   (replace -5)
                   (replace -10)
                   (replace -8)
                   (expand "*")
                   (simplify (-3))
                   (expand "abs" -3)
                   (lemma "sum_derivable_fun[{x: nnreal | x < pi / 2}]"
                    ("f1"
                     "LAMBDA (x_1: {x: nnreal | x < pi / 2}): sin_value(x_1)"
                     "f2"
                     "LAMBDA (x_1: {x: nnreal | x < pi / 2}):
                                                                                                                                      1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                   (assert)
                   (expand "+")
                   (lemma "deriv_sum_fun[{x: nnreal | x < pi / 2}]"
                    ("ff1"
                     "LAMBDA (x_1: {x: nnreal | x < pi / 2}): sin_value(x_1)"
                     "ff2"
                     "LAMBDA (x_1: {x: nnreal | x < pi / 2}):
                                                                                                                                            1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                   (replace -3 -1)
                   (replace -5 -1)
                   (expand "+")
                   (hide -13 -12 -11 -10 -8 -7 -6 -5 -4 -3)
                   (lemma "minimum_derivative[{x: nnreal | x < pi / 2}]"
                    ("g"
                     "LAMBDA (x: {x: nnreal | x < pi / 2}): sin_value(x) + 1 / 6 * (x * (x * x)) - x"
                     "x"
                     "0"
                     "y1"
                     "px"))
                   (("1"
                     (split -1)
                     (("1"
                       (simplify -1)
                       (rewrite "sin_value_0")
                       (assert))
                      ("2"
                       (replace -1 1)
                       (hide -1 -2 2)
                       (simplify 1)
                       (rewrite "cos_value_0")
                       (assert))
                      ("3" (assert))
                      ("4"
                       (replace -1 1)
                       (hide-all-but 1)
                       (skosimp*)
                       (typepred "y!1")
                       (expand ">=")
                       (expand "<=")
                       (split -1)
                       (("1"
                         (hide 1)
                         (lemma "cos_lb" ("px" "y!1"))
                         (("1"
                           (expand "cos")
                           (lemma "floor_0" ("x" "y!1 / (2 * pi)"))
                           (rewrite "div_mult_pos_lt1" -1)
                           (rewrite "div_mult_pos_le2" -1)
                           (flatten -1)
                           (replace -1)
                           (simplify -2)
                           (hide -1)
                           (rewrite "cos_q1" -1)
                           (("1"
                             (lemma "posreal_times_posreal_is_posreal"
                              ("px"
                               "y!1"
                               "py"
                               "cos_value(y!1)-1+y!1*y!1/2"))
                             (("1" (assert)) ("2" (assert))))
                            ("2" (rewrite "phase_sin_q1" 1))))
                          ("2" (assert))))
                        ("2" (assert))))))
                    ("2" (propax)) ("3" (skosimp*) (assert))))
                  ("2"
                   (hide-all-but 1)
                   (skosimp*)
                   (inst + "x!1+1")
                   (assert))
                  ("3" (lemma deriv_domain_real) (propax))))
                ("2" (propax))))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (case "x!1=0")
               (("1"
                 (assert)
                 (inst-cp 1 "pi/4")
                 (inst-cp + "pi/3")
                 (assert))
                ("2"
                 (assert)
                 (inst-cp + "pi/4")
                 (inst-cp + "pi/3")
                 (assert))))
              ("3"
               (hide-all-but 1)
               (lemma deriv_domain_open)
               (inst - "-pi/2" "pi/2"))))
            ("2"
             (hide-all-but 1)
             (skosimp*)
             (case "x!1=0")
             (("1" (inst + "pi/4") (assert))
              ("2" (inst + "0") (assert))))
            ("3"
             (hide-all-but 1)
             (assert)
             (lemma deriv_domain_nnreal_lt)
             (inst - "pi/2"))))
          ("2" (rewrite "phase_sin_q1" 1))))
        ("2"
         (case "pi/2<=px")
         (("1"
           (hide 1)
           (hide -3 -4 -7 -8)
           (rewrite "sin_q2" 1)
           (("1"
             (lemma "cos_lb" ("px" "px-pi/2"))
             (("1"
               (expand "cos" -1)
               (lemma "floor_0" ("x" "(px - pi / 2) / (2 * pi)"))
               (rewrite "div_mult_pos_le2" -1)
               (rewrite "div_mult_pos_lt1" -1)
               (flatten -1)
               (split -2)
               (("1"
                 (hide -2)
                 (replace -1)
                 (simplify -2)
                 (hide -1)
                 (rewrite "cos_q1" -1)
                 (("1"
                   (case "px - px * px * px / 6 <= 1 - (pi / 2 * (pi / 2) - pi / 2 * px + (px * px - pi / 2 * px)) / 2 ")
                   (("1" (assert))
                    ("2"
                     (hide -1 2)
                     (lemma
                      "identity_derivable_fun[{x:posreal|pi/2<=x&x<pi}]")
                     (("1"
                       (lemma "deriv_id_fun[{x:posreal|pi/2<=x&x<pi}]")
                       (lemma
                        "const_derivable_fun[{x:posreal|pi/2<=x&x<pi}]"
                        ("b" "1 - (pi / 2 * (pi / 2))/2"))
                       (lemma "deriv_const_fun[{x:posreal|pi/2<=x&x<pi}]"
                        ("b" "1 - (pi / 2 * (pi / 2))/2"))
                       (expand "I")
                       (expand "const_fun")
                       (lemma
                        "composition_derivable_fun[{x: posreal | pi / 2 <= x & x < pi},real]"
                        ("f"
                         "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x"
                         "g"
                         "LAMBDA (x_1: real): 1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                       (("1"
                         (assert)
                         (expand "o")
                         (lemma
                          "deriv_comp_fun[{x: posreal | pi / 2 <= x & x < pi},real]"
                          ("ff"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x"
                           "gg"
                           "LAMBDA (x_1: real): 1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                         (expand "o")
                         (replace -9)
                         (replace -5)
                         (expand "*")
                         (hide -9 -10)
                         (lemma
                          "scal_derivable_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("f"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x"
                           "b"
                           "pi/2"))
                         (assert)
                         (expand "*")
                         (lemma
                          "deriv_scal_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("ff"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x"
                           "b"
                           "pi/2"))
                         (replace -7)
                         (expand "*")
                         (lemma
                          "prod_derivable_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("f1"
                           "(LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x)"
                           "f2"
                           "(LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x)"))
                         (assert)
                         (expand "*")
                         (lemma
                          "deriv_prod_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("ff1"
                           "(LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x)"
                           "ff2"
                           "(LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): x)"))
                         (replace -9)
                         (expand "*")
                         (expand "+")
                         (lemma
                          "scal_derivable_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("f"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}): x_1 * x_1"
                           "b"
                           "1/2"))
                         (assert)
                         (expand "*")
                         (lemma
                          "deriv_scal_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("ff"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}): x_1 * x_1"
                           "b"
                           "1/2"))
                         (expand "*")
                         (replace -3 -1)
                         (simplify -1)
                         (lemma
                          "sum_derivable_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("f1"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): 1 - (pi / 2 * (pi / 2)) / 2"
                           "f2"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}): pi / 2 * x_1"))
                         (assert)
                         (expand "+")
                         (lemma
                          "deriv_sum_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("ff1"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}): 1 - (pi / 2 * (pi / 2)) / 2"
                           "ff2"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}): pi / 2 * x_1"))
                         (replace -11)
                         (replace -7)
                         (expand "+")
                         (hide -7 -8 -11 -12)
                         (lemma
                          "diff_derivable_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("f1"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 + pi / 2 * x_1 - (pi / 2 * (pi / 2)) / 2"
                           "f2"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 / 2 * (x * x)"))
                         (assert)
                         (expand "-")
                         (lemma
                          "deriv_diff_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("ff1"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 + pi / 2 * x_1 - (pi / 2 * (pi / 2)) / 2"
                           "ff2"
                           "LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 / 2 * (x * x)"))
                         (replace -3)
                         (replace -5)
                         (expand "-")
                         (hide -3 -4 -5 -6 -7 -8 -11 -12)
                         (lemma
                          "sum_derivable_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("f1"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 + pi / 2 * x_1 - (pi / 2 * (pi / 2)) / 2 -
                                                                                                                                                                       1 / 2 * (x_1 * x_1)"
                           "f2"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                         (assert)
                         (expand "+")
                         (lemma
                          "deriv_sum_fun[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("ff1"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 + pi / 2 * x_1 - (pi / 2 * (pi / 2)) / 2 -
                                                                                                                                                                       1 / 2 * (x_1 * x_1)"
                           "ff2"
                           "LAMBDA (x_1: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 / 6 * (x_1 * (x_1 * x_1)) - x_1"))
                         (replace -3)
                         (replace -5)
                         (expand "+")
                         (hide -3 -4 -5 -6)
                         (lemma
                          "nonneg_derivative[{x: posreal | pi / 2 <= x & x < pi}]"
                          ("g"
                           "(LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                      1 + 1 / 6 * (x * (x * x)) + pi / 2 * x - x -
                                                                                                                                                                       (pi / 2 * (pi / 2)) / 2
                                                                                                                                                                       - 1 / 2 * (x * x))"))
                         (("1"
                           (flatten -1)
                           (hide -1)
                           (split -1)
                           (("1"
                             (hide -2 -3)
                             (expand "increasing?")
                             (inst - "pi/2" "px")
                             (assert)
                             (case "0<=1 + 1 / 6 * (pi / 2 * (pi / 2 * (pi / 2))) + pi / 2 * (pi / 2) -
                                                                                                                                                                                                               (pi / 2 * (pi / 2)) / 2
                                                                                                                                                                                                               - pi / 2
                                                                                                                                                                                                               - 1 / 2 * (pi / 2 * (pi / 2))")
                             (("1" (assert))
                              ("2"
                               (hide-all-but 1)
                               (name "K10" "pi/2")
                               (replace -1)
                               (typepred "pi")
                               (expand "pi_lb")
                               (expand "pi_ub")
                               (hide -1 -2)
                               (simplify 1)
                               (case "1 + 1 / 6 * (K10 * (K10 * K10)) + K10 * K10 - (K10 * K10) / 2 - K10
                                                                                                                                                                                                                            - 1 / 2 * (K10 * K10) = 1 + 1 / 6 * (K10 * (K10 * K10))-K10")
                               (("1"
                                 (replace -1)
                                 (hide -1)
                                 (lemma
                                  "le_times_le_pos"
                                  ("nnx"
                                   "157/100"
                                   "y"
                                   "K10"
                                   "nnz"
                                   "157/100"
                                   "w"
                                   "K10"))
                                 (lemma
                                  "le_times_le_pos"
                                  ("y"
                                   "315/200"
                                   "nnx"
                                   "K10"
                                   "w"
                                   "315/200"
                                   "nnz"
                                   "K10"))
                                 (assert)
                                 (case "1-K10*K10/6 <= 35351/60000")
                                 (("1"
                                   (case "1-K10*K10/6>=0")
                                   (("1"
                                     (lemma
                                      "le_times_le_pos"
                                      ("nnx"
                                       "K10"
                                       "y"
                                       "315/200"
                                       "nnz"
                                       "1 - K10 * K10 / 6"
                                       "w"
                                       "35351 / 60000"))
                                     (assert))
                                    ("2" (assert))))
                                  ("2" (assert))))
                                ("2" (hide 2) (assert))))))
                            ("2"
                             (hide -3 -4 2)
                             (skosimp*)
                             (case "deriv(LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                                                                       1 + 1 / 6 * (x * (x * x)) + pi / 2 * x - x -
                                                                                                                                                                                                                        (pi / 2 * (pi / 2)) / 2
                                                                                                                                                                                                                        - 1 / 2 * (x * x))(x!1) = deriv((LAMBDA (x: {x: posreal | pi / 2 <= x & x < pi}):
                                                                                                                                                                                                                       1 + 1 / 6 * (x * (x * x)) + pi / 2 * x - x -
                                                                                                                                                                                                                        (pi / 2 * (pi / 2)) / 2
                                                                                                                                                                                                                        - 1 / 2 * (x * x)),x!1)")
                             (("1"
                               (replace -2 -1)
                               (replace -1 1 rl)
                               (hide-all-but 1)
                               (simplify)
                               (typepred "x!1")
                               (hide -1 -2)
                               (hide -1)
                               (typepred "pi")
                               (hide -1 -2)
                               (expand "pi_lb")
                               (expand "pi_ub")
                               (assert)
                               (case "x!1*(x!1/2-1) >= -1/2")
                               (("1" (assert))
                                ("2"
                                 (hide 2 -1 -2)
                                 (lemma
                                  "quadratic_ge_0"
                                  ("x"
                                   "x!1"
                                   "a"
                                   "1/2"
                                   "b"
                                   "-1"
                                   "c"
                                   "1/2"))
                                 (expand "sq" -1)
                                 (hide -1 2)
                                 (expand "discr")
                                 (assert)
                                 (expand "sq")
                                 (expand "root")
                                 (expand "discr")
                                 (expand "sq")
                                 (rewrite "sqrt_0")
                                 (assert))))
                              ("2" (expand "deriv" 1 1) (propax))
                              ("3"
                               (hide-all-but 1)
                               (lemma "deriv_domain_co")
                               (inst - "pi/2" "pi")
                               (expand "deriv_domain?")
                               (skosimp*)
                               (inst - "e!1" "x!2")
                               (skosimp*)
                               (inst + "y!1"))))))
                          ("2" (propax)) ("3" (skosimp*) (assert))))
                        ("2"
                         (hide-all-but 1)
                         (skosimp*)
                         (inst + "x!1+2")
                         (assert))
                        ("3" (lemma deriv_domain_real) (propax))))
                      ("2"
                       (hide-all-but 1)
                       (skosimp*)
                       (case "x!1=pi/2")
                       (("1" (inst + "3*pi/4") (assert))
                        ("2" (inst + "pi/2") (assert))))
                      ("3"
                       (hide-all-but 1)
                       (assert)
                       (lemma "deriv_domain_co")
                       (inst - "pi/2" "pi")
                       (expand "deriv_domain?")
                       (skosimp*)
                       (inst - "e!1" "x!1")
                       (skosimp*)
                       (inst + "y!1"))))))
                  ("2"
                   (rewrite "floor_0" 1)
                   (rewrite "div_mult_pos_le2" 1)
                   (rewrite "div_mult_pos_lt1" 1))))
                ("2" (assert)) ("3" (assert))))
              ("2"
               (expand "<=" -1)
               (split -1)
               (("1" (assert))
                ("2"
                 (replace -1 * rl)
                 (hide-all-but 2)
                 (simplify)
                 (rewrite "cos_value_0")
                 (typepred "pi")
                 (hide -1 -2)
                 (expand "pi_lb")
                 (expand "pi_ub")
                 (lemma "le_times_le_pos"
                  ("nnx"
                   "314/200"
                   "y"
                   "pi/2"
                   "nnz"
                   "314/200"
                   "w"
                   "pi/2"))
                 (assert)
                 (case "1-pi/2*(pi/2)/6 <= 35351/60000")
                 (("1"
                   (lemma "le_times_le_pos"
                    ("nnx"
                     "pi/2"
                     "y"
                     "315/200"
                     "nnz"
                     "1 - pi / 2 * (pi / 2) / 6"
                     "w"
                     "35351 / 60000"))
                   (("1" (assert))
                    ("2"
                     (lemma "le_times_le_pos"
                      ("nnx"
                       "pi/2"
                       "y"
                       "315/200"
                       "nnz"
                       "pi/2"
                       "w"
                       "315/200"))
                     (assert))))
                  ("2" (assert))))))))
            ("2" (rewrite "phase_sin_q2" 1))))
          ("2" (assert))))))
      ("3" (assert))))
    ("2"
     (lemma "pi_bnds")
     (flatten -1)
     (case "pi<=px")
     (("1"
       (case-replace "306 / 100 <= px")
       (("1"
         (mult-ineq -1 -1)
         (assert)
         (div-by -1 "6")
         (case "1-px*px/6<1-306 / 100 * (306 / 100) / 6")
         (("1"
           (mult-by -1 "px")
           (lemma "both_sides_times_neg_lt1"
            ("nz"
             "(1 - 306 / 100 * (306 / 100) / 6)"
             "y"
             "306/100"
             "x"
             "px"))
           (assert))
          ("2" (assert))))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "convergence")
   (expand "convergence")
   (split)
   (("1"
     (expand "adh")
     (skosimp*)
     (expand "fullset")
     (inst + "e!1/2")
     (("1" (expand "abs") (assert)) ("2" (expand "A") (propax))))
    ("2"
     (skosimp*)
     (expand "fullset")
     (expand "NQ")
     (inst + "min(1,epsilon!1)")
     (("1"
       (skolem 1 ("z"))
       (flatten)
       (rewrite "sin_plus")
       (name "SX" "sin(x!1)")
       (replace -1)
       (name "CX" "cos(x!1)")
       (replace -1)
       (lemma "triangle" ("x" "SX*((cos(z)-1)/z)" "y" "CX*(sin(z)/z-1)"))
       (rewrite "abs_mult" -1)
       (rewrite "abs_mult" -1)
       (lemma "cos_pos_bnds" ("px" "abs(z)"))
       (flatten)
       (rewrite "sq_rew" -1)
       (case "abs(((cos(z) - 1) / z)) < abs(z)/2")
       (("1"
         (lemma "sin_pos_bnds" ("px" "abs(z)"))
         (flatten)
         (rewrite "sq_rew" -1)
         (case "sq(abs(z)) = sq(z)")
         (("1"
           (replace -1)
           (typepred "cos(x!1)")
           (typepred "sin(x!1)")
           (lemma "div_mult_pos_lt2"
            ("x" "1-sq(z)/6" "py" "abs(z)" "z" "sin(abs(z))"))
           (case "sin(abs(z))/abs(z) = sin(z)/z")
           (("1"
             (assert)
             (replace -1 -2)
             (lemma "div_mult_pos_lt1"
              ("z" "sin(abs(z))" "py" "abs(z)" "x" "1"))
             (replace -2 -1)
             (assert)
             (case "abs((sin(z) / z-1)) < sq(z)/6")
             (("1"
               (assert)
               (case "sq(z)/6 +abs(z)/2 < epsilon!1")
               (("1"
                 (assert)
                 (case "abs(CX) <=1")
                 (("1"
                   (case "abs(SX) <=1")
                   (("1"
                     (lemma "le_times_le_pos"
                      ("nnx"
                       "abs(CX)"
                       "y"
                       "1"
                       "nnz"
                       "abs((sin(z) / z - 1))"
                       "w"
                       "sq(z)/6"))
                     (lemma "le_times_le_pos"
                      ("nnx"
                       "abs(SX)"
                       "y"
                       "1"
                       "nnz"
                       "abs((cos(z) -1)/ z)"
                       "w"
                       "abs(z)/2"))
                     (assert))
                    ("2"
                     (hide 2)
                     (expand "abs" 1)
                     (case "SX<0")
                     (("1" (assert)) ("2" (assert))))))
                  ("2"
                   (hide 2)
                   (expand "abs" 1)
                   (case "CX<0")
                   (("1" (assert)) ("2" (assert))))))
                ("2"
                 (hide 2)
                 (hide-all-but (-18 1))
                 (case "sq(z) < abs(z)")
                 (("1"
                   (expand "min")
                   (case "1<=epsilon!1")
                   (("1" (assert)) ("2" (assert))))
                  ("2"
                   (hide 2)
                   (typepred "z")
                   (lemma "both_sides_times_pos_lt1"
                    ("x" "abs(z)" "y" "1" "pz" "abs(z)"))
                   (rewrite "sq_rew")
                   (case "sq(abs(z))=sq(z)")
                   (("1"
                     (assert)
                     (expand "min")
                     (case "1<=epsilon!1")
                     (("1" (assert)) ("2" (assert))))
                    ("2"
                     (hide-all-but 1)
                     (expand "abs")
                     (case "z<0")
                     (("1" (rewrite "sq_neg") (assert))
                      ("2" (assert))))))))))
              ("2" (hide 2) (expand "abs" 1) (assert))))
            ("2"
             (hide-all-but 1)
             (expand "abs")
             (case "z<0")
             (("1" (assert) (rewrite "sin_neg") (assert))
              ("2" (assert))))))
          ("2"
           (hide-all-but 1)
           (expand "abs")
           (case "z<0")
           (("1" (assert) (rewrite "sq_neg")) ("2" (assert))))))
        ("2"
         (hide 2)
         (case "cos(abs(z)) = cos(z)")
         (("1"
           (case "sq(abs(z)) = sq(z)")
           (("1"
             (replace -1)
             (replace -2)
             (hide (-5 -6 -7))
             (lemma "abs_div" ("x" "cos(z)-1" "n0y" "z"))
             (replace -1 1)
             (rewrite "div_mult_pos_lt1" 1)
             (case "abs(z) / 2 * abs(z) = sq(z)/2")
             (("1"
               (replace -1 1)
               (expand "abs" 1)
               (assert)
               (expand "<=" -6)
               (split -6)
               (("1" (assert)) ("2" (replace -1) (assert))))
              ("2"
               (hide 2)
               (hide-all-but (-2 -6 1))
               (expand "sq")
               (assert))))
            ("2"
             (hide-all-but 1)
             (expand "abs")
             (rewrite "sq_neg")
             (case "z<0")
             (("1" (assert)) ("2" (assert))))))
          ("2"
           (hide-all-but 1)
           (expand "abs")
           (rewrite "cos_neg")
           (case "z<0")
           (("1" (assert)) ("2" (assert))))))))
      ("2"
       (expand "min")
       (case "1 <= epsilon!1")
       (("1" (assert)) ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sin_convergence")
   (rewrite "sin_cos")
   (inst - "pi/2+x!1")
   (expand "NQ")
   (lemma "cos_sin" ("a" "x!1"))
   (replace -1 -2 rl)
   (lemma "extensionality"
    ("f"
     "LAMBDA (h: (A[real](pi / 2 + x!1))):
                         (sin(h + pi / 2 + x!1) - cos(x!1)) / h"
     "g"
     "LAMBDA (h: (A[real](x!1))):
                         (cos(h + x!1) - cos(x!1)) / h"))
   (("1"
     (split -1)
     (("1"
       (replace -1 -3)
       (assert)
       (case "--cos(pi / 2 + x!1)=cos(pi / 2 + x!1)")
       (("1"
         (replace -1)
         (assert)
         (expand "convergence")
         (hide -1 -2 -3)
         (expand "convergence")
         (flatten)
         (split 1)
         (("1"
           (hide -2)
           (expand "adh")
           (skosimp*)
           (inst - "e!1")
           (skosimp*)
           (typepred "x!1")
           (inst + "x!2")
           (("1" (assert)) ("2" (expand "A") (propax))))
          ("2"
           (hide -1)
           (skosimp*)
           (inst - "epsilon!1")
           (skosimp*)
           (inst + "delta!1")
           (skosimp*)
           (inst - "x!2")
           (("1" (assert)) ("2" (expand "A") (propax))))))
        ("2" (assert))))
      ("2"
       (hide 2)
       (skosimp*)
       (lemma "cos_sin" ("a" "x!2+x!1"))
       (replace -1 1 rl)
       (propax))))
    ("2" (hide 2 -1 -2) (skosimp*) (expand "A") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "sin_derivable_fun")
   (assert)
   (lemma "derivable_cont_fun[real]" ("f" "sin"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "Taylors" ("f" "sin" "n" "2*n!1+2" "aa" "0" "bb" "x!1"))
   (lemma "nderiv_sin_fun" ("n" "2*n!1+3"))
   (flatten)
   (replace -1)
   (case "FORALL (n:nat): sigma(0, 2 * n + 2,
                                      LAMBDA (nn:nat):
                                        IF nn > 2 * n + 2 THEN 0
                                        ELSIF nn = 0 THEN sin(0)
                                        ELSE nderiv(nn, sin)(0) * (x!1 - 0) ^ nn / factorial(nn)
                                        ENDIF) = sin_series_n(x!1, n)")
   (("1" (inst - "n!1") (assert))
    ("2"
     (hide-all-but 1)
     (expand "sin_series_n")
     (induct "n")
     (("1"
       (expand "sin_series_term")
       (expand "sigma")
       (expand "sigma")
       (expand "sigma")
       (expand "factorial")
       (expand "factorial")
       (expand "factorial")
       (lemma "nderiv_sin_fun")
       (inst-cp - "1")
       (inst - "2")
       (flatten)
       (replace -2)
       (replace -4)
       (rewrite "sin_0")
       (simplify 1)
       (lemma "sin_pi2")
       (lemma "sin_pi")
       (expand "pi")
       (replace -1)
       (replace -2)
       (assert)
       (rewrite "expt_x0" 1)
       (assert))
      ("2"
       (skosimp*)
       (expand "sigma" 1)
       (expand "sigma" 1 1)
       (lemma "sigma_eq[nat]"
        ("low"
         "0"
         "high"
         "j!1"
         "F"
         "LAMBDA (i: nat):
                                       IF i > 1 + j!1 THEN 0 ELSE sin_series_term(x!1)(i) ENDIF"
         "G"
         "LAMBDA (i: nat):
                                      IF i > j!1 THEN 0 ELSE sin_series_term(x!1)(i) ENDIF"))
       (split -1)
       (("1"
         (replace -1)
         (hide -1)
         (lemma "sigma_eq[nat]"
          ("low"
           "0"
           "high"
           "2+2*j!1"
           "G"
           "LAMBDA (nn: nat):
                                           IF nn > 2 + 2 * j!1 THEN 0
                                           ELSIF nn = 0 THEN sin(0)
                                           ELSE nderiv(nn, sin)(0) * x!1 ^ nn / factorial(nn)
                                           ENDIF"
           "F"
           "LAMBDA (nn: nat):
                                           IF nn > 4 + 2 * j!1 THEN 0
                                           ELSIF nn = 0 THEN sin(0)
                                           ELSE nderiv(nn, sin)(0) * x!1 ^ nn / factorial(nn)
                                           ENDIF"))
         (("1"
           (split -1)
           (("1"
             (replace -1)
             (replace -2)
             (hide-all-but 1)
             (lemma "nderiv_sin_fun" ("n" "3+2*j!1"))
             (lemma "nderiv_sin_fun" ("n" "4+2*j!1"))
             (flatten)
             (replace -2)
             (replace -4)
             (simplify 1)
             (expand "sin_series_term")
             (hide-all-but 1)
             (lemma "sin_k_pi" ("k" "2+j!1"))
             (lemma "sin_k_pi2" ("k" "j!1+1"))
             (expand "pi")
             (replace -1)
             (replace -2)
             (assert))
            ("2" (hide-all-but 1) (skosimp*) (typepred "n!2") (assert))))
          ("2"
           (hide-all-but 1)
           (skosimp*)
           (lemma "nderiv_sin_fun" ("n" "nn!1"))
           (flatten))
          ("3"
           (hide-all-but 1)
           (skosimp*)
           (lemma "nderiv_sin_fun" ("n" "nn!1"))
           (flatten))))
        ("2" (hide-all-but 1) (skosimp*) (assert))))
      ("3"
       (hide 2)
       (skosimp*)
       (lemma "nderiv_sin_fun" ("n" "nn!1"))
       (flatten))))
    ("3"
     (hide-all-but 1)
     (skosimp*)
     (lemma "nderiv_sin_fun" ("n" "nn!1"))
     (flatten))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "Taylors" ("f" "cos" "n" "2*n!1+1" "aa" "0" "bb" "x!1"))
   (lemma "nderiv_cos_fun" ("n" "2*n!1+2"))
   (flatten)
   (replace -1)
   (case "FORALL (n:nat): sigma(0, 2 * n + 1,
                                      LAMBDA (nn:nat):
                                        IF nn > 2 * n + 1 THEN 0
                                        ELSIF nn = 0 THEN cos(0)
                                        ELSE nderiv(nn, cos)(0) * (x!1 - 0) ^ nn / factorial(nn)
                                        ENDIF) = cos_series_n(x!1, n)")
   (("1" (inst - "n!1") (assert))
    ("2"
     (hide-all-but 1)
     (expand "cos_series_n")
     (induct "n")
     (("1"
       (expand "sigma")
       (expand "sigma")
       (expand "cos_series_term")
       (rewrite "cos_0")
       (lemma "nderiv_cos_fun" ("n" "1"))
       (flatten)
       (replace -2)
       (simplify)
       (lemma "cos_pi2")
       (expand "pi")
       (replace -1)
       (assert))
      ("2"
       (skosimp*)
       (expand "sigma" 1)
       (expand "sigma" 1 1)
       (lemma "sigma_eq[nat]"
        ("low"
         "0"
         "high"
         "1+2*j!1"
         "G"
         "LAMBDA (nn: nat):
                                     IF nn > 1 + 2 * j!1 THEN 0
                                     ELSIF nn = 0 THEN cos(0)
                                     ELSE nderiv(nn, cos)(0) * x!1 ^ nn / factorial(nn)
                                     ENDIF"
         "F"
         "LAMBDA (nn: nat):
                                     IF nn > 3 + 2 * j!1 THEN 0
                                     ELSIF nn = 0 THEN cos(0)
                                     ELSE nderiv(nn, cos)(0) * x!1 ^ nn / factorial(nn)
                                     ENDIF"))
       (("1"
         (split -1)
         (("1"
           (replace -1)
           (replace -2)
           (hide -1 -2)
           (lemma "sigma_eq[nat]"
            ("low"
             "0"
             "high"
             "j!1"
             "F"
             "LAMBDA (i: nat):
                                                 IF i > j!1 THEN 0 ELSE cos_series_term(x!1)(i) ENDIF"
             "G"
             "LAMBDA (i: nat):
                                                   IF i > 1 + j!1 THEN 0 ELSE cos_series_term(x!1)(i) ENDIF"))
           (split -1)
           (("1"
             (replace -1)
             (simplify 1)
             (hide -1)
             (lemma "nderiv_cos_fun" ("n" "3+2*j!1"))
             (lemma "nderiv_cos_fun" ("n" "2+2*j!1"))
             (flatten)
             (replace -2)
             (replace -4)
             (simplify 1)
             (hide-all-but 1)
             (lemma "cos_k_pi" ("k" "j!1+1"))
             (lemma "cos_eq_0" ("a" "((2 * (j!1 * pi) + 3 * pi) / 2)"))
             (flatten -1)
             (hide -1)
             (expand "pi")
             (split -1)
             (("1"
               (replace -1)
               (replace -2)
               (expand "cos_series_term")
               (assert))
              ("2" (hide-all-but 1) (inst + "j!1+1") (assert))))
            ("2" (hide 2) (skosimp*) (assert))))
          ("2" (hide-all-but 1) (skosimp*) (assert))))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (lemma "nderiv_cos_fun" ("n" "nn!1"))
         (flatten))
        ("3"
         (hide-all-but 1)
         (skosimp*)
         (lemma "nderiv_cos_fun" ("n" "nn!1"))
         (flatten))))
      ("3"
       (hide 2)
       (skosimp*)
       (lemma "nderiv_cos_fun" ("n" "nn!1"))
       (flatten))))
    ("3"
     (hide-all-but 1)
     (skosimp*)
     (lemma "nderiv_cos_fun" ("n" "nn!1"))
     (flatten))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: deriv_sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "scal_derivable_fun[T]")
   (inst - "k!1" "(LAMBDA (x: T): sin(alpha!1 * x))")
   (assert)
   (expand "*")
   (hide 2)
   (lemma "comp_derivable_fun[T,real]")
   (("1"
     (inst - "(LAMBDA (x:T): alpha!1*x)" "(LAMBDA (x:real): sin(x))")
     (assert)
     (hide 2)
     (split +)
     (("1"
       (lemma "scal_derivable_fun[T]")
       (inst - "alpha!1" "id[T]")
       (assert)
       (expand "id")
       (expand "*")
       (hide 2)
       (lemma "id_derivable_fun[T]")
       (propax))
      ("2"
       (lemma "sin_derivable")
       (expand "derivable?")
       (skosimp*)
       (expand "derivable?")
       (expand "convergent?")
       (inst - "x!1")
       (skosimp*)
       (inst + "l!1")
       (expand "convergence")
       (expand "convergence")
       (flatten)
       (split +)
       (("1" (propax))
        ("2"
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + delta!1)
         (skosimp*)
         (inst?)
         (assert)
         (expand "NQ")
         (propax))))))
    ("2" (lemma "not_one_element") (propax))
    ("3" (rewrite "deriv_domain"))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: deriv_sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "scal_derivable_fun[T]")
   (inst - "k!1" "(LAMBDA (x: T): cos(alpha!1 * x))")
   (assert)
   (expand "*")
   (hide 2)
   (lemma "comp_derivable_fun[T,real]")
   (("1"
     (inst - "(LAMBDA (x:T): alpha!1*x)" "(LAMBDA (x:real): cos(x))")
     (assert)
     (hide 2)
     (split +)
     (("1"
       (lemma "scal_derivable_fun[T]")
       (inst - "alpha!1" "id[T]")
       (assert)
       (expand "id")
       (expand "*")
       (hide 2)
       (lemma "id_derivable_fun[T]")
       (propax))
      ("2"
       (lemma "cos_derivable")
       (expand "derivable?")
       (skosimp*)
       (expand "derivable?")
       (expand "convergent?")
       (inst - "x!1")
       (skosimp*)
       (inst + "l!1")
       (expand "convergence")
       (expand "convergence")
       (flatten)
       (split +)
       (("1" (propax))
        ("2"
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + delta!1)
         (skosimp*)
         (inst?)
         (assert)
         (expand "NQ")
         (propax))))))
    ("2" (lemma "not_one_element") (propax))
    ("3" (rewrite "deriv_domain"))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: deriv_sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (auto-rewrite-theory "analysis@derivatives_lam[T]")
   (case "derivable?[T](LAMBDA (x: T): sin(alpha!1 * x))")
   (("1"
     (lemma "deriv_scal_fun[T]")
     (inst - "k!1" "(LAMBDA (x: T): sin(alpha!1 * x))")
     (assert)
     (expand "*")
     (assert)
     (apply-extensionality 2 :hide? t)
     (hide -1)
     (lemma "deriv_comp_fun[T,real]")
     (inst - "(LAMBDA (x:T): alpha!1*x)" "(LAMBDA (x:real): sin(x))")
     (("1"
       (expand "o ")
       (replace -1)
       (hide -1)
       (assert)
       (expand "*")
       (lemma deriv_scal_fun[T])
       (inst - "alpha!1" "id[T]")
       (("1"
         (assert)
         (expand "id")
         (expand "*")
         (assert)
         (lemma "deriv_id_fun[T]")
         (replace -1)
         (assert)
         (lemma "deriv_sin_fun")
         (case-replace "(LAMBDA (x: real): sin(x)) = sin")
         (("1" (replace -2) (assert))
          ("2" (apply-extensionality 1 :hide? t))))
        ("2" (lemma "id_derivable_fun[T]") (expand "id") (propax))))
      ("2"
       (lemma sin_derivable_fun)
       (case-replace "(LAMBDA (x: real): sin(x)) = sin")
       (apply-extensionality 1 :hide? t))))
    ("2"
     (assert)
     (hide 3)
     (lemma "sin_derivable")
     (inst?)
     (inst - "1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: deriv_sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (auto-rewrite-theory "analysis@derivatives_lam[T]")
   (case "derivable?[T](LAMBDA (x: T): cos(alpha!1 * x))")
   (("1"
     (lemma "deriv_scal_fun[T]")
     (inst - "k!1" "(LAMBDA (x: T): cos(alpha!1 * x))")
     (assert)
     (expand "*")
     (assert)
     (apply-extensionality 2 :hide? t)
     (hide -1)
     (lemma "deriv_comp_fun[T,real]")
     (inst - "(LAMBDA (x:T): alpha!1*x)" "(LAMBDA (x:real): cos(x))")
     (("1"
       (expand "o ")
       (replace -1)
       (hide -1)
       (assert)
       (expand "*")
       (lemma deriv_scal_fun[T])
       (inst - "alpha!1" "id[T]")
       (("1"
         (assert)
         (expand "id")
         (expand "*")
         (assert)
         (lemma "deriv_id_fun[T]")
         (replace -1)
         (assert)
         (lemma "deriv_cos_fun")
         (case-replace "(LAMBDA (x: real): cos(x)) = cos")
         (("1" (replace -2) (assert) (hide -) (expand "-") (assert))
          ("2" (apply-extensionality 1 :hide? t))))
        ("2" (lemma "id_derivable_fun[T]") (expand "id") (propax))))
      ("2"
       (lemma cos_derivable_fun)
       (case-replace "(LAMBDA (x: real): cos(x)) = cos")
       (apply-extensionality 1 :hide? t))))
    ("2"
     (assert)
     (hide 3)
     (lemma "cos_derivable")
     (inst?)
     (inst - "1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: integral_indef_sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "fundamental_indef[T]")
   (inst - "t1!1" "t2!1" "LAMBDA (t: T): v!1 * sin(theta!1 + w!1 * t)")
   (assert)
   (case-replace
    "continuous?(LAMBDA (t: T): v!1 * sin(w!1 * t + theta!1))")
   (("1"
     (flatten)
     (hide -1 -2 1)
     (lemma "integral_sin")
     (inst - "theta!1" "v!1" "w!1")
     (assert)
     (skosimp*)
     (replace -1)
     (hide -1)
     (expand "+")
     (expand "const_fun")
     (assert))
    ("2"
     (auto-rewrite-theory "continuous_lambda[T]")
     (hide -1 -2 2 3)
     (lemma "scal_mult_cont[T]")
     (inst - "(LAMBDA (t: T): sin(w!1 * t + theta!1))" "v!1")
     (hide 2)
     (lemma "composition_cont_fun[T, real]")
     (expand "o")
     (inst - "(LAMBDA(t:T):w!1 * t + theta!1)"
      "(LAMBDA(t:real): sin(t))")
     (assert)
     (hide 2)
     (lemma "sin_cont_fun")
     (case-replace "(LAMBDA(t:real):sin(t))=sin")
     (apply-extensionality 1))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: integral_indef_sincos
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "fundamental_indef[T]")
   (inst - "t1!1" "t2!1" "LAMBDA (t: T): v!1 * cos(theta!1 + w!1 * t)")
   (case-replace
    "continuous?(LAMBDA (t: T): v!1 * cos(w!1 * t + theta!1))")
   (("1"
     (flatten)
     (lemma "integral_cos")
     (inst - "theta!1" "v!1" "w!1")
     (assert)
     (skosimp*)
     (replace -1)
     (hide -1 -2 -3)
     (expand "+")
     (expand "const_fun")
     (assert))
    ("2"
     (hide 2)
     (auto-rewrite-theory "continuous_lambda[T]")
     (hide -1)
     (lemma "scal_mult_cont[T]")
     (inst - "(LAMBDA (t: T): cos(w!1 * t + theta!1))" "v!1")
     (hide 2)
     (lemma "composition_cont_fun[T, real]")
     (expand "o")
     (inst - "(LAMBDA(t:T):w!1 * t + theta!1)"
      "(LAMBDA(t:real): cos(t))")
     (assert)
     (hide 2)
     (lemma "cos_cont_fun")
     (case-replace "(LAMBDA(t:real):cos(t))=cos")
     (apply-extensionality 1))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "trichotomy" ("x" "x!1"))
   (expand "atan2")
   (split -1)
   (("1"
     (assert)
     (lemma "trichotomy" ("x" "y!1"))
     (split -1)
     (("1"
       (assert)
       (typepred "atan(y!1 / x!1)")
       (expand "pi")
       (expand "pi")
       (lemma "atan_strict_increasing")
       (expand "strict_increasing?")
       (inst - "0" "y!1/x!1")
       (lemma "posreal_div_posreal_is_posreal" ("px" "y!1" "py" "x!1"))
       (assert)
       (rewrite "atan_0")
       (expand "abs")
       (assert)
       (expand "atan")
       (assert))
      ("2" (replace -1) (assert) (rewrite "atan_0") (assert))
      ("3"
       (assert)
       (lemma "atan_strict_increasing")
       (expand "strict_increasing?")
       (typepred "atan(y!1 / x!1)")
       (inst - "y!1/x!1" "0")
       (lemma "both_sides_div_pos_gt1" ("x" "0" "y" "y!1" "pz" "x!1"))
       (assert)
       (rewrite "atan_0")
       (expand "abs")
       (assert)
       (expand "pi")
       (expand "pi")
       (expand "atan")
       (assert))))
    ("2"
     (replace -1)
     (assert)
     (lemma "trichotomy" ("x" "y!1"))
     (split -1)
     (("1" (assert)) ("2" (assert)) ("3" (assert))))
    ("3"
     (assert)
     (hide -2)
     (lemma "trichotomy" ("x" "y!1"))
     (split -1)
     (("1"
       (assert)
       (lemma "both_sides_div_neg_gt1")
       (inst - "x!1" "0" "y!1")
       (assert)
       (lemma "atan_strict_increasing")
       (expand "strict_increasing?")
       (inst - "y!1/x!1" "0")
       (rewrite "atan_0")
       (typepred "atan(y!1/x!1)")
       (expand "abs")
       (assert)
       (assert)
       (expand "pi")
       (expand "pi")
       (expand "atan")
       (assert))
      ("2" (assert) (replace -1) (rewrite "atan_0") (assert))
      ("3"
       (lemma "negreal_div_negreal_is_posreal" ("nx" "y!1" "ny" "x!1"))
       (("1"
         (lemma "atan_strict_increasing")
         (expand "strict_increasing?")
         (inst - "0" "y!1/x!1")
         (rewrite "atan_0")
         (assert)
         (typepred "atan(y!1/x!1)")
         (expand "abs")
         (expand "pi")
         (expand "pi")
         (expand "atan")
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "FORALL (x:real): sin(atan(x)) = x/sqrt(1+sq(x))")
   (("1"
     (expand "atan2")
     (case "x!1>0")
     (("1"
       (assert)
       (case "y!1>=0")
       (("1" (inst - "y!1/x!1") (assert))
        ("2"
         (inst - "y!1/x!1")
         (lemma "sin_period" ("a" "atan(y!1 / x!1)" "j" "1"))
         (assert))))
      ("2"
       (assert)
       (case "x!1=0")
       (("1"
         (assert)
         (replace -1)
         (rewrite "sin_pi2")
         (rewrite "sin_3pi2"))
        ("2"
         (assert)
         (rewrite "neg_sin" :dir rl)
         (inst - "y!1/x!1")
         (assert))))))
    ("2"
     (hide-all-but 1)
     (skosimp*)
     (case "FORALL (px:posreal):sin(atan(px)) = px / sqrt(1 + sq(px))")
     (("1"
       (lemma "trichotomy" ("x" "x!2"))
       (split -1)
       (("1" (inst - "x!2") (assert))
        ("2"
         (replace -1)
         (rewrite "atan_0")
         (rewrite "sin_0")
         (rewrite "sq_0")
         (rewrite "sqrt_1")
         (assert))
        ("3"
         (inst - "-x!2")
         (("1"
           (rewrite "atan_neg")
           (rewrite "sin_neg")
           (rewrite "sq_neg")
           (assert))
          ("2" (assert))))))
      ("2"
       (hide 2)
       (skosimp*)
       (expand "sin")
       (case "floor(atan(px!1) / (2 * pi)) = 0")
       (("1"
         (replace -1)
         (simplify)
         (hide -1)
         (lemma "atan_strict_increasing")
         (expand "strict_increasing?")
         (inst - "0" "px!1")
         (rewrite "atan_0")
         (assert)
         (case "atan(px!1)<pi/2")
         (("1"
           (lemma "phase_sin_q1" ("x" "atan(px!1)"))
           (assert)
           (lemma "sin_q1" ("x" "atan(px!1)"))
           (assert)
           (lemma "sin_value_atan" ("x" "px!1"))
           (assert))
          ("2" (assert))))
        ("2"
         (hide 2)
         (lemma "floor_def" ("x" "atan(px!1) / (2 * pi)"))
         (rewrite "div_mult_pos_lt1")
         (rewrite "div_mult_pos_le2")
         (flatten)
         (name-replace "K1" "floor(atan(px!1) / (2 * pi))")
         (typepred "atan(px!1)")
         (expand "abs")
         (lemma "atan_strict_increasing")
         (expand "strict_increasing?")
         (inst - "0" "px!1")
         (rewrite "atan_0")
         (assert)
         (expand "pi")
         (expand "atan")
         (case "K1>=1")
         (("1"
           (lemma "both_sides_times_pos_ge1"
            ("x" "K1" "y" "1" "pz" "8*atan_value(1)"))
           (("1" (assert))
            ("2"
             (lemma "both_sides_times_pos_le1"
              ("x" "K1" "y" "-1" "pz" "8*atan_value(1)"))
             (("1" (case "K1<=-1") (("1" (assert)) ("2" (assert))))
              ("2" (assert))))))
          ("2"
           (assert)
           (lemma "both_sides_times_pos_le1"
            ("x" "K1" "y" "-1" "pz" "8*atan_value(1)"))
           (case "K1<=-1")
           (("1" (assert)) ("2" (assert))))))))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: trig_inverses
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "arctan")
   (assert)
   (typepred "atan(y!1)")
   (lemma "arctan_prep")
   (inst?))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "sin2_cos2")
   (inst -1 "pi/4")
   (lemma "sin_cos_pi4")
   (case "sq(sin(pi / 4)) = sq(cos(pi / 4))")
   (("1"
     (replace -1 :hide? t)
     (hide -1)
     (ground)
     (case "sqrt(2 * sq(cos(pi / 4))) = 1")
     (("1"
       (rewrite "sqrt_times")
       (rewrite "sqrt_sq")
       (("1"
         (hide -2)
         (lemma "both_sides_div1")
         (inst -1 "sqrt(2)" "sqrt(2) * cos(pi / 4)" "1")
         (ground))
        ("2"
         (hide -1 -2 2)
         (lemma "cos_decreasing")
         (inst -1 "pi/2" "pi/4")
         (ground)
         (rewrite "cos_pi2")
         (ground))))
      ("2" (replace -1) (assert))))
    ("2" (ground))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_values
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "sin_pi6")
   (lemma "cos2")
   (inst?)
   (rewrite "sqrt_eq" :dir rl)
   (rewrite "sqrt_sq")
   (("1"
     (replace -2)
     (replace -1)
     (hide -1 -2)
     (case-replace "1 - sq(1 / 2) = 3/4")
     (("1"
       (rewrite "sqrt_div")
       (hide -1)
       (case-replace "sqrt(4) = 2")
       (hide 2)
       (case-replace "4 = 2*2")
       (("1" (hide -1) (rewrite "sqrt_square")) ("2" (assert))))
      ("2" (hide 2) (expand "sq") (assert))))
    ("2" (hide -1 -2 2) (rewrite "cos_ge_0"))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_extra
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "tan")
   (case "(sin(a!1) / cos(a!1) - sin(b!1) / cos(b!1) = sin(a!1 - b!1)
                                                      /
                                                      (cos(a!1)
                                                       *
                                                       cos(b!1))) = (sin(a!1 - b!1)
                                                                     /
                                                                     (cos(a!1)
                                                                      *
                                                                      cos
                                                                      (b!1)) = sin(a!1)
                                                                               /
                                                                               cos(a!1)
                                                                               -
                                                                               sin(b!1)
                                                                               /
                                                                               cos(b!1))")
   (("1"
     (replace -1 1 :hide? t)
     (rewrite "div_cancel3" 1)
     (rewrite "times_div1" 1)
     (case-replace
      "(cos(a!1) * cos(b!1) * sin(a!1)) / cos(a!1) = cos(b!1) * sin(a!1)")
     (("1"
       (case-replace
        "cos(a!1) * cos(b!1) * (sin(b!1) / cos(b!1)) = cos(a!1) * sin(b!1)")
       (("1" (hide -1 -2) (rewrite "sin_minus") (assert))
        ("2" (assert))))
      ("2" (assert))))
    ("2" (assert) (assert))
    ("3"
     (assert)
     (assert)
     (hide 2)
     (expand "Tan?")
     (lemma "zero_times3")
     (inst?)
     (assert))
    ("4" (assert) (assert) (expand "Tan?") (propax))
    ("5" (assert) (assert) (expand "Tan?") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_extra
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (prop)
   (("1"
     (lemma "sq_sin")
     (inst -1 "a!1/2")
     (replace -2 * lr)
     (expand "sq")
     (assert))
    ("2"
     (lemma "sq_sin")
     (inst -1 "a!1/2")
     (replace -2 * lr)
     (assert)
     (lemma "sq_eq_0")
     (inst -1 "sin(a!1/2)")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_extra
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "tan")
   (rewrite "sq_div")
   (("1"
     (rewrite "sq_sin")
     (rewrite "sq_cos")
     (assert)
     (rewrite "div_div2")
     (rewrite "div_cancel1"))
    ("2"
     (hide 3)
     (lemma "sq_cos")
     (inst -1 "a!1")
     (prop)
     (replace -2 * lr)
     (expand "sq")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "cos_term")
   (skosimp)
   (case-replace "n!1=0")
   (assert)
   (case-replace "a!1=0")
   (("1" (expand "^") (expand "expt") (propax))
    ("2"
     (lemma "expt_times" ("i" "2" "j" "n!1"))
     (inst-cp - "a!1")
     (inst - "-a!1")
     (case-replace "(-a!1) ^ 2 = a!1 ^ 2")
     (("1" (assert)) ("2" (hide-all-but (1 2)) (grind))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "cos_term")
   (lemma "exp_tends_to_0" ("n0a" "n0x!1"))
   (expand "exp_term")
   (expand "tends_to_0?")
   (skosimp*)
   (inst - "epsilon!1")
   (skosimp)
   (inst + "2*n!1")
   (skosimp)
   (inst - "2*i!1")
   (assert)
   (case-replace "i!1=0")
   (("1" (assert))
    ("2"
     (assert)
     (rewrite "abs_div")
     (rewrite "abs_div")
     (rewrite "abs_mult")
     (case-replace "abs((-1) ^ i!1) = 1")
     (("1" (assert))
      ("2"
       (hide-all-but 1)
       (case "(-1)^2 = 1")
       (("1"
         (case "even?(i!1)")
         (("1"
           (expand "even?")
           (skosimp)
           (replace -1)
           (rewrite "expt_times")
           (replace -2)
           (rewrite "expt_1i")
           (expand "abs")
           (propax))
          ("2"
           (rewrite "even_or_odd")
           (expand "odd?")
           (skosimp)
           (replace -1)
           (rewrite "expt_plus")
           (rewrite "expt_times")
           (replace -2)
           (rewrite "expt_x1")
           (rewrite "expt_1i")
           (expand "abs")
           (assert))))
        ("2" (hide 2) (grind))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "identity_derivable_fun[real]")
   (lemma "deriv_id_fun[real]")
   (expand "I")
   (expand "const_fun")
   (expand "sin_term")
   (expand "cos_term")
   (case-replace "n!1=0")
   (("1"
     (rewrite "expt_x0")
     (assert)
     (expand "^")
     (expand "expt")
     (expand "expt")
     (propax))
    ("2"
     (lemma "deriv_exp_fun[real]"
      ("f" "LAMBDA (x: real): x" "n" "2*n!1+1"))
     (assert)
     (expand "^" -1)
     (flatten)
     (lemma "scal_derivable_fun[real]"
      ("f"
       "LAMBDA (t: real): t ^ (1 + 2 * n!1)"
       "b"
       "(-1) ^ n!1 / factorial(1 + 2 * n!1)"))
     (assert)
     (lemma "deriv_scal_fun[real]"
      ("ff"
       "LAMBDA (t: real): t ^ (1 + 2 * n!1)"
       "b"
       "(-1) ^ n!1 / factorial(1 + 2 * n!1)"))
     (replace -5)
     (assert)
     (expand "*")
     (replace -4)
     (assert)
     (replace -1)
     (hide-all-but (1 2))
     (apply-extensionality 2 :hide? t)
     (name-replace "X" "x!1 ^ (2 * n!1)")
     (name-replace "S" "(-1) ^ n!1")
     (expand "factorial" 1 2)
     (expand "factorial" 1 3)
     (assert)
     (typepred "factorial(2*n!1)")
     (name-replace "F" "factorial(2 * n!1)")
     (lemma "div_cancel1")
     (inst - "2*n!1+1" "S*X/F")
     (assert)
     (assert)
     (rewrite "div_div2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "cos_term")
   (expand "sin_term")
   (case-replace "n!1=0")
   (("1"
     (lemma "const_derivable_fun[real]" ("b" "1"))
     (lemma "deriv_const_fun[real]" ("b" "1"))
     (expand "const_fun")
     (assert))
    ("2"
     (assert)
     (lemma "identity_derivable_fun[real]")
     (lemma "deriv_id_fun[real]")
     (expand "I")
     (expand "const_fun")
     (lemma "deriv_exp_fun[real]"
      ("f" "LAMBDA (x: real): x" "n" "2*n!1"))
     (assert)
     (expand "^" -1)
     (flatten)
     (lemma "scal_derivable_fun[real]"
      ("f"
       "LAMBDA (t: real): t ^ (2 * n!1)"
       "b"
       "(-1)^n!1/factorial(2 * n!1)"))
     (lemma "deriv_scal_fun[real]"
      ("ff"
       "LAMBDA (t: real): t ^ (2 * n!1)"
       "b"
       "(-1)^n!1/factorial(2 * n!1)"))
     (("1"
       (replace -5)
       (assert)
       (expand "*")
       (replace -4)
       (assert)
       (replace -1)
       (hide-all-but (1 2))
       (apply-extensionality 2 :hide? t)
       (name-replace "X" "x!1 ^ (2 * n!1 - 1)")
       (expand "^")
       (expand "expt" 1 1)
       (name-replace "S" "expt((-1), n!1 - 1)")
       (expand "factorial" 1 1)
       (assert))
      ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "sin_approx")
   (expand "sin_term")
   (expand "^" 1 2)
   (expand "expt")
   (induct "n")
   (("1" (expand "sigma") (assert) (expand "sigma") (assert))
    ("2" (skosimp*) (expand "sigma" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "sin_approx")
   (induct "n")
   (("1"
     (expand "sigma")
     (expand "sin_term")
     (skosimp)
     (rewrite "expt_x1")
     (rewrite "expt_x1")
     (assert)
     (expand "sigma")
     (assert))
    ("2"
     (skosimp*)
     (expand "sigma" 1)
     (inst - "a!1")
     (replace -1)
     (assert)
     (hide -1)
     (expand "sin_term")
     (assert)
     (case-replace "(-a!1) ^ (3 + 2 * j!1) = - a!1 ^ (3 + 2 * j!1)")
     (("1" (assert))
      ("2"
       (hide 2)
       (lemma "expt_plus" ("i" "1" "j" "2*j!1+2"))
       (case-replace "a!1=0")
       (("1" (expand "^" 1) (expand "expt" 1) (assert))
        ("2"
         (inst-cp - "-a!1")
         (("1"
           (inst - "a!1")
           (("1"
             (rewrite "expt_x1")
             (rewrite "expt_x1")
             (replace -1)
             (replace -2)
             (hide -1 -2)
             (lemma "expt_times" ("i" "2" "j" "1+j!1"))
             (inst-cp - "a!1")
             (("1"
               (inst - "-a!1")
               (("1"
                 (replace -1)
                 (replace -2)
                 (case-replace "(-a!1) ^ 2 = a!1 ^ 2")
                 (("1" (assert))
                  ("2"
                   (hide-all-but (1 2))
                   (expand "^")
                   (expand "expt")
                   (expand "expt")
                   (expand "expt")
                   (assert))))
                ("2" (assert))))
              ("2" (assert))))
            ("2" (assert))))
          ("2" (assert))))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "sin_series" ("x" "a!1" "n" "n!1"))
   (expand "sin_term")
   (case "forall (n:nat): sin_series_n(a!1, n) = sin_approx(a!1, n)")
   (("1"
     (inst - "n!1")
     (replace -1 -2)
     (hide -1)
     (rewrite "abs_div")
     (rewrite "abs_mult")
     (expand "abs" 1 4)
     (case-replace "abs((-1) ^ (1 + n!1)) = 1")
     (("1" (assert))
      ("2"
       (hide-all-but 1)
       (case "(-1)^2 =1")
       (("1"
         (case "even?(1+n!1)")
         (("1"
           (expand "even?")
           (skosimp)
           (replace -1)
           (rewrite "expt_times")
           (replace -2)
           (rewrite "expt_1i")
           (expand "abs")
           (propax))
          ("2"
           (rewrite "even_or_odd")
           (expand "odd?")
           (skosimp)
           (replace -1)
           (rewrite "expt_plus")
           (rewrite "expt_times")
           (replace -2)
           (rewrite "expt_1i")
           (rewrite "expt_x1")
           (expand "abs")
           (assert))))
        ("2"
         (hide 2)
         (expand "^")
         (expand "expt")
         (expand "expt")
         (expand "expt")
         (assert))))))
    ("2"
     (hide-all-but 1)
     (expand "sin_series_n")
     (expand "sin_approx")
     (expand "sin_term")
     (expand "sin_series_term")
     (induct "n")
     (("1" (expand "sigma") (expand "sigma") (propax))
      ("2"
       (skosimp*)
       (rewrite "sigma_rew" 1)
       (swap-rel 1)
       (rewrite "sigma_rew" 1)
       (replace -1 1 rl)
       (hide -1)
       (lemma "sigma_eq"
        ("low"
         "0"
         "high"
         "j!1"
         "F"
         "LAMBDA (i: nat):
                              IF i > 1 + j!1 THEN 0
                              ELSE ((-1) ^ i * a!1 ^ (1 + 2 * i)) / factorial(1 + 2 * i)
                              ENDIF"
         "G"
         "LAMBDA (i: nat):
                               IF i > j!1 THEN 0
                               ELSE ((-1) ^ i * a!1 ^ (1 + 2 * i)) / factorial(1 + 2 * i)
                               ENDIF"))
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "cos_approx")
   (expand "cos_term")
   (induct "n")
   (("1" (expand "sigma") (expand "sigma") (propax))
    ("2"
     (skosimp*)
     (expand "sigma" 1)
     (expand "^" 1 4)
     (expand "expt")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "cos_approx")
   (induct "n")
   (("1"
     (expand "sigma")
     (expand "cos_term")
     (skosimp*)
     (expand "sigma" 1)
     (propax))
    ("2"
     (skosimp*)
     (expand "sigma" 1)
     (inst - "a!1")
     (replace -1)
     (assert)
     (hide -1)
     (expand "cos_term")
     (case-replace "a!1=0")
     (("1" (expand "^") (expand "expt") (propax))
      ("2"
       (lemma "expt_times" ("i" "2" "j" "1+j!1"))
       (inst-cp - "a!1")
       (inst - "-a!1")
       (case-replace "(-a!1) ^ 2 = a!1 ^ 2")
       (("1" (assert)) ("2" (hide-all-but (1 2)) (grind))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "cos_series" ("x" "a!1" "n" "n!1"))
   (expand "cos_term")
   (rewrite "abs_div")
   (expand "abs" 1 3)
   (rewrite "abs_mult")
   (case-replace "abs((-1)^(1+n!1))=1")
   (("1"
     (case "forall (n:nat): cos_series_n(a!1, n) = cos_approx(a!1, n)")
     (("1" (inst - "n!1") (assert))
      ("2"
       (hide-all-but 1)
       (expand "cos_approx")
       (expand "cos_series_n")
       (expand "cos_series_term")
       (expand "cos_term")
       (induct "n")
       (("1" (expand "sigma") (expand "sigma") (propax))
        ("2"
         (skosimp*)
         (expand "sigma" 1)
         (replace -1 1 rl)
         (hide -1)
         (lemma "sigma_eq"
          ("low"
           "0"
           "high"
           "j!1"
           "F"
           "LAMBDA (i: nat):
                         IF i > 1 + j!1 THEN 0
                         ELSE IF i = 0 THEN 1
                              ELSE (-1) ^ i * a!1 ^ (2 * i) / factorial(2 * i)
                              ENDIF
                         ENDIF"
           "G"
           "LAMBDA (i: nat):
                          IF i > j!1 THEN 0
                          ELSE IF i = 0 THEN 1
                               ELSE (-1) ^ i * a!1 ^ (2 * i) / factorial(2 * i)
                               ENDIF
                          ENDIF"))
         (assert))))))
    ("2"
     (hide-all-but 1)
     (case "(-1)^2=1")
     (("1"
       (case "even?(1+n!1)")
       (("1"
         (expand "even?")
         (skosimp)
         (replace -1)
         (rewrite "expt_times")
         (replace -2)
         (rewrite "expt_1i")
         (expand "abs")
         (propax))
        ("2"
         (rewrite "even_or_odd")
         (expand "odd?")
         (skosimp*)
         (replace -1)
         (rewrite "expt_plus")
         (rewrite "expt_times")
         (rewrite "expt_x1")
         (replace -2)
         (rewrite "expt_1i")
         (expand "abs")
         (assert))))
      ("2"
       (hide 2)
       (expand "^")
       (expand "expt")
       (expand "expt")
       (expand "expt")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "sin_approx")
   (expand "cos_approx")
   (induct "n")
   (("1"
     (expand "sigma")
     (lemma "sin_term_deriv" ("n" "0"))
     (flatten)
     (lemma "sin_term_deriv" ("n" "0"))
     (flatten)
     (expand "sigma")
     (propax))
    ("2"
     (lemma "sin_term_deriv" ("n" "0"))
     (flatten)
     (expand "sigma")
     (expand "sigma")
     (propax))
    ("3"
     (skosimp)
     (expand "sigma" 1)
     (lemma "sin_term_deriv" ("n" "1+j!1"))
     (flatten)
     (lemma "sum_derivable_fun[real]"
      ("f1"
       "LAMBDA a: sin_term(a)(1 + j!1)"
       "f2"
       "LAMBDA a: sigma(0, j!1, sin_term(a))"))
     (assert)
     (lemma "deriv_sum_fun[real]"
      ("ff1"
       "LAMBDA a: sin_term(a)(1 + j!1)"
       "ff2"
       "LAMBDA a: sigma(0, j!1, sin_term(a))"))
     (replace -4)
     (replace -6)
     (expand "+")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "cos_approx")
   (expand "sin_approx")
   (induct "n")
   (("1"
     (expand "sigma")
     (expand "cos_term")
     (lemma "const_derivable_fun[real]" ("b" "1"))
     (expand "sigma")
     (propax))
    ("2"
     (lemma "deriv_const_fun[real]" ("b" "1"))
     (expand "sigma")
     (expand "cos_term")
     (expand "sigma")
     (propax))
    ("3"
     (skosimp*)
     (case-replace "j!1=0")
     (("1"
       (assert)
       (expand "sigma" 1)
       (lemma "cos_term_deriv" ("n" "1"))
       (flatten)
       (lemma "sum_derivable_fun[real]"
        ("f1"
         "LAMBDA a: cos_term(a)(1)"
         "f2"
         "LAMBDA a: sigma(0, 0, cos_term(a))"))
       (assert)
       (expand "+")
       (assert)
       (lemma "deriv_sum_fun[real]"
        ("ff1"
         "LAMBDA a: cos_term(a)(1)"
         "ff2"
         "LAMBDA a: sigma(0, 0, cos_term(a))"))
       (replace -7)
       (replace -4)
       (expand "+")
       (assert))
      ("2"
       (assert)
       (expand "sigma" 2)
       (lemma "cos_term_deriv" ("n" "1+j!1"))
       (flatten)
       (assert)
       (lemma "sum_derivable_fun[real]"
        ("f1"
         "LAMBDA a: cos_term(a)(1 + j!1)"
         "f2"
         "LAMBDA a: sigma(0, j!1, cos_term(a))"))
       (assert)
       (expand "+")
       (assert)
       (lemma "deriv_sum_fun[real]"
        ("ff1"
         "LAMBDA a: cos_term(a)(1+j!1)"
         "ff2"
         "LAMBDA a: sigma(0, j!1, cos_term(a))"))
       (replace -4)
       (replace -6)
       (expand "+")
       (replace -1)
       (hide-all-but (1 2))
       (apply-extensionality 2 :hide? t))))
    ("4" (skosimp) (assert)) ("5" (skosimp) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skosimp)
     (expand "sin_lb")
     (expand "sin_approx")
     (expand "sigma")
     (expand "sin_term")
     (expand "sigma")
     (rewrite "expt_x0")
     (rewrite "expt_x1")
     (rewrite "expt_x1")
     (expand "factorial")
     (expand "factorial")
     (expand "factorial")
     (expand "factorial")
     (assert)
     (case "px!1<=6")
     (("1"
       (lemma "le_times_le_pos"
        ("nnx" "px!1" "y" "6" "nnz" "px!1" "w" "6"))
       (assert))
      ("2"
       (case "6<px!1")
       (("1"
         (hide 1)
         (case "1-px!1*px!1/6 < -6")
         (("1"
           (lemma "both_sides_times_pos_lt1"
            ("pz" "px!1" "x" "1 - px!1 * px!1 / 6" "y" "-6"))
           (assert)
           (expand "^")
           (expand "expt")
           (expand "expt")
           (expand "expt")
           (expand "expt")
           (assert))
          ("2"
           (hide 2)
           (lemma "both_sides_div_pos_lt1"
            ("pz" "6" "x" "42" "y" "px!1*px!1"))
           (assert))))
        ("2" (assert))))))
    ("2"
     (skosimp*)
     (inst - "px!1")
     (assert)
     (expand "sin_lb")
     (lemma "sin_approx_next" ("a" "px!1" "n" "1+2*j!1"))
     (lemma "div_mult_pos_gt1"
      ("z"
       "px!1*px!1"
       "py"
       "110 + 44 * j!1 + (16 * (j!1 * j!1) + 40 * j!1)"
       "x"
       "1"))
     (assert)
     (name-replace "SN" "sin_approx(px!1, 1 + 2 * j!1)")
     (name-replace "SN2" "sin_approx(px!1, 3 + 2 * j!1)")
     (lemma "sin_term_gt0" ("a" "px!1" "n" "2*(1+j!1)"))
     (assert)
     (name-replace "ST" "sin_term(px!1)(2 + 2 * j!1)")
     (case "1-px!1 * px!1 / (42 + 28 * j!1 + (16 * (j!1 * j!1) + 24 * j!1))<0")
     (("1"
       (lemma "both_sides_times_pos_lt1"
        ("pz"
         "ST"
         "x"
         "1 - px!1 * px!1 / (42 + 28 * j!1 + (16 * (j!1 * j!1) + 24 * j!1))"
         "y"
         "0"))
       (("1"
         (assert)
         (assert)
         (name-replace "TT"
          "(px!1 * px!1 / (42 + 16 * (j!1 * j!1) + 52 * j!1))")
         (assert))
        ("2" (assert))))
      ("2"
       (hide 2 -1 -3 -4)
       (hide -1)
       (lemma "div_mult_pos_gt1"
        ("z"
         "px!1*px!1"
         "py"
         "(42 + 28 * j!1 + (16 * (j!1 * j!1) + 24 * j!1))"
         "x"
         "1"))
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (case "sin_lb(px!1,0) > 0")
   (("1"
     (case-replace "n!1=0")
     (lemma "sin_lb_inc" ("px" "px!1" "n" "0" "pm" "n!1"))
     (("1" (assert)) ("2" (assert))))
    ("2"
     (assert)
     (hide 2)
     (expand "sin_lb")
     (assert)
     (expand "sin_approx")
     (expand "sigma")
     (expand "sigma")
     (expand "sin_term")
     (expand "^")
     (expand "expt")
     (expand "expt")
     (expand "expt")
     (expand "expt")
     (expand "factorial")
     (expand "factorial")
     (expand "factorial")
     (expand "factorial")
     (assert)
     (lemma "posreal_times_posreal_is_posreal"
      ("px" "px!1/6" "py" "6-px!1*px!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (n: nat, n0x: nzreal):
                 n0x * n0x < (4 * n + 6) * (4 * n + 5) =>
                  cos_lb(n0x, n) < cos_lb(n0x, n + 1)")
   (("1"
     (induct "pm")
     (("1" (assert)) ("2" (assert))
      ("3"
       (skosimp*)
       (inst - "n!1" "n0x!1")
       (replace -3)
       (case-replace "j!1=0")
       (("1" (assert))
        ("2" (assert) (inst - "n!1+1" "n0x!1") (assert))))))
    ("2"
     (hide 2)
     (skosimp)
     (expand "cos_lb")
     (lemma "cos_approx_next" ("a" "n0x!1" "n" "1+2*n!1"))
     (lemma "cos_term_gt0" ("a" "n0x!1" "n" "2*(1+n!1)"))
     (simplify -1)
     (name-replace "CT" "cos_term(n0x!1)(2 + 2 * n!1)")
     (name-replace "CN" "cos_approx(n0x!1, 1 + 2 * n!1)")
     (name-replace "CN2" "cos_approx(n0x!1, 3 + 2 * n!1)")
     (lemma "div_mult_pos_lt1"
      ("z" "n0x!1*n0x!1" "py" "(4 * n!1 + 6) * (4 * n!1 + 5)" "x" "1"))
     (name-replace "TT"
      "n0x!1 * n0x!1 / ((4 * n!1 + 6) * (4 * n!1 + 5))")
     (assert)
     (lemma "posreal_times_posreal_is_posreal" ("px" "CT" "py" "1-TT"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skosimp)
     (expand "cos_lb")
     (expand "cos_approx")
     (expand "sigma")
     (expand "sigma")
     (expand "cos_term")
     (rewrite "expt_x1")
     (expand "factorial")
     (expand "factorial")
     (expand "factorial")
     (expand "^")
     (expand "expt")
     (expand "expt")
     (expand "expt")
     (assert))
    ("2"
     (skosimp*)
     (expand "cos_lb")
     (inst - "n0x!1")
     (lemma "cos_approx_next" ("a" "n0x!1" "n" "1+2*j!1"))
     (name-replace "CN1" "cos_approx(n0x!1, 1 + 2 * j!1)")
     (name-replace "CN3" "cos_approx(n0x!1, 3 + 2 * j!1)")
     (lemma "cos_term_gt0" ("a" "n0x!1" "n" "2*(1+j!1)"))
     (simplify -1)
     (name-replace "CT" "cos_term(n0x!1)(1 + 2 * j!1 + 1)")
     (assert)
     (lemma "div_mult_pos_gt1"
      ("z"
       "n0x!1*n0x!1"
       "py"
       "(30 + 24 * j!1 + (16 * (j!1 * j!1) + 20 * j!1))"
       "x"
       "1"))
     (assert)
     (name-replace "TT"
      "n0x!1 * n0x!1 / (30 + 16 * (j!1 * j!1) + 44 * j!1)")
     (lemma "both_sides_times_pos_lt1" ("pz" "CT" "x" "1-TT" "y" "0"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (n: nat, px: posreal):
                                             px * px > (4 * n + 4) * (4 * n + 3) & n >= 1 => cos_ub(px, n) > 1")
   (("1"
     (skosimp)
     (lemma "trichotomy" ("x" "n0x!1"))
     (split -1)
     (("1" (inst - "n!1" "n0x!1") (("1" (assert)) ("2" (assert))))
      ("2" (assert))
      ("3"
       (inst - "n!1" "-n0x!1")
       (("1" (assert) (expand "cos_ub") (rewrite "cos_approx_neg"))
        ("2" (assert))))))
    ("2"
     (hide 2)
     (induct "n")
     (("1" (skosimp) (assert))
      ("2"
       (skosimp*)
       (case-replace "j!1=0")
       (("1"
         (assert)
         (hide -1 -2 -4)
         (expand "cos_ub")
         (expand "cos_approx")
         (expand "sigma")
         (expand "sigma")
         (expand "sigma")
         (expand "cos_term")
         (expand "factorial")
         (expand "factorial")
         (expand "factorial")
         (expand "factorial")
         (expand "factorial")
         (rewrite "expt_x1")
         (lemma "expt_times" ("n0x" "px!1" "i" "2" "j" "2"))
         (case-replace "px!1^2=px!1*px!1")
         (("1"
           (replace -2)
           (name-replace "X" "px!1 * px!1")
           (hide -1 -2)
           (expand "^")
           (expand "expt")
           (expand "expt")
           (expand "expt")
           (lemma "posreal_times_posreal_is_posreal"
            ("px" "X" "py" "X/24-1/2"))
           (("1" (assert))
            ("2"
             (hide 2)
             (lemma "both_sides_times_pos_lt1"
              ("pz" "24" "x" "0" "y" "X / 24 - 1 / 2"))
             (assert))))
          ("2" (hide-all-but 1) (grind))))
        ("2"
         (inst - "px!1")
         (expand "cos_ub")
         (lemma "cos_approx_next" ("a" "px!1" "n" "2*j!1"))
         (lemma "cos_term_lt0" ("a" "px!1" "n" "2*j!1+1"))
         (simplify -1)
         (name-replace "CT" "cos_term(px!1)(1 + 2 * j!1)")
         (lemma "div_mult_pos_gt1"
          ("z" "px!1*px!1" "py" "(4*j!1+4)*(4*j!1+3)" "x" "1"))
         (name-replace "TT"
          "px!1 * px!1 / ((4 * j!1 + 4) * (4 * j!1 + 3))")
         (assert)
         (lemma "negreal_times_negreal_is_posreal"
          ("nx" "CT" "ny" "1-TT"))
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_lb")
   (lemma "sin_approx_deriv" ("n" "1+2*n!1"))
   (flatten)
   (lemma "restrict2_derivable[nnreal,real]"
    ("f" "LAMBDA a: sin_approx(a, 1+2*n!1)"))
   (("1"
     (lemma "restrict2_deriv[nnreal,real]"
      ("f" "LAMBDA a: sin_approx(a, 1+2*n!1)"))
     (expand "restrict2")
     (assert)
     (replace -4)
     (assert)
     (expand "cos_lb")
     (apply-extensionality 1 :hide? t)
     (inst - "x!1")
     (replace -1 1 rl)
     (propax))
    ("2" (propax)) ("3" (hide-all-but 1) (grind))
    ("4" (hide-all-but 1) (skosimp) (inst 1 "x!1+1") (assert))
    ("5" (hide-all-but 1) (skosimp) (inst 1 "x!1+1") (assert))
    ("6" (hide-all-but 1) (lemma deriv_domain_real) (propax))
    ("7" (hide-all-but 1) (lemma deriv_domain_nnreal) (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sin_ub")
   (expand "cos_ub")
   (lemma "sin_approx_deriv" ("n" "2*n!1"))
   (flatten)
   (lemma "restrict2_derivable[nnreal,real]"
    ("f" "LAMBDA a: sin_approx(a, 2*n!1)"))
   (("1"
     (lemma "restrict2_deriv[nnreal,real]"
      ("f" "LAMBDA a: sin_approx(a, 2*n!1)"))
     (expand "restrict2")
     (replace -4)
     (simplify -1)
     (assert)
     (apply-extensionality 1 :hide? t)
     (inst - "x!1")
     (assert))
    ("2" (propax)) ("3" (hide-all-but 1) (grind))
    ("4" (hide-all-but 1) (skosimp) (inst 1 "x!1+1") (assert))
    ("5" (hide-all-but 1) (skosimp) (inst 1 "x!1+1") (assert))
    ("6" (hide-all-but 1) (assert) (lemma deriv_domain_real) (propax))
    ("7" (hide-all-but 1) (lemma deriv_domain_nnreal) (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "cos_lb")
   (lemma "cos_approx_deriv" ("n" "1+2*n!1"))
   (flatten)
   (assert)
   (replace -2)
   (hide-all-but 1)
   (apply-extensionality :hide? t)
   (expand "sin_lb")
   (expand "sin_ub")
   (propax))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "cos_ub")
   (lemma "cos_approx_deriv" ("n" "2*n!1"))
   (flatten)
   (assert)
   (replace -2 1)
   (apply-extensionality 1 :hide? t)
   (("1"
     (case-replace "n!1=0")
     (("1" (assert))
      ("2" (assert) (expand "sin_ub") (expand "sin_lb") (propax))))
    ("2" (skosimp) (assert)) ("3" (skosimp) (assert))
    ("4" (skosimp) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "strict_decreasing?")
   (skosimp*)
   (typepred "x!1")
   (typepred "y!1")
   (expand ">=")
   (expand "<=" -3)
   (split -3)
   (("1"
     (lemma "cos_lb_deriv" ("n" "n!1"))
     (flatten)
     (lemma "restrict2_derivable[{x: posreal | x <= pi},real]"
      ("f" "LAMBDA a: cos_lb(a, n!1)"))
     (("1"
       (lemma "restrict2_deriv[{x: posreal | x <= pi},real]"
        ("f" "LAMBDA a: cos_lb(a, n!1)"))
       (expand "restrict2")
       (replace -4)
       (simplify -1)
       (lemma "negative_derivative[{x:posreal | x <= pi}]"
        ("g" "LAMBDA (a:{x:posreal | x <= pi}): cos_lb(a, n!1)"))
       (("1"
         (split -1)
         (("1"
           (expand "strict_decreasing?")
           (inst - "x!1" "y!1")
           (("1" (assert)) ("2" (assert)) ("3" (assert))))
          ("2"
           (skosimp)
           (inst - "x!2")
           (expand "deriv" -1)
           (replace -1 1 rl)
           (hide-all-but 1)
           (typepred "x!2")
           (lemma "sin_ub" ("n0x" "x!2" "n" "n!1"))
           (lemma "sin_ge_0" ("a" "x!2"))
           (assert))))
        ("2" (propax))
        ("3"
         (hide-all-but 1)
         (assert)
         (expand "connected?")
         (skosimp*)
         (assert))))
      ("2" (propax)) ("3" (skosimp*) (inst 1 "x!2"))
      ("4"
       (hide-all-but 1)
       (assert)
       (expand "not_one_element?")
       (skosimp*)
       (inst + "x!2/2")
       (assert))
      ("5"
       (hide-all-but 1)
       (lemma "deriv_domain_oc")
       (inst - "0" "pi")
       (assert)
       (expand "deriv_domain?")
       (skosimp*)
       (inst - "e!1" "x!2")
       (skosimp*)
       (inst + "y!2"))))
    ("2"
     (replace -1 * rl)
     (lemma "cos_lb" ("n0x" "y!1" "n" "n!1"))
     (("1"
       (typepred "cos(y!1)")
       (expand "cos_lb")
       (rewrite "cos_approx_a0")
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (rewrite "sin_shift" :dir rl)
   (lemma "pi_lb_diff" ("n" "n!1"))
   (lemma "pi_lb_inc" ("n" "n!1" "m" "n!1+1"))
   (simplify -1)
   (lemma "pi_bounds" ("n" "n!1+1"))
   (flatten)
   (hide -2)
   (name "KK"
         "16 * (1 / 5) ^ (4 * n!1 + 5) *
                               (1 / (4 * n!1 + 5) - 1 / (25 * (4 * n!1 + 7)))
                               +
                               4 * (1 / 239) ^ (4 * n!1 + 3) *
                                (1 / (4 * n!1 + 3) - 1 / (57121 * (4 * n!1 + 5)))")
   (replace -1)
   (case "pi / 2 - pi_lbn(n!1) / 2 > KK / 2")
   (("1"
     (case "pi / 2 - pi_lbn(n!1) / 2 < 1/500")
     (("1"
       (lemma "sin_px" ("px" "pi / 2 - pi_lbn(n!1) / 2"))
       (("1"
         (split -1)
         (("1"
           (case "cos_term(pi_lbn(n!1) / 2)(2 * n!1 + 2) < KK/2 * (1 - 1 / 1500000)")
           (("1" (assert))
            ("2"
             (hide 2)
             (hide -1)
             (name "F"
                   "lambda (n:nat): 8 * (1 / 5) ^ (4 * n + 5) *
                                                            (1 / (4 * n + 5) - 1 / (25 * (4 * n + 7)))
                                                            +
                                                            2 * (1 / 239) ^ (4 * n + 3) *
                                                             (1 / (4 * n + 3) - 1 / (57121 * (4 * n + 5)))")
             (case-replace "KK/2=F(n!1)")
             (("1"
               (hide -1 -2 -5)
               (expand "cos_term")
               (case-replace "(-1) ^ (2 + 2 * n!1)=1")
               (("1"
                 (lemma "both_sides_expt_pos_lt"
                  ("px"
                   "pi_lbn(n!1) / 2"
                   "py"
                   "31415927/20000000"
                   "pm"
                   "4 + 4 * n!1"))
                 (lemma "pi_ub")
                 (assert)
                 (name "G"
                       "lambda (n:nat): (31415927 / 20000000) ^ (4 + 4 * n)/factorial(4 + 4 * n)")
                 (case "(1 * (pi_lbn(n!1) / 2) ^ (4 + 4 * n!1)) / factorial(4 + 4 * n!1) <G(n!1)")
                 (("1"
                   (case "forall (m:nat): m>=5 => G(m)<F(m)*(1 - 1 / 1500000)")
                   (("1"
                     (inst - "n!1")
                     (assert)
                     (name-replace "DRL1"
                      "(1 * (pi_lbn(n!1) / 2) ^ (4 + 4 * n!1)) / factorial(4 + 4 * n!1)")
                     (assert))
                    ("2"
                     (hide-all-but 1)
                     (case "G(5) < F(5) * (1 - 1 / 1500000)")
                     (("1"
                       (case "FORALL (m: nat): m >= 5 & G(m) < F(m) * (1 - 1 / 1500000) => G(m+1) < F(m+1) * (1 - 1 / 1500000)")
                       (("1"
                         (induct "m")
                         (("1" (flatten) (assert))
                          ("2"
                           (skosimp*)
                           (case-replace "j!1=4")
                           (("1" (assert))
                            ("2" (assert) (inst - "j!1") (assert))))))
                        ("2"
                         (hide 2 -1)
                         (skosimp)
                         (name "LHS"
                               "(31415927 / 20000000) ^ 4/((5+4 * m!1)*(6+4 * m!1)*(7+4 * m!1)*(8+4 * m!1))")
                         (case-replace "G(m!1 + 1)=G(m!1)*LHS")
                         (("1"
                           (hide -1)
                           (case "LHS*F(m!1)<F(m!1 + 1)")
                           (("1"
                             (lemma "both_sides_times_pos_lt1"
                              ("pz"
                               "LHS"
                               "x"
                               "G(m!1)"
                               "y"
                               "F(m!1) * (1 - 1 / 1500000)"))
                             (assert))
                            ("2"
                             (hide -3 2)
                             (expand "F" 1)
                             (lemma "expt_plus"
                              ("n0x" "1/5" "i" "4" "j" "5+4*m!1"))
                             (replace -1)
                             (hide -1)
                             (name-replace "FIVE"
                              "(1 / 5) ^ (5 + 4 * m!1)")
                             (lemma "expt_plus"
                              ("n0x"
                               "1 / 239"
                               "i"
                               "4"
                               "j"
                               "3 + 4 * m!1"))
                             (replace -1)
                             (hide -1)
                             (name-replace "TWOTHREENINE"
                              "(1 / 239) ^ (3 + 4 * m!1)")
                             (case-replace
                              "(1 / 239) ^ 4 * TWOTHREENINE * (1 / (514089 + 228484 * m!1))= (1 / 239) ^ 6 * TWOTHREENINE * (1 / (9+4*m!1))")
                             (("1"
                               (hide -1)
                               (case-replace
                                "(TWOTHREENINE * (1 / (285605 + 228484 * m!1))) = (1/239)^2 * (TWOTHREENINE * (1 / (5 + 4 * m!1)))")
                               (("1"
                                 (hide -1)
                                 (case-replace
                                  "(FIVE * (1 / (175 + 100 * m!1))) = (1/5)^2*FIVE*(1/(7+4*m!1))")
                                 (("1"
                                   (hide -1)
                                   (case
                                    "-2 * ((1 / 239) ^ 2 * (TWOTHREENINE * (1 / (5 + 4 * m!1))) * LHS) -
                                                                                                               8 * ((1 / 5) ^ 2 * FIVE * (1 / (7 + 4 * m!1)) * LHS)
                                                                                                               + 8 * ((FIVE * (1 / (5 + 4 * m!1))) * LHS)
                                                                                                               + 2 * ((TWOTHREENINE * (1 / (3 + 4 * m!1))) * LHS) < 8 * ((FIVE * (1 / (5 + 4 * m!1))) * LHS)")
                                   (("1"
                                     (case
                                      "8 * ((FIVE * (1 / (5 + 4 * m!1))) * LHS)<8 * ((1 / 5) ^ 4 * FIVE * (1 / (9 + 4 * m!1))) +
                                                                                                                      2 * ((1 / 239) ^ 4 * TWOTHREENINE * (1 / (7 + 4 * m!1)))
                                                                                                                      - 2 * ((1 / 239) ^ 6 * TWOTHREENINE * (1 / (9 + 4 * m!1)))
                                                                                                                      - 8 * ((1 / 5) ^ 4 * FIVE * (1 / (275 + 100 * m!1)))")
                                     (("1" (assert))
                                      ("2"
                                       (hide 2 -1)
                                       (lemma
                                        "expt_plus"
                                        ("n0x" "1/239" "i" "2" "j" "4"))
                                       (replace -1)
                                       (hide -1)
                                       (lemma
                                        "both_sides_times_pos_lt1"
                                        ("pz"
                                         "2 * (1 / 239) ^ 4 * TWOTHREENINE"
                                         "y"
                                         "1 / (7 + 4 * m!1) -(1 / 239) ^ 2/ (9 + 4 * m!1)"
                                         "x"
                                         "0"))
                                       (flatten -1)
                                       (hide -1)
                                       (split -1)
                                       (("1"
                                         (case
                                          "8 * ((FIVE * (1 / (5 + 4 * m!1))) * LHS) <8 * ((1 / 5) ^ 4 * FIVE * (1 / (9 + 4 * m!1))) - 8 * ((1 / 5) ^ 4 * FIVE * (1 / (275 + 100 * m!1)))")
                                         (("1" (assert))
                                          ("2"
                                           (hide -1 2)
                                           (case-replace
                                            "1 / (275 + 100 * m!1) = (1/5)^2*1/(11+4*m!1)")
                                           (("1"
                                             (hide -1)
                                             (lemma
                                              "both_sides_times_pos_lt1"
                                              ("pz"
                                               "8*FIVE"
                                               "x"
                                               "LHS/(5 + 4 * m!1)"
                                               "y"
                                               "(1 / 5) ^ 4*(1 / (9 + 4 * m!1) - (1 / 5) ^ 2 / (11 + 4 * m!1))"))
                                             (replace -1 1)
                                             (hide -1)
                                             (case
                                              "(24/25)*(1 / (9 + 4 * m!1)) < (1 / (9 + 4 * m!1) - (1 / 5) ^ 2 / (11 + 4 * m!1))")
                                             (("1"
                                               (case
                                                "LHS / (5 + 4 * m!1) <(1 / 5) ^ 4 *(24 / 25) * (1 / (9 + 4 * m!1))")
                                               (("1"
                                                 (name-replace
                                                  "RHS"
                                                  "(1 / (9 + 4 * m!1) - (1 / 5) ^ 2 / (11 + 4 * m!1))")
                                                 (lemma
                                                  "both_sides_times_pos_lt1"
                                                  ("pz"
                                                   "(1/5)^4"
                                                   "x"
                                                   "(24 / 25) * (1 / (9 + 4 * m!1))"
                                                   "y"
                                                   "RHS"))
                                                 (assert))
                                                ("2"
                                                 (hide 2)
                                                 (hide -1)
                                                 (case
                                                  "(31415927 / 20000000) ^ 4 < 609/100")
                                                 (("1"
                                                   (lemma
                                                    "both_sides_div_pos_lt1"
                                                    ("pz"
                                                     "((5 + 4 * m!1) * (6 + 4 * m!1) * (7 + 4 * m!1) * (8 + 4 * m!1))"
                                                     "x"
                                                     "(31415927 / 20000000) ^ 4"
                                                     "y"
                                                     "609 / 100"))
                                                   (replace -3)
                                                   (replace -2)
                                                   (flatten -1)
                                                   (case
                                                    "LHS < (1 / 5) ^ 4 * (12/15)")
                                                   (("1"
                                                     (hide -2 -3 -4)
                                                     (lemma
                                                      "both_sides_div_pos_lt1"
                                                      ("pz"
                                                       "5 + 4 * m!1"
                                                       "x"
                                                       "LHS"
                                                       "y"
                                                       "(1 / 5) ^ 4 * (12 / 15)"))
                                                     (replace -2)
                                                     (flatten)
                                                     (lemma
                                                      "both_sides_times_pos_lt1"
                                                      ("pz"
                                                       "(1 / 5) ^ 4"
                                                       "x"
                                                       "(12 / 15) / (5 + 4 * m!1)"
                                                       "y"
                                                       "(24 / 25) * (1 / (9 + 4 * m!1))"))
                                                     (flatten)
                                                     (hide -1)
                                                     (split -1)
                                                     (("1" (assert))
                                                      ("2"
                                                       (hide -1 -2 2)
                                                       (lemma
                                                        "both_sides_times_pos_lt1"
                                                        ("pz"
                                                         "12/75"
                                                         "x"
                                                         "5/(5 + 4 * m!1)"
                                                         "y"
                                                         "6/(9 + 4 * m!1)"))
                                                       (replace -1 1)
                                                       (hide -1)
                                                       (lemma
                                                        "div_mult_pos_lt1"
                                                        ("py"
                                                         "5 + 4 * m!1"
                                                         "z"
                                                         "5"
                                                         "x"
                                                         "6 / (9 + 4 * m!1)"))
                                                       (replace -1)
                                                       (lemma
                                                        "div_mult_pos_lt2"
                                                        ("py"
                                                         "9 + 4 * m!1"
                                                         "z"
                                                         "6*(5 + 4 * m!1)"
                                                         "x"
                                                         "5"))
                                                       (replace -1 1)
                                                       (assert))))
                                                    ("2"
                                                     (hide 2)
                                                     (case-replace
                                                      "(1 / 5) ^ 4 * (12 / 15) = 12/9375")
                                                     (("1"
                                                       (hide -1)
                                                       (lemma
                                                        "both_sides_div_pos_le2"
                                                        ("pz"
                                                         "609/100"
                                                         "py"
                                                         "25*26*27*28"
                                                         "px"
                                                         "((5 + 4 * m!1) * (6 + 4 * m!1) * (7 + 4 * m!1) * (8 + 4 * m!1))"))
                                                       (flatten)
                                                       (hide -1)
                                                       (split)
                                                       (("1"
                                                         (name-replace
                                                          "LHS2"
                                                          "609 / 100 /
                                                                                                                                                                                  ((5 + 4 * m!1) * (6 + 4 * m!1) * (7 + 4 * m!1) * (8 + 4 * m!1))")
                                                         (assert))
                                                        ("2"
                                                         (hide-all-but
                                                          (1 -4))
                                                         (lemma
                                                          "le_times_le_pos"
                                                          ("nnx"
                                                           "25"
                                                           "y"
                                                           "5 + 4 * m!1"
                                                           "nnz"
                                                           "26 * 27 * 28"
                                                           "w"
                                                           "(6 + 4 * m!1) * (7 + 4 * m!1) * (8 + 4 * m!1)"))
                                                         (lemma
                                                          "le_times_le_pos"
                                                          ("nnx"
                                                           "26"
                                                           "y"
                                                           "6 + 4 * m!1"
                                                           "nnz"
                                                           "27 * 28"
                                                           "w"
                                                           "(7 + 4 * m!1) * (8 + 4 * m!1)"))
                                                         (lemma
                                                          "le_times_le_pos"
                                                          ("nnx"
                                                           "27"
                                                           "y"
                                                           "7 + 4 * m!1"
                                                           "nnz"
                                                           "28"
                                                           "w"
                                                           "(8 + 4 * m!1)"))
                                                         (assert))))
                                                      ("2"
                                                       (hide-all-but 1)
                                                       (grind))))))
                                                  ("2"
                                                   (hide-all-but 1)
                                                   (grind))))))
                                              ("2"
                                               (hide -1 2)
                                               (lemma
                                                "both_sides_times_pos_lt1"
                                                ("pz"
                                                 "9 + 4 * m!1"
                                                 "x"
                                                 "(24 / 25) * (1 / (9 + 4 * m!1))"
                                                 "y"
                                                 "(1 / (9 + 4 * m!1) - (1 / 5) ^ 2 / (11 + 4 * m!1))"))
                                               (replace -1 1 rl)
                                               (hide -1)
                                               (lemma
                                                "div_cancel2"
                                                ("x"
                                                 "1"
                                                 "n0z"
                                                 "9+4*m!1"))
                                               (lemma
                                                "associative_mult"
                                                ("x"
                                                 "24 / 25"
                                                 "y"
                                                 "1 / (9 + 4 * m!1)"
                                                 "z"
                                                 "9 + 4 * m!1"))
                                               (replace -2)
                                               (replace -1 1 rl)
                                               (hide -1 -2)
                                               (lemma
                                                "both_sides_div_pos_lt2"
                                                ("pz"
                                                 "1"
                                                 "py"
                                                 "9 + 4 * m!1"
                                                 "px"
                                                 "11 + 4 * m!1"))
                                               (simplify -1)
                                               (case-replace
                                                "(1 / (9 + 4 * m!1) - (1 / 5) ^ 2 / (11 + 4 * m!1)) * (9 + 4 * m!1) = 1- (1 / 5) ^ 2*(9 + 4 * m!1)/(11 + 4 * m!1)")
                                               (("1"
                                                 (hide -1)
                                                 (case
                                                  "(1 / 5) ^ 2 * (9 + 4 * m!1) / (11 + 4 * m!1) < 1/25")
                                                 (("1" (assert))
                                                  ("2"
                                                   (hide 2)
                                                   (case-replace
                                                    "(1 / 5) ^ 2=1/25")
                                                   (("1"
                                                     (rewrite
                                                      "div_mult_pos_lt1"
                                                      1))
                                                    ("2"
                                                     (hide-all-but 1)
                                                     (grind))))))
                                                ("2"
                                                 (hide 2)
                                                 (assert))))))
                                            ("2"
                                             (hide-all-but 1)
                                             (rewrite "cross_mult")
                                             (grind))))))
                                        ("2"
                                         (hide -1 2)
                                         (lemma
                                          "div_mult_pos_lt1"
                                          ("z"
                                           "(1 / 239) ^ 2"
                                           "py"
                                           "9 + 4 * m!1"
                                           "x"
                                           "1 / (7 + 4 * m!1)"))
                                         (flatten)
                                         (hide -1)
                                         (split -1)
                                         (("1"
                                           (assert)
                                           (name-replace
                                            "DRL1"
                                            "(1 / 239) ^ 2")
                                           (assert))
                                          ("2"
                                           (hide 2)
                                           (lemma
                                            "div_mult_pos_lt2"
                                            ("py"
                                             "7 + 4 * m!1"
                                             "z"
                                             "9 + 4 * m!1"
                                             "x"
                                             "(1 / 239) ^ 2"))
                                           (replace -1 1)
                                           (hide -1)
                                           (lemma
                                            "lt_times_lt_pos1"
                                            ("px"
                                             "(1 / 239) ^ 2"
                                             "y"
                                             "1"
                                             "nnz"
                                             "7 + 4 * m!1"
                                             "w"
                                             "9 + 4 * m!1"))
                                           (lemma
                                            "both_sides_expt_pos_lt"
                                            ("px"
                                             "1/239"
                                             "py"
                                             "1"
                                             "pm"
                                             "2"))
                                           (assert)
                                           (grind))))))))
                                    ("2"
                                     (hide 2)
                                     (case
                                      "(2*TWOTHREENINE)*(1 / (3 + 4 * m!1)-(1 / 239) ^ 2*(1 / (5 + 4 * m!1))) - 8*(1 / 5) ^ 2 * FIVE * (1 / (7 + 4 * m!1))<0")
                                     (("1"
                                       (lemma
                                        "both_sides_times_pos_lt1"
                                        ("pz"
                                         "LHS"
                                         "x"
                                         "(2 * TWOTHREENINE) *
                                                                                                                              (1 / (3 + 4 * m!1) - (1 / 239) ^ 2 * (1 / (5 + 4 * m!1)))
                                                                                                                              - 8 * (1 / 5) ^ 2 * FIVE * (1 / (7 + 4 * m!1))"
                                         "y"
                                         "0"))
                                       (replace -1 -2 rl)
                                       (hide -1)
                                       (assert))
                                      ("2"
                                       (hide 2)
                                       (hide -1)
                                       (case
                                        "2 * TWOTHREENINE/(3 + 4 * m!1) < 8 * (1 / 5) ^ 2 * FIVE * (1 / (7 + 4 * m!1))")
                                       (("1"
                                         (name-replace
                                          "RHS"
                                          "8 * (1 / 5) ^ 2 * FIVE * (1 / (7 + 4 * m!1))")
                                         (lemma
                                          "both_sides_times_pos_lt1"
                                          ("y"
                                           "1/(3 + 4 * m!1)"
                                           "x"
                                           "(1 / (3 + 4 * m!1) - (1 / 239) ^ 2 * (1 / (5 + 4 * m!1)))"
                                           "pz"
                                           "2 * TWOTHREENINE"))
                                         (assert))
                                        ("2"
                                         (hide 2)
                                         (rewrite "times_div1")
                                         (lemma
                                          "div_mult_pos_lt1"
                                          ("py"
                                           "3 + 4 * m!1"
                                           "z"
                                           "2 * TWOTHREENINE"
                                           "x"
                                           "(8 * ((1 / 5) ^ 2 * FIVE))/(7 + 4 * m!1)"))
                                         (replace -1 1)
                                         (hide -1)
                                         (lemma
                                          "div_mult_pos_lt2"
                                          ("py"
                                           "7 + 4 * m!1"
                                           "z"
                                           "(8 * ((1 / 5) ^ 2 * FIVE))*(3 + 4 * m!1)"
                                           "x"
                                           "2 * TWOTHREENINE"))
                                         (replace -1)
                                         (hide -1)
                                         (expand "FIVE")
                                         (expand "TWOTHREENINE")
                                         (case
                                          "forall (m:nat): m>=5 => 14 * (1 / 239) ^ (3 + 4 * m) +
                                                                                                                                 8 * ((1 / 239) ^ (3 + 4 * m) * m)
                                                                                                                                 <
                                                                                                                                 24 * ((1 / 5) ^ 2 * (1 / 5) ^ (5 + 4 * m)) +
                                                                                                                                  32 * ((1 / 5) ^ 2 * (1 / 5) ^ (5 + 4 * m) * m)")
                                         (("1" (inst - "m!1") (assert))
                                          ("2"
                                           (hide-all-but 1)
                                           (induct "m")
                                           (("1" (assert))
                                            ("2"
                                             (skosimp)
                                             (case-replace "j!1=4")
                                             (("1" (grind))
                                              ("2"
                                               (assert)
                                               (lemma
                                                "lt_times_lt_pos1"
                                                ("px"
                                                 "14 * (1 / 239) ^ (3 + 4 * j!1) +
                                                                                                                                                      8 * ((1 / 239) ^ (3 + 4 * j!1) * j!1)"
                                                 "y"
                                                 "24 * ((1 / 5) ^ 2 * (1 / 5) ^ (5 + 4 * j!1)) +
                                                                                                                                                       32 * ((1 / 5) ^ 2 * (1 / 5) ^ (5 + 4 * j!1) * j!1)"
                                                 "nnz"
                                                 "(1 / 239) ^ 4"
                                                 "w"
                                                 "(1/5)^4"))
                                               (split -1)
                                               (("1"
                                                 (case
                                                  "8*(1 / 239) ^ (7 + 4 * j!1)<32*((1 / 5) ^ 2 * (1 / 5) ^ (9 + 4 * j!1))")
                                                 (("1"
                                                   (lemma
                                                    "expt_plus"
                                                    ("n0x"
                                                     "1/5"
                                                     "i"
                                                     "4"
                                                     "j"
                                                     "5+4*j!1"))
                                                   (replace -1)
                                                   (lemma
                                                    "expt_plus"
                                                    ("n0x"
                                                     "1/239"
                                                     "i"
                                                     "4"
                                                     "j"
                                                     "3+4*j!1"))
                                                   (replace -1)
                                                   (assert))
                                                  ("2"
                                                   (hide -1 -2 3)
                                                   (lemma
                                                    "expt_plus"
                                                    ("n0x"
                                                     "1/5"
                                                     "i"
                                                     "2"
                                                     "j"
                                                     "7+4*j!1"))
                                                   (replace -1)
                                                   (hide -1)
                                                   (case
                                                    "forall (m:nat): m>=27 => 8 * (1 / 239) ^ m <
                                                                                                                                                               32 * ((1 / 5) ^ 2 * ((1 / 5) ^ 2 * (1 / 5) ^ m))")
                                                   (("1"
                                                     (inst
                                                      -
                                                      "7 + 4 * j!1")
                                                     (assert))
                                                    ("2"
                                                     (hide-all-but 1)
                                                     (induct "m")
                                                     (("1" (grind))
                                                      ("2"
                                                       (skosimp)
                                                       (case-replace
                                                        "j!2=26")
                                                       (("1" (grind))
                                                        ("2"
                                                         (assert)
                                                         (lemma
                                                          "lt_times_lt_pos1"
                                                          ("px"
                                                           "1/239"
                                                           "y"
                                                           "1/5"
                                                           "nnz"
                                                           "8 * (1 / 239) ^ j!2"
                                                           "w"
                                                           "32 * ((1 / 5) ^ 2 * ((1 / 5) ^ 2 * (1 / 5) ^ j!2))"))
                                                         (expand "^")
                                                         (expand
                                                          "expt"
                                                          2
                                                          (1 4))
                                                         (assert))))))))))
                                                ("2" (assert))
                                                ("3"
                                                 (hide-all-but 1)
                                                 (lemma
                                                  "both_sides_expt_pos_lt"
                                                  ("px"
                                                   "1/239"
                                                   "py"
                                                   "1/5"
                                                   "pm"
                                                   "4"))
                                                 (assert))))))))))))))))
                                  ("2"
                                   (hide 2 -1)
                                   (rewrite "times_div1")
                                   (rewrite "times_div1")
                                   (rewrite "cross_mult")
                                   (grind))))
                                ("2"
                                 (hide -1 2)
                                 (rewrite "times_div1")
                                 (rewrite "times_div1")
                                 (rewrite "times_div1")
                                 (rewrite "cross_mult")
                                 (rewrite "expt_x2")
                                 (assert))))
                              ("2"
                               (hide 2)
                               (rewrite "times_div1")
                               (rewrite "times_div1")
                               (rewrite "cross_mult")
                               (expand "^" 1)
                               (expand "expt" 1 (3 4))
                               (expand "expt" 1 (3 4))
                               (assert))))))
                          ("2"
                           (hide -3 2 -2)
                           (expand "G")
                           (hide -1)
                           (lemma "expt_plus"
                            ("n0x"
                             "31415927 / 20000000"
                             "i"
                             "4"
                             "j"
                             "4 + 4 * m!1"))
                           (replace -1 1)
                           (hide -1)
                           (expand "LHS")
                           (name-replace "DRL11"
                            "(31415927 / 20000000) ^ 4")
                           (name-replace "DRL12"
                            "(31415927 / 20000000) ^ (4 + 4 * m!1)")
                           (expand "factorial" 1 1)
                           (expand "factorial" 1 (1 2))
                           (expand "factorial" 1 (1 2 3))
                           (expand "factorial" 1 (1 2 3 4))
                           (assert)
                           (name-replace "FACTORIAL"
                            "factorial(4 + 4 * m!1)")
                           (assert)
                           (rewrite "div_times")
                           (assert))))))
                      ("2"
                       (hide 2)
                       (expand "F")
                       (expand "G")
                       (grind))))))
                  ("2"
                   (hide 2)
                   (expand "G" 1)
                   (assert)
                   (lemma "both_sides_div_pos_lt1"
                    ("pz"
                     "factorial(4 + 4 * n!1)"
                     "x"
                     "(pi_lbn(n!1) / 2) ^ (4 + 4 * n!1)"
                     "y"
                     "(31415927 / 20000000) ^ (4 + 4 * n!1)"))
                   (assert))))
                ("2"
                 (hide-all-but 1)
                 (lemma "expt_times" ("n0x" "-1" "i" "2" "j" "1+n!1"))
                 (expand "^" -1 2)
                 (expand "expt")
                 (expand "expt")
                 (expand "expt")
                 (rewrite "sq_rew")
                 (rewrite "sq_neg")
                 (rewrite "expt_1i"))))
              ("2" (expand "F" 1) (expand "KK" 1) (assert))))))
          ("2" (assert))))
        ("2" (assert))))
      ("2"
       (hide -1 -2 2)
       (lemma "pi_lb_pi" ("n" "n!1"))
       (case "16 * ((1 / 5) ^ (4 * n!1 + 5) / (4 * n!1 + 5)) <= 16*(1/5)^25/25")
       (("1"
         (case "4 * ((1 / 239) ^ (4 * n!1 + 3) / (4 * n!1 + 3)) <= 4*(1/239)^23/23")
         (("1"
           (case "16 * (1 / 5) ^ 25 / 25< 1/1000000")
           (("1"
             (case "4 * (1 / 239) ^ 23 / 23< 1 / 1000000")
             (("1" (assert)) ("2" (hide-all-but 1) (grind))))
            ("2" (hide-all-but 1) (grind))))
          ("2"
           (hide-all-but (-6 1))
           (lemma "both_sides_expt_lt1_le"
            ("lt1x" "1/239" "j" "23" "i" "4*n!1+3"))
           (assert)
           (lemma "both_sides_div_pos_le2"
            ("pz" "4" "px" "3+4*n!1" "py" "23"))
           (assert)
           (lemma "le_times_le_pos"
            ("nnx"
             "4 / (3 + 4 * n!1)"
             "y"
             "4 / 23"
             "nnz"
             "(1 / 239) ^ (3 + 4 * n!1)"
             "w"
             "(1 / 239) ^ 23"))
           (assert))))
        ("2"
         (hide-all-but (-5 1))
         (lemma "both_sides_div_pos_le2"
          ("pz" "16" "px" "5+4*n!1" "py" "25"))
         (assert)
         (lemma "both_sides_expt_lt1_le"
          ("lt1x" "1/5" "j" "25" "i" "4*n!1+5"))
         (lemma "le_times_le_pos"
          ("nnx"
           "16 / (5 + 4 * n!1)"
           "y"
           "16 / 25"
           "nnz"
           "(1 / 5) ^ (4 * n!1 + 5)"
           "w"
           "(1 / 5) ^ 25"))
         (assert))))))
    ("2"
     (hide -1 2)
     (lemma "both_sides_div_pos_lt1"
      ("pz" "2" "y" "pi-pi_lbn(n!1)" "x" "KK"))
     (expand ">" 1)
     (replace -1 1)
     (assert))))


