# Proofs

proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergent_subset" ("X" "X!1" "Y" "union(X!1,Y!1)" "g" "f!1"))
   (split)
   (("1" (propax)) ("2" (hide 2) (grind))
    ("3" (typepred "f!1") (propax))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergent_subset" ("X" "Y!1" "Y" "union(X!1,Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergent_subset"
    ("X" "intersection(X!1,Y!1)" "Y" "union(X!1,Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergent_subset"
    ("X" "difference(X!1,Y!1)" "Y" "union(X!1,Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (lemma "convergent_subset"
    ("X" "difference(Y!1,X!1)" "Y" "union(X!1,Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergent_subset" ("X" "X!1" "Y" "Y!1" "g" "f!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergent_subset"
    ("X" "difference(Y!1,X!1)" "Y" "Y!1" "g" "f!1"))
   (typepred "f!1")
   (rewrite "difference_subset")
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergent_add" ("X" "X!1" "t" "t!1" "g" "f!1"))
   (typepred "f!1")
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergent_subset" ("X" "rest(X!1)" "Y" "X!1" "g" "f!1"))
   (rewrite "rest_subset")
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergent_scal" ("a" "a!1" "f" "f!1" "X" "X!1"))
   (typepred "f!1")
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (typepred "g!1")
   (lemma "convergent_diff" ("X" "X!1" "f" "f!1" "g" "g!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "phi!1")
   (typepred "f!1")
   (expand "convergent?")
   (flatten)
   (assert)
   (expand "absconvergent?")
   (typepred "phi!1")
   (lemma "denumerable_enumeration_bij" ("X" "X!1"))
   (lemma "denumerable_enumeration_image" ("X" "X!1"))
   (name-replace "PHI" "denumerable_enumeration(X!1)")
   (expand "extend")
   (expand "o")
   (lemma "bij_inv_is_bij[nat, (X!1)]" ("f" "PHI"))
   (hide -4)
   (assert)
   (case "nonempty?(X!1)")
   (("1"
     (lemma "bij_inv_is_bij[(X!1), (X!1)]" ("f" "phi!1"))
     (("1"
       (split -1)
       (("1"
         (lemma "abs_series_bij_conv"
          ("a"
           "abs(LAMBDA (x: nat): f!1(PHI(x)))"
           "phi"
           "lambda n: inverse(PHI)(phi!1(PHI(n)))"))
         (("1"
           (assert)
           (split -1)
           (("1"
             (expand "o")
             (expand "abs" -1)
             (expand "abs" 2)
             (case-replace
              "(LAMBDA (x_1: nat):
                                        abs(f!1(PHI(inverse(PHI)(phi!1(PHI(x_1)))))))=(LAMBDA (n: nat): abs(f!1(phi!1(PHI(n)))))")
             (hide-all-but (-2 -3 -4 -5 -6 -8 1))
             (apply-extensionality :hide? t)
             (("1"
               (lemma "comp_inverse_right[nat, (X!1)]"
                ("f" "PHI" "y" "phi!1(PHI(x!1))"))
               (replace -1)
               (propax))
              ("2"
               (skosimp)
               (assert)
               (lemma "comp_inverse_right[nat, (X!1)]"
                ("f" "PHI" "y" "phi!1(PHI(n!1))"))
               (replace -1)
               (name-replace "DRL1" "f!1(phi!1(PHI(n!1)))")
               (hide-all-but 1)
               (grind))))
            ("2"
             (hide-all-but (1 -6))
             (expand "convergent?")
             (skosimp)
             (inst + "l!1")
             (expand "convergence")
             (skosimp)
             (inst - "epsilon!1")
             (skosimp)
             (inst + "n!1")
             (skosimp)
             (inst - "i!1")
             (assert)
             (expand "abs" 1 2)
             (expand "abs" -2 2)
             (expand "series")
             (case-replace
              "(LAMBDA (n: nat): abs(abs(LAMBDA (x: nat): f!1(PHI(x)))(n)))=(LAMBDA (n: nat): abs(f!1(PHI(n))))")
             (hide-all-but 1)
             (apply-extensionality :hide? t)
             (("1" (expand "abs") (expand "abs") (propax))
              ("2"
               (skosimp)
               (expand "abs")
               (expand "abs")
               (case-replace "f!1(PHI(n!2)) < 0")
               (("1" (assert)) ("2" (assert))))))))
          ("2"
           (lemma "composition_bijective[nat,(X!1),(X!1)]"
            ("f1" "PHI" "f2" "phi!1"))
           (lemma "composition_bijective[nat,(X!1),nat]"
            ("f1" "phi!1 o PHI" "f2" "inverse[nat, (X!1)](PHI)"))
           (("1" (expand "o") (propax)) ("2" (propax))))))
        ("2" (propax))))
      ("2"
       (hide-all-but (-1 1))
       (expand "nonempty?")
       (expand "empty?")
       (skosimp)
       (inst + "x!1")
       (assert)
       (expand "member")
       (propax))))
    ("2"
     (expand "nonempty?")
     (rewrite "emptyset_is_empty?")
     (replace -1)
     (assert))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (split)
   (("1"
     (expand "nonempty?")
     (expand "empty?")
     (inst - "0")
     (expand "member")
     (inst + "emptyset[T]")
     (split)
     (("1"
       (expand "emptyset")
       (expand "subset?")
       (expand "member")
       (propax))
      ("2" (rewrite "sigma_empty"))))
    ("2"
     (expand "above_bounded")
     (typepred "f!1")
     (inst + "sigma(X!1,f!1)")
     (expand "upper_bound")
     (skosimp)
     (typepred "z!1")
     (skosimp)
     (case "union(F!1, difference(X!1, F!1))=X!1")
     (("1"
       (lemma "sigma_disjoint_union"
        ("f" "f!1" "X" "F!1" "Y" "difference(X!1,F!1)"))
       (("1"
         (replace -2)
         (split -1)
         (("1"
           (lemma "sigma_ge_0" ("f" "f!1" "X" "difference(X!1, F!1)"))
           (split -1)
           (("1" (assert))
            ("2"
             (skosimp)
             (typepred "t!1")
             (expand "difference")
             (expand "member")
             (flatten)
             (inst -8 "t!1")
             (assert))))
          ("2"
           (hide-all-but (-3 1))
           (expand "difference")
           (expand "disjoint?")
           (expand "intersection")
           (expand "subset?")
           (expand "empty?")
           (expand "member")
           (skosimp))))
        ("2" (replace -1) (propax))))
      ("2"
       (hide-all-but (-2 1))
       (apply-extensionality :hide? t)
       (expand "subset?")
       (expand "difference")
       (expand "union")
       (expand "member")
       (inst - "x!1")
       (case-replace "F!1(x!1)")
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (split)
   (("1"
     (expand "nonempty?")
     (expand "empty?")
     (inst - "sigma(emptyset[T],f!1)")
     (("1"
       (expand "member")
       (inst + "emptyset[T]")
       (split)
       (("1"
         (expand "emptyset")
         (expand "subset?")
         (skosimp)
         (expand "member")
         (propax))
        ("2" (expand "emptyset") (propax))))
      ("2" (rewrite "sigma_empty") (assert))
      ("3" (expand "convergent?") (propax))))
    ("2"
     (name "XX" "{t | X!1(t) & f!1(t)>=0}")
     (case "subset?(XX,X!1)")
     (("1"
       (lemma "sigma_subset" ("X" "XX" "Y" "X!1" "f" "f!1"))
       (("1"
         (replace -2)
         (lemma "sigma_opp" ("f" "f!1" "X" "difference(X!1, XX)"))
         (lemma "sigma_ge_0" ("X" "difference(X!1, XX)" "f" "-f!1"))
         (split -1)
         (("1"
           (lemma "sigma_ge_0" ("X" "XX" "f" "f!1"))
           (split -1)
           (("1"
             (expand "above_bounded")
             (inst + "sigma(XX, f!1)")
             (expand "upper_bound")
             (skosimp)
             (typepred "z!1")
             (skosimp)
             (lemma "sigma_subset" ("f" "f!1" "X" "F!1" "Y" "XX"))
             (split -1)
             (("1"
               (assert)
               (lemma "sigma_ge_0" ("f" "f!1" "X" "difference(XX, F!1)"))
               (split)
               (("1" (assert))
                ("2"
                 (skosimp)
                 (typepred "t!1")
                 (expand "difference")
                 (expand "XX")
                 (expand "member")
                 (flatten))))
              ("2"
               (hide 2)
               (expand "subset?")
               (skosimp)
               (expand "member")
               (expand "XX")
               (inst - "x!1")
               (assert)
               (assert)
               (inst - "x!1")
               (assert))))
            ("2" (skosimp) (typepred "t!1") (expand "XX") (flatten))))
          ("2"
           (hide-all-but (1 -3))
           (skosimp)
           (expand "subset?")
           (inst - "t!1")
           (expand "XX")
           (typepred "t!1")
           (expand "difference")
           (expand "member")
           (flatten)
           (assert)
           (expand "XX")
           (expand "-")
           (assert))))
        ("2"
         (typepred "X!1")
         (lemma "countable_subset[T]")
         (inst - "XX" "X!1")
         (assert))))
      ("2"
       (expand "subset?")
       (skosimp)
       (expand "member")
       (expand "XX")
       (flatten))))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (expand "nonempty?")
     (expand "empty?")
     (inst - "0")
     (expand "member")
     (inst + "emptyset[T]")
     (rewrite "sigma_empty")
     (grind))
    ("2"
     (expand "above_bounded")
     (lemma "countable_subset"
      ("S" "{t | X!1(t) & f!1(t) >= 0}" "Count" "X!1"))
     (case-replace "subset?({t | X!1(t) & f!1(t) >= 0}, X!1)")
     (("1"
       (lemma "convergent_subset"
        ("g" "f!1" "X" "{t | X!1(t) & f!1(t)>=0}" "Y" "X!1"))
       (("1"
         (assert)
         (inst + "sigma({t | X!1(t) & f!1(t)>=0},f!1)")
         (expand "upper_bound")
         (skosimp)
         (typepred "z!1")
         (skosimp)
         (lemma "sigma_subset"
          ("X" "F!1" "Y" "{t | X!1(t) & f!1(t) >= 0}" "f" "f!1"))
         (case-replace "subset?(F!1, {t | X!1(t) & f!1(t) >= 0})")
         (("1"
           (lemma "sigma_ge_0"
            ("X"
             "difference({t | X!1(t) & f!1(t) >= 0}, F!1)"
             "f"
             "f!1"))
           (split -1)
           (("1" (assert))
            ("2"
             (skosimp)
             (typepred "t!1")
             (expand "difference")
             (expand "member")
             (flatten))))
          ("2"
           (hide-all-but (1 -3 -4))
           (expand "subset?")
           (expand "member")
           (skosimp)
           (inst - "x!1")
           (inst - "x!1")
           (assert)
           (assert))))
        ("2" (propax))))
      ("2" (hide-all-but 1) (grind))))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_countable
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (expand "nonempty?")
     (expand "empty?")
     (inst - "0")
     (expand "member")
     (inst + "emptyset[T]")
     (split)
     (("1"
       (expand "emptyset")
       (expand "subset?")
       (skosimp)
       (expand "member")
       (propax))
      ("2" (expand "emptyset") (propax)) ("3" (rewrite "sigma_empty"))))
    ("2"
     (typepred "f!1")
     (name "XX" "{t | X!1(t) & f!1(t) <= 0}")
     (case "subset?(XX,X!1)")
     (("1"
       (lemma "sigma_subset" ("X" "XX" "Y" "X!1" "f" "f!1"))
       (("1"
         (assert)
         (lemma "sigma_opp" ("f" "f!1" "X" "XX"))
         (lemma "sigma_ge_0" ("f" "f!1" "X" "difference(X!1, XX)"))
         (split -1)
         (("1"
           (lemma "sigma_ge_0" ("f" "-f!1" "X" "XX"))
           (split)
           (("1"
             (expand "below_bounded")
             (inst + "sigma(XX, f!1)")
             (expand "lower_bound")
             (skosimp)
             (typepred "z!1")
             (skosimp)
             (lemma "sigma_subset" ("X" "F!1" "Y" "XX" "f" "f!1"))
             (split -1)
             (("1"
               (assert)
               (lemma "sigma_opp" ("f" "f!1" "X" "difference(XX, F!1)"))
               (replace -6 * rl)
               (lemma "sigma_ge_0"
                ("f" "-f!1" "X" "difference(XX, F!1)"))
               (split)
               (("1" (assert))
                ("2"
                 (skosimp)
                 (typepred "t!1")
                 (expand "difference")
                 (expand "member")
                 (expand "-")
                 (flatten)
                 (expand "XX")
                 (flatten)
                 (assert))))
              ("2"
               (hide-all-but (-2 1 -3))
               (expand "subset?")
               (expand "member")
               (skosimp)
               (inst - "x!1")
               (inst - "x!1")
               (expand "XX")
               (assert)
               (assert))))
            ("2"
             (skosimp)
             (typepred "t!1")
             (expand "XX")
             (expand "-")
             (flatten)
             (assert))))
          ("2"
           (hide 2)
           (skosimp)
           (typepred "t!1")
           (expand "difference")
           (expand "member")
           (flatten)
           (expand "XX")
           (assert))))
        ("2"
         (hide-all-but (-1 1))
         (lemma "countable_subset" ("Count" "X!1" "S" "XX"))
         (assert))))
      ("2"
       (hide-all-but 1)
       (expand "subset?")
       (expand "member")
       (expand "XX")
       (skosimp))))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma" 1 1)
   (lemma "sigma_disjoint_union"
    ("f"
     "f!1"
     "X"
     "nonzero_elts(f!1, C!1)"
     "Y"
     "difference(C!1,nonzero_elts(f!1, C!1))"))
   (("1"
     (case-replace
      "union(nonzero_elts(f!1, C!1),
                         difference(C!1, nonzero_elts(f!1, C!1)))=C!1")
     (("1"
       (hide -1)
       (split)
       (("1"
         (case-replace
          "sigma_countable.sigma(difference(C!1, nonzero_elts(f!1, C!1)), f!1)=0")
         (("1" (assert))
          ("2"
           (hide -1 2)
           (lemma "sigma_eq"
            ("f"
             "f!1"
             "g"
             "lambda t:0"
             "X"
             "difference(C!1, nonzero_elts(f!1, C!1))"))
           (("1"
             (split -1)
             (("1" (replace -1) (rewrite "sigma_zero"))
              ("2"
               (hide 2)
               (skosimp)
               (typepred "t!1")
               (expand "nonzero_elts")
               (expand "difference")
               (expand "member")
               (flatten)
               (assert))))
            ("2"
             (hide 2)
             (rewrite "countable_convergence.convergent_zero"))))))
        ("2"
         (hide 2)
         (expand "disjoint?")
         (expand "difference")
         (expand "intersection")
         (expand "empty?")
         (expand "member")
         (skosimp))))
      ("2"
       (hide-all-but 1)
       (apply-extensionality :hide? t)
       (expand "difference")
       (expand "union")
       (expand "member")
       (grind))))
    ("2"
     (hide 2)
     (case-replace
      "(union[T]
                     (nonzero_elts[T](f!1, C!1),
                      difference[T](C!1, nonzero_elts[T](f!1, C!1))))=C!1")
     (("1" (assert))
      ("2" (hide 2) (apply-extensionality :hide? t) (grind))))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace "nonzero_elts(g!1, emptyset[T])=emptyset[T]")
   (("1" (rewrite "sigma_empty"))
    ("2" (hide 2) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (rewrite "sigma_countable")
   (("1" (rewrite "sigma_singleton"))
    ("2" (rewrite "countable_convergence.convergent_singleton"))
    ("3" (rewrite "countable_singleton"))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace
    "nonzero_elts(f!1, union(X!1, Y!1))=union(nonzero_elts(f!1, X!1),nonzero_elts(f!1, Y!1))")
   (("1"
     (lemma "sigma_disjoint_union"
      ("X"
       "nonzero_elts(f!1, X!1)"
       "Y"
       "nonzero_elts(f!1, Y!1)"
       "f"
       "f!1"))
     (assert)
     (hide 2 -1)
     (expand "disjoint?")
     (expand "intersection")
     (expand "empty?")
     (expand "member")
     (skosimp)
     (expand "nonzero_elts")
     (flatten)
     (inst - "x!1")
     (assert))
    ("2"
     (hide 2)
     (apply-extensionality :hide? t)
     (expand "nonzero_elts")
     (expand "union")
     (expand "member")
     (expand "disjoint?")
     (expand "empty?")
     (inst - "x!1")
     (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace
    "nonzero_elts(f!1, intersection(X!1, Y!1))=intersection(nonzero_elts(f!1, X!1),nonzero_elts(f!1, Y!1))")
   (("1"
     (case-replace
      "nonzero_elts(f!1, union(X!1, Y!1))=union(nonzero_elts(f!1, X!1),nonzero_elts(f!1, Y!1))")
     (("1"
       (lemma "sigma_union"
        ("f"
         "f!1"
         "X"
         "nonzero_elts(f!1, X!1)"
         "Y"
         "nonzero_elts(f!1, Y!1)"))
       (propax))
      ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))
    ("2" (hide 2) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace
    "nonzero_elts(f!1, difference(X!1, Y!1))=difference(nonzero_elts(f!1, X!1), nonzero_elts(f!1,Y!1))")
   (("1"
     (case-replace
      "nonzero_elts(f!1, difference(Y!1, X!1))=difference(nonzero_elts(f!1, Y!1), nonzero_elts(f!1,X!1))")
     (("1"
       (lemma "sigma_difference"
        ("X"
         "nonzero_elts(f!1, X!1)"
         "Y"
         "nonzero_elts(f!1, Y!1)"
         "f"
         "f!1"))
       (("1" (assert))
        ("2"
         (hide 2)
         (case-replace
          "union[T](nonzero_elts[T](f!1, X!1), nonzero_elts[T](f!1, Y!1))=nonzero_elts[T](f!1, union(X!1,Y!1))")
         (("1"
           (assert)
           (typepred "f!1")
           (expand "convergent?" -1)
           (propax))
          ("2"
           (hide-all-but 1)
           (apply-extensionality :hide? t)
           (grind))))))
      ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))
    ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "difference_subset2" ("b" "Y!1" "a" "X!1"))
   (assert)
   (lemma "sigma_difference" ("X" "X!1" "Y" "Y!1" "f" "f!1"))
   (("1" (replace -2) (rewrite "sigma_empty") (assert))
    ("2"
     (case-replace "union[T](X!1, Y!1)=Y!1")
     (("1" (assert))
      ("2"
       (hide-all-but (1 -2))
       (apply-extensionality :hide? t)
       (expand "union")
       (expand "subset?")
       (expand "member")
       (inst - "x!1")
       (grind))))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "member")
   (case-replace "X!1(t!1)")
   (("1"
     (case-replace "add(t!1, X!1)=X!1")
     (hide 2)
     (apply-extensionality :hide? t)
     (grind))
    ("2"
     (assert)
     (rewrite "add_as_union")
     (lemma "sigma_union" ("f" "f!1" "X" "X!1" "Y" "singleton(t!1)"))
     (rewrite "sigma_singleton")
     (case-replace "intersection(X!1, singleton(t!1))=emptyset[T]")
     (("1" (rewrite "sigma_empty") (assert))
      ("2"
       (hide-all-but (1 2))
       (apply-extensionality :hide? t)
       (grind))))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "member")
   (case-replace "X!1(t!1)")
   (("1"
     (lemma "add_remove_member" ("x" "t!1" "a" "X!1"))
     (expand "member")
     (assert)
     (lemma "sigma_add" ("t" "t!1" "X" "remove(t!1, X!1)" "f" "f!1"))
     (replace -2)
     (expand "remove" -1 1)
     (expand "member")
     (assert))
    ("2"
     (assert)
     (lemma "member_remove" ("x" "t!1" "a" "X!1"))
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "choose_rest" ("a" "X!1"))
   (typepred "X!1")
   (expand "nonempty?")
   (assert)
   (lemma "sigma_add" ("f" "f!1" "t" "choose(X!1)" "X" "rest(X!1)"))
   (lemma "choose_not_member" ("a" "X!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace "nonzero_elts(LAMBDA t: 0, X!1)=emptyset[T]")
   (("1" (rewrite "sigma_countable.sigma_empty"))
    ("2" (hide 2) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace "a!1=0")
   (("1"
     (case-replace "nonzero_elts(0 * f!1, X!1)=emptyset[T]")
     (("1"
       (lemma "sigma_countable.sigma_empty" ("g" "0*f!1"))
       (replace -1)
       (assert))
      ("2" (hide 2) (apply-extensionality :hide? t) (grind))))
    ("2"
     (case-replace "nonzero_elts(a!1 * f!1, X!1)=nonzero_elts(f!1, X!1)")
     (("1"
       (hide -1)
       (lemma "sigma_scal"
        ("a" "a!1" "f" "f!1" "X" "nonzero_elts(f!1, X!1)"))
       (propax))
      ("2"
       (hide 3)
       (apply-extensionality :hide? t)
       (expand "nonzero_elts")
       (expand "*")
       (case-replace "X!1(x!1)")
       (("1" (case-replace "f!1(x!1)=0") (("1" (assert)) ("2" (assert))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "sigma_scal" ("f" "f!1" "X" "X!1" "a" "-1"))
   (case-replace "-1 * f!1=-f!1")
   (("1" (assert))
    ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (lemma "sigma_countable.sigma_plus"
    ("X"
     "union(nonzero_elts(f!1, X!1),nonzero_elts(g!1, X!1))"
     "f"
     "f!1"
     "g"
     "g!1"))
   (("1"
     (lemma "sigma_countable.sigma_subset"
      ("X"
       "nonzero_elts(f!1, X!1)"
       "Y"
       "union(nonzero_elts(f!1, X!1), nonzero_elts(g!1, X!1))"
       "f"
       "f!1"))
     (split -1)
     (("1"
       (case-replace
        "sigma_countable.sigma(difference(union(nonzero_elts(f!1, X!1),
                                       nonzero_elts(g!1, X!1)),
                                 nonzero_elts(f!1, X!1)),
                      f!1)=0")
       (("1"
         (replace -2)
         (hide -1 -2)
         (lemma "sigma_countable.sigma_subset"
          ("X"
           "nonzero_elts(g!1, X!1)"
           "Y"
           "union(nonzero_elts(f!1, X!1), nonzero_elts(g!1, X!1))"
           "f"
           "g!1"))
         (split -1)
         (("1"
           (case-replace
            "sigma_countable.sigma(difference(union(nonzero_elts(f!1, X!1),
                                           nonzero_elts(g!1, X!1)),
                                     nonzero_elts(g!1, X!1)),
                          g!1)=0")
           (("1"
             (replace -2)
             (hide -1 -2)
             (lemma "sigma_countable.sigma_subset"
              ("X"
               "nonzero_elts(f!1 + g!1, X!1)"
               "Y"
               "union(nonzero_elts(f!1, X!1), nonzero_elts(g!1, X!1))"
               "f"
               "f!1+g!1"))
             (split -1)
             (("1"
               (case-replace
                "sigma_countable.sigma(difference(union(nonzero_elts(f!1, X!1),
                                               nonzero_elts(g!1, X!1)),
                                         nonzero_elts(f!1 + g!1, X!1)),
                              f!1 + g!1)=0")
               (("1" (assert))
                ("2"
                 (hide-all-but 1)
                 (lemma "sigma_eq"
                  ("X"
                   "difference(union(nonzero_elts(f!1, X!1),
                                               nonzero_elts(g!1, X!1)),
                                         nonzero_elts(f!1 + g!1, X!1))"
                   "f"
                   "f!1+g!1"
                   "g"
                   "lambda t:0"))
                 (("1"
                   (rewrite "sigma_countable.sigma_zero")
                   (assert)
                   (hide 2)
                   (skosimp)
                   (typepred "t!1")
                   (expand "+ ")
                   (expand "difference")
                   (expand "union")
                   (expand "nonzero_elts")
                   (expand "member")
                   (flatten)
                   (case-replace "X!1(t!1)")
                   (("1" (assert)) ("2" (assert))))
                  ("2"
                   (hide 2)
                   (rewrite "countable_convergence.convergent_zero"))))))
              ("2" (hide-all-but 1) (grind))))
            ("2"
             (hide-all-but 1)
             (case-replace
              "difference(union(nonzero_elts(f!1, X!1),
                                          nonzero_elts(g!1, X!1)),
                                    nonzero_elts(g!1, X!1))=difference(nonzero_elts(f!1, X!1),
                                          nonzero_elts(g!1, X!1))")
             (("1"
               (lemma "sigma_eq"
                ("X"
                 "difference(nonzero_elts(f!1, X!1), nonzero_elts(g!1, X!1))"
                 "f"
                 "g!1"
                 "g"
                 "lambda t:0"))
               (("1"
                 (rewrite "sigma_countable.sigma_zero")
                 (assert)
                 (hide-all-but 1)
                 (skosimp)
                 (typepred "t!1")
                 (expand "difference")
                 (expand "member")
                 (expand "nonzero_elts")
                 (flatten)
                 (assert))
                ("2"
                 (hide-all-but 1)
                 (rewrite "countable_convergence.convergent_zero"))))
              ("2" (hide 2) (apply-extensionality :hide? t) (grind))))))
          ("2" (hide-all-but 1) (grind))))
        ("2"
         (hide-all-but 1)
         (case-replace
          "difference(union(nonzero_elts(f!1, X!1),
                                      nonzero_elts(g!1, X!1)),
                                nonzero_elts(f!1, X!1))=difference(nonzero_elts(g!1, X!1),nonzero_elts(f!1, X!1))")
         (("1"
           (hide -1)
           (lemma "sigma_eq"
            ("f"
             "f!1"
             "g"
             "lambda t:0"
             "X"
             "difference(nonzero_elts(g!1, X!1), nonzero_elts(f!1, X!1))"))
           (("1"
             (rewrite "sigma_countable.sigma_zero" -1)
             (assert)
             (hide 2)
             (skosimp)
             (typepred "t!1")
             (expand "nonzero_elts")
             (expand "difference")
             (expand "member")
             (flatten)
             (assert))
            ("2"
             (hide 2)
             (rewrite "countable_convergence.convergent_zero"))))
          ("2" (hide 2) (apply-extensionality :hide? t) (grind))))))
      ("2" (hide-all-but 1) (grind))))
    ("2"
     (hide 2)
     (case-replace
      "union[T](nonzero_elts[T](f!1, X!1), nonzero_elts[T](g!1, X!1))=union[T](nonzero_elts[T](g!1, X!1), difference(nonzero_elts[T](f!1, X!1), nonzero_elts[T](g!1, X!1)))")
     (("1"
       (hide -1)
       (lemma "countable_convergence.convergent_union"
        ("X"
         "nonzero_elts[T](g!1, X!1)"
         "Y"
         "difference(nonzero_elts[T](f!1, X!1),
                                    nonzero_elts[T](g!1, X!1))"
         "g"
         "g!1"))
       (("1"
         (assert)
         (hide 2)
         (split)
         (("1" (typepred "g!1") (expand "convergent?" -1) (flatten))
          ("2"
           (lemma "convergent_zeros"
            ("X"
             "difference(nonzero_elts[T](f!1, X!1),
                                          nonzero_elts[T](g!1, X!1))"
             "g"
             "g!1"))
           (split -1)
           (("1" (propax))
            ("2"
             (hide 2)
             (skosimp)
             (typepred "t!1")
             (expand "difference")
             (expand "member")
             (expand "nonzero_elts")
             (flatten)
             (assert))))))
        ("2"
         (rewrite "countable_difference")
         (typepred "f!1")
         (expand "convergent?")
         (propax))
        ("3" (typepred "g!1") (expand "convergent?") (flatten))))
      ("2" (hide 2) (apply-extensionality :hide? t) (grind))))
    ("3"
     (hide 2)
     (case-replace
      "union[T](nonzero_elts[T](f!1, X!1), nonzero_elts[T](g!1, X!1))=union[T](nonzero_elts[T](f!1, X!1), difference(nonzero_elts[T](g!1, X!1), nonzero_elts[T](f!1, X!1)))")
     (("1"
       (hide -1)
       (lemma "countable_convergence.convergent_union"
        ("X"
         "nonzero_elts[T](f!1, X!1)"
         "Y"
         "difference(nonzero_elts[T](g!1, X!1),
                                    nonzero_elts[T](f!1, X!1))"
         "g"
         "f!1"))
       (("1"
         (split)
         (("1" (propax))
          ("2"
           (hide 2)
           (typepred "f!1")
           (expand "convergent?" -1)
           (flatten))
          ("3"
           (hide 2)
           (lemma "convergent_zeros"
            ("X"
             "difference(nonzero_elts[T](g!1, X!1),
                                          nonzero_elts[T](f!1, X!1))"
             "g"
             "f!1"))
           (split -1)
           (("1" (propax))
            ("2"
             (hide 2)
             (skosimp)
             (typepred "t!1")
             (expand "difference")
             (expand "nonzero_elts")
             (expand "member")
             (flatten)
             (assert))))))
        ("2"
         (typepred "f!1")
         (typepred "g!1")
         (expand "convergent?")
         (flatten)
         (hide -2 -4 2 3)
         (rewrite "countable_difference"))
        ("3" (typepred "f!1") (expand "convergent?") (flatten))))
      ("2" (hide 2) (apply-extensionality :hide? t) (grind))))
    ("4"
     (hide 2)
     (typepred "f!1")
     (typepred "g!1")
     (expand "convergent?")
     (flatten)
     (rewrite "countable_union"))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "sigma_opp" ("f" "g!1" "X" "X!1"))
   (lemma "sigma_plus" ("f" "f!1" "g" "-g!1" "X" "X!1"))
   (case-replace "f!1 + -g!1=f!1-g!1")
   (("1" (assert))
    ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (lemma "sigma_ge_0" ("f" "f!1" "X" "nonzero_elts(f!1, X!1)"))
   (split -1)
   (("1" (propax))
    ("2"
     (hide 2)
     (skosimp)
     (typepred "t!1")
     (expand "nonzero_elts")
     (flatten)
     (inst - "t!1"))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (lemma "sigma_gt_0" ("X" "nonzero_elts(f!1, X!1)" "f" "f!1"))
   (("1"
     (split -1)
     (("1" (propax))
      ("2"
       (hide 2)
       (skosimp)
       (typepred "t!1")
       (expand "nonzero_elts")
       (flatten)
       (inst - "t!1")
       (assert))))
    ("2"
     (typepred "f!1")
     (expand "convergent?")
     (flatten)
     (hide -2 2)
     (expand "nonempty_countable?")
     (assert)
     (hide -1)
     (expand "nonempty?")
     (expand "empty?")
     (expand "nonzero_elts")
     (expand "member")
     (skosimp)
     (inst - "t!1")
     (typepred "t!1")
     (inst - "t!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace "nonzero_elts(abs(f!1), X!1)=nonzero_elts(f!1, X!1)")
   (("1"
     (lemma "sigma_abs" ("X" "nonzero_elts(f!1, X!1)" "f" "f!1"))
     (propax))
    ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "sigma")
   (case-replace "nonzero_elts(g!1, X!1)=nonzero_elts(f!1, X!1)")
   (("1"
     (lemma "sigma_eq"
      ("f" "f!1" "g" "g!1" "X" "nonzero_elts(f!1, X!1)"))
     (assert)
     (skosimp)
     (typepred "t!1")
     (hide -2 2)
     (expand "nonzero_elts")
     (flatten)
     (inst - "t!1"))
    ("2"
     (hide 2)
     (expand "nonzero_elts")
     (apply-extensionality :hide? t)
     (case-replace "X!1(x!1)")
     (("1" (inst - "x!1") (assert) (grind)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "sigma_ge_0" ("X" "X!1" "f" "g!1-f!1"))
   (("1"
     (split)
     (("1" (lemma "sigma_diff" ("X" "X!1" "f" "g!1" "g" "f!1")) (assert))
      ("2" (hide 2) (skosimp) (inst - "t!1") (expand "-") (assert))))
    ("2"
     (hide 2)
     (typepred "f!1")
     (typepred "g!1")
     (lemma "convergence_set.convergent_diff"
      ("X" "X!1" "f" "g!1" "g" "f!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (skosimp)
   (lemma "sigma_gt_0" ("X" "X!1" "f" "g!1-f!1"))
   (("1"
     (split)
     (("1" (lemma "sigma_diff" ("X" "X!1" "f" "g!1" "g" "f!1")) (assert))
      ("2" (skosimp) (expand "-") (inst - "t!2") (assert))
      ("3" (inst + "t!1") (expand "-") (assert))))
    ("2"
     (lemma "convergence_set.convergent_diff"
      ("X" "X!1" "f" "g!1" "g" "f!1"))
     (assert))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (expand "convergent?" 1)
   (case "subset?(nonzero_elts(f!1, C!1),C!1)")
   (("1"
     (lemma "countable_subset[T]"
      ("S" "nonzero_elts(f!1, C!1)" "Count" "C!1"))
     (assert)
     (lemma "countable_convergence.convergent_subset"
      ("X" "nonzero_elts(f!1, C!1)" "Y" "C!1" "g" "f!1"))
     (assert))
    ("2" (hide-all-but 1) (grind))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "convergent?")
   (case "subset?(nonzero_elts(g!1, F!1),F!1)")
   (("1"
     (lemma "finite_subset[T]" ("s" "nonzero_elts(g!1, F!1)" "A" "F!1"))
     (assert)
     (lemma "finite_countable[T]" ("x" "nonzero_elts(g!1, F!1)"))
     (assert)
     (expand "convergent?")
     (propax))
    ("2"
     (hide-all-but 1)
     (expand "subset?")
     (expand "nonzero_elts")
     (expand "member")
     (skosimp))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "convergent?")
   (case "g!1(t!1)=0")
   (("1"
     (case-replace "nonzero_elts(g!1, singleton[T](t!1))=emptyset[T]")
     (("1" (rewrite "countable_emptyset") (rewrite "convergent_empty"))
      ("2"
       (hide 2)
       (apply-extensionality :hide? t)
       (expand "emptyset")
       (expand "nonzero_elts")
       (expand "singleton")
       (flatten)
       (assert))))
    ("2"
     (case-replace
      "nonzero_elts(g!1, singleton[T](t!1))=singleton[T](t!1)")
     (("1"
       (lemma "convergent_singleton" ("t" "t!1" "g" "g!1"))
       (rewrite "countable_singleton"))
      ("2"
       (hide 3)
       (expand "singleton")
       (expand "nonzero_elts")
       (apply-extensionality :hide? t)
       (case-replace "x!1=t!1")
       (("1" (assert)) ("2" (assert))))))))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("X" "X!1" "Y" "union(X!1, Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("X" "Y!1" "Y" "union(X!1, Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergence_set.convergent_subset"
    ("X" "X!1" "Y" "union(X!1, Y!1)" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("Y" "union(X!1,Y!1)" "X" "intersection(X!1, Y!1)" "g" "f!1"))
   (assert)
   (hide 2)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("Y" "union(X!1,Y!1)" "X" "difference(X!1, Y!1)" "g" "f!1"))
   (assert)
   (hide 2)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("Y" "union(X!1,Y!1)" "X" "difference(Y!1, X!1)" "g" "f!1"))
   (assert)
   (hide 2)
   (grind))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("Y" "Y!1" "X" "X!1" "g" "f!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_subset"
    ("Y" "Y!1" "X" "difference(Y!1,X!1)" "g" "f!1"))
   (assert)
   (hide 2)
   (expand "difference")
   (expand "subset?")
   (expand "member")
   (skosimp))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_add"
    ("X" "X!1" "t" "t!1" "g" "f!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "convergence_set.convergent_remove"
    ("X" "X!1" "t" "t!1" "g" "f!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: sigma_set
theory: sigma_set
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "f!1")
   (lemma "convergence_set.convergent_subset"
    ("X" "rest[T](X!1)" "Y" "X!1" "g" "f!1"))
   (assert)
   (hide-all-but 1)
   (rewrite "rest_subset"))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "indiscrete_topology_set")
   (expand "empty?")
   (expand "full?")
   (expand "topology?")
   (split)
   (("1" (grind)) ("2" (grind))
    ("3"
     (expand "topology_Union?")
     (skosimp*)
     (expand "member")
     (flatten)
     (skosimp*)
     (expand "subset?")
     (expand "Union")
     (skosimp)
     (typepred "a!1")
     (inst - "a!1")
     (expand "member")
     (split)
     (("1" (inst - "x!1")) ("2" (inst - "x!2") (inst + "a!1"))))
    ("4"
     (expand "topology_intersection?")
     (skosimp*)
     (typepred "A!1")
     (typepred "B!1")
     (expand "intersection")
     (expand "member")
     (flatten)
     (skosimp*)
     (split -1)
     (("1" (inst - "x!1"))
      ("2"
       (inst - "x!2")
       (assert)
       (split -2)
       (("1" (inst - "x!1")) ("2" (inst - "x!2"))))))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "T0_space?")
   (expand "is_T0?")
   (skosimp)
   (inst + "singleton(x!1)")
   (("1" (grind)) ("2" (hide 2) (grind))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "T1_space?")
   (expand "is_T1?")
   (skosimp)
   (inst + "singleton(x!1)")
   (("1" (grind)) ("2" (hide 2) (grind))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "T2_space?")
   (expand "is_T2?")
   (skosimp)
   (inst + "singleton(x!1)" "singleton(y!1)")
   (("1" (grind)) ("2" (hide 2) (grind)) ("3" (hide 2) (grind))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "discrete_topology_lem")
   (expand "hausdorff_space?")
   (expand "hausdorff?")
   (lemma "T2_topology_TCC1")
   (expand "T2_space?")
   (propax))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "T1_space?")
   (expand "T0_space?")
   (flatten)
   (assert)
   (expand "is_T0?")
   (expand "is_T1?")
   (skosimp)
   (expand "member")
   (inst - "x!2" "y!1")
   (assert)
   (skosimp)
   (inst + "U!1")
   (assert))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "T2_space?")
   (flatten)
   (expand "T1_space?")
   (assert)
   (expand "is_T1?")
   (expand "is_T2?")
   (hide -1)
   (skosimp)
   (inst - "x!2" "y!1")
   (assert)
   (skosimp)
   (inst + "U!1")
   (expand "disjoint?")
   (expand "empty?")
   (replace -2)
   (inst - "y!1")
   (grind))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "hausdorff_space?")
   (expand "T2_space?")
   (expand "hausdorff?")
   (propax))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "T2_space?")
   (expand "hausdorff_space?")
   (expand "hausdorff?")
   (propax))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "compact_space?")
   (expand "compact_subset?")
   (skosimp)
   (expand "finite_cover?")
   (expand "open_cover?")
   (flatten)
   (expand "indiscrete_topology")
   (inst + "U!1")
   (split)
   (("1" (grind))
    ("2"
     (hide -2)
     (expand "subset?")
     (expand "indiscrete_topology_set")
     (expand "member")
     (lemma "finite_subset[set[T]]"
      ("s" "U!1" "A" "{A | empty?(A) OR full?(A)}"))
     (("1" (assert) (expand "subset?") (expand "member") (propax))
      ("2"
       (hide-all-but 1)
       (expand "is_finite")
       (inst + "2"
        "lambda (x: {A | empty?[T](A) OR full?[T](A)}): if empty?(x) then 0 else 1 endif")
       (expand "injective?")
       (skosimp)
       (typepred "x1!1")
       (case-replace "empty?[T](x1!1)")
       (("1"
         (lift-if)
         (prop)
         (("1"
           (rewrite "emptyset_is_empty?")
           (rewrite "emptyset_is_empty?")
           (assert))
          ("2" (assert))))
        ("2"
         (typepred "x2!1")
         (case-replace "empty?[T](x2!1)")
         (("1" (lift-if) (assert))
          ("2"
           (assert)
           (rewrite "fullset_is_full?")
           (rewrite "fullset_is_full?")
           (assert))))))))
    ("3" (propax))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology_prelim
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "connected_space?")
   (expand "connected?")
   (skosimp)
   (typepred "A!1")
   (expand "indiscrete_topology")
   (expand "indiscrete_topology_set")
   (rewrite "emptyset_is_empty?")
   (rewrite "emptyset_is_empty?")
   (rewrite "fullset_is_full?")
   (rewrite "fullset_is_full?")
   (split -1)
   (("1" (propax)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "B!1")
   (expand "member")
   (expand "extend")
   (expand "synthetic_generated_topology_set")
   (split 1)
   (("1"
     (flatten)
     (apply-extensionality :hide? t)
     (expand "Union" 1)
     (case-replace "A!1(x!1)")
     (("1"
       (skosimp)
       (replace -3 -1 rl)
       (expand "Union")
       (skosimp)
       (typepred "a!1")
       (inst + "a!1")
       (expand "subset?")
       (inst - "a!1")
       (expand "member")
       (assert)
       (skosimp)
       (replace -5 1 rl)
       (assert)
       (inst + "a!1"))
      ("2"
       (replace 1 2)
       (assert)
       (skosimp*)
       (typepred "a!1")
       (assert)
       (expand "subset?")
       (inst - "x!1")
       (expand "member")
       (propax))))
    ("2"
     (flatten)
     (inst +
      "extend[setof[T],(B!1),bool,FALSE]({x:(B!1)|subset?(x, A!1)})")
     (split 1)
     (("1"
       (expand "subset?")
       (skosimp)
       (expand "extend")
       (expand "member")
       (assert))
      ("2" (expand "extend") (replace -1 1 rl) (propax))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "B!1")
   (expand "synthetic_generated_topology_set")
   (expand "emptyset")
   (expand "member")
   (inst + "emptyset[set[T]]")
   (split 1)
   (("1"
     (expand "subset?")
     (skosimp)
     (expand "emptyset")
     (expand "member")
     (propax))
    ("2"
     (apply-extensionality 1 :hide? t)
     (expand "emptyset")
     (expand "Union")
     (skosimp))))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "B!1")
   (expand "synthetic_base?")
   (flatten)
   (expand "synthetic_generated_topology_set")
   (expand "member")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "topology_Union?")
   (skosimp*)
   (rewrite "synthetic_generated_alt_def" 1)
   (apply-extensionality 1 :hide? t)
   (case-replace "Union(U!1)(x!1)")
   (("1"
     (expand "Union" -1)
     (expand "Union" 1 1)
     (skosimp)
     (typepred "a!1")
     (expand "subset?" -3)
     (inst-cp - "a!1")
     (expand "member" -4 1)
     (rewrite "synthetic_generated_alt_def" -4)
     (replace -4 -2)
     (expand "Union" -2)
     (skosimp)
     (typepred "a!2")
     (expand "extend")
     (case-replace "B!1(a!2)")
     (("1"
       (inst + "a!2")
       (expand "extend")
       (assert)
       (expand "subset?")
       (skosimp)
       (expand "member")
       (expand "Union")
       (inst - "x!2")
       (assert)
       (inst + "a!1"))
      ("2" (assert))))
    ("2"
     (replace 1 2)
     (assert)
     (expand "extend")
     (expand "Union")
     (skosimp)
     (typepred "a!1")
     (assert)
     (expand "subset?")
     (inst - "x!1")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("B"))
   (expand "topology_intersection?")
   (skosimp*)
   (typepred "A!1")
   (typepred "B!1")
   (rewrite "synthetic_generated_def" 1)
   (lemma "synthetic_generated_alt_def" ("B" "B" "A" "A!1"))
   (lemma "synthetic_generated_alt_def" ("B" "B" "A" "B!1"))
   (expand "member")
   (inst + "{z:(B) | subset?(z,A!1) & subset?(z,B!1)}")
   (split 1)
   (("1"
     (expand "extend")
     (expand "subset?")
     (skosimp)
     (expand "member")
     (assert))
    ("2"
     (apply-extensionality 1 :hide? t)
     (case-replace "intersection(A!1, B!1)(x!1)")
     (("1"
       (expand "intersection")
       (expand "member")
       (flatten)
       (expand "extend")
       (expand "Union")
       (replace -3 -2)
       (replace -4 -1)
       (hide -3 -4)
       (assert)
       (skosimp*)
       (typepred "a!1")
       (typepred "a!2")
       (assert)
       (typepred "B")
       (expand "synthetic_base?")
       (flatten)
       (hide -1)
       (inst - "a!1" "a!2")
       (skosimp)
       (lemma "extensionality_postulate"
        ("f" "Union(V!1)" "g" "intersection(a!1, a!2)"))
       (flatten -1)
       (hide -1)
       (split -1)
       (("1"
         (inst - "x!1")
         (expand "intersection" -1)
         (expand "member")
         (expand "Union" -1)
         (skosimp)
         (typepred "a!3")
         (expand "subset?")
         (inst -3 "a!3")
         (expand "member")
         (inst + "a!3")
         (assert)
         (lemma "Union_subset" ("A" "V!1" "a" "a!3"))
         (replace -5 -1)
         (hide-all-but (-1 -6 -8 1))
         (expand "intersection")
         (expand "subset?")
         (expand "member")
         (split 1)
         (("1"
           (skosimp)
           (inst - "x!2")
           (assert)
           (flatten)
           (inst -5 "x!2")
           (assert))
          ("2"
           (skosimp)
           (inst - "x!2")
           (assert)
           (flatten)
           (inst - "x!2")
           (assert))))
        ("2" (propax))))
      ("2"
       (replace 1 2)
       (assert)
       (expand "extend")
       (expand "Union")
       (skosimp)
       (typepred "a!1")
       (assert)
       (flatten)
       (expand "intersection")
       (expand "subset?")
       (inst - "x!1")
       (inst - "x!1")
       (expand "member")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "base?")
   (expand "synthetic_base?")
   (flatten)
   (split 1)
   (("1"
     (typepred "t!1")
     (expand "topology?")
     (flatten)
     (expand "topology_full?")
     (expand "member")
     (inst - "fullset[T]"))
    ("2"
     (skosimp)
     (typepred "B1!1")
     (typepred "B2!1")
     (typepred "t!1")
     (expand "topology?")
     (flatten)
     (expand "subset?" -7)
     (inst-cp - "B1!1")
     (inst - "B2!1")
     (expand "member")
     (expand "topology_intersection?")
     (inst - "B1!1" "B2!1")
     (expand "member")
     (inst - "intersection(B1!1, B2!1)"))))


proof_type: f_proof
decl_type: formula
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "B!1")
   (expand "base?")
   (split 1)
   (("1"
     (expand "subset?")
     (skosimp)
     (expand "member")
     (expand "synthetic_generated_topology_set")
     (expand "synthetic_base?")
     (flatten)
     (inst -3 "x!1" "x!1")
     (hide -2)
     (rewrite "intersection_idempotent"))
    ("2"
     (skosimp)
     (typepred "A!1")
     (expand "synthetic_generated_topology_set")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "topology?")
   (split)
   (("1"
     (lemma "synthetic_generated_empty")
     (inst - "B!1")
     (expand "topology_empty?")
     (expand "synthetic_generated_topology_set")
     (propax))
    ("2"
     (expand "topology_full?")
     (lemma "synthetic_generated_full" ("B" "B!1"))
     (expand "synthetic_generated_topology_set")
     (propax))
    ("3"
     (lemma "synthetic_generated_Union" ("B" "B!1"))
     (expand "synthetic_generated_topology_set")
     (propax))
    ("4"
     (lemma "synthetic_generated_intersection" ("B" "B!1"))
     (expand "synthetic_generated_topology_set")
     (propax))))


proof_type: j_proof
decl_type: tcc
library: topology
theory: basis
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case-replace
    "synthetic_generated_topology_set(B!1) = synthetic_generated_topology(B!1)")
   (("1" (typepred "synthetic_generated_topology(B!1)") (propax))
    ("2"
     (hide 2)
     (expand "synthetic_generated_topology_set")
     (expand "synthetic_generated_topology")
     (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "closed?")
   (expand "open?")
   (skosimp)
   (rewrite "complement_complement")
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "open?")
   (typepred "S")
   (expand "topology?")
   (flatten)
   (expand "topology_empty?")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "open?")
   (typepred "S")
   (expand "topology?")
   (flatten)
   (expand "topology_full?")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "S")
   (expand "topology?")
   (flatten)
   (expand "topology_Union?")
   (inst - "Y!1")
   (expand "open?")
   (split -3)
   (("1" (propax))
    ("2"
     (hide-all-but (-4 1))
     (expand "subset?")
     (skosimp)
     (expand "every")
     (expand "member")
     (inst - "x!1"))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "U1!1")
   (typepred "U2!1")
   (name "YY" "{a:set[T] | a = U1!1 OR a = U2!1}")
   (lemma "open_Union" ("Y" "YY"))
   (lemma "extensionality" ("a" "Union(YY)" "b" "union(U1!1,U2!1)"))
   (split -1)
   (("1"
     (split -2)
     (("1" (assert))
      ("2"
       (replace -2 1 rl)
       (hide -1 -2 2)
       (expand "every")
       (skosimp)
       (typepred "x!1")
       (split)
       (("1" (assert)) ("2" (assert))))))
    ("2"
     (replace -2 1 rl)
     (hide -1 -2 2)
     (skosimp*)
     (expand "Union")
     (expand "union")
     (assert)
     (split 1)
     (("1"
       (skosimp*)
       (typepred "a!1")
       (split -1)
       (("1" (assert)) ("2" (assert))))
      ("2"
       (flatten)
       (split -1)
       (("1" (inst + "U1!1")) ("2" (inst + "U2!1"))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "U1!1")
   (typepred "U2!1")
   (expand "open?")
   (typepred "S")
   (expand "topology?")
   (flatten)
   (expand "topology_intersection?")
   (inst - "U1!1" "U2!1")
   (("1" (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (name "N" "card(Y!1)")
   (("1"
     (lemma "Intersection_finite" ("A" "Y!1" "P" "open?"))
     (split -1)
     (("1" (propax)) ("2" (rewrite "open_fullset")) ("3" (propax))
      ("4" (expand "every") (propax))
      ("5"
       (skosimp)
       (lemma "open_intersection" ("U1" "a!1" "U2" "b!1"))
       (("1" (propax)) ("2" (propax)) ("3" (propax))))))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (rewrite "open_complement" 1 :dir rl)
   (rewrite "complement_emptyset")
   (rewrite "open_fullset"))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (rewrite "open_complement" 1 :dir rl)
   (rewrite "complement_fullset")
   (rewrite "open_emptyset"))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "open_complement" 1 :dir rl)
   (rewrite "Demorgan2")
   (lemma "open_Union" ("Y" "Complement(Y!1)"))
   (split)
   (("1" (propax))
    ("2"
     (hide 2)
     (expand "every")
     (skosimp)
     (typepred "x!1")
     (expand "Complement")
     (skosimp)
     (typepred "b!1")
     (inst - "b!1")
     (rewrite "open_complement" -3 :dir rl)
     (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "V1!1")
   (typepred "V2!1")
   (rewrite "open_complement" :dir rl)
   (rewrite "open_complement" :dir rl)
   (rewrite "open_complement" :dir rl)
   (rewrite "demorgan2")
   (rewrite "open_union"))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "open_complement" 1 :dir rl)
   (rewrite "demorgan1")
   (typepred "V1!1")
   (typepred "V2!1")
   (rewrite "open_complement" -1 :dir rl)
   (rewrite "open_complement" -2 :dir rl)
   (lemma "open_intersection"
    ("U1" "complement(V1!1)" "U2" "complement(V2!1)"))
   (("1" (propax)) ("2" (propax)) ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "open_complement" 1 :dir rl)
   (rewrite "Demorgan1")
   (lemma "open_Intersection" ("Y" "Complement(Y!1)"))
   (rewrite "finite_Complement")
   (split)
   (("1" (propax))
    ("2"
     (hide -1 2)
     (expand "closed?")
     (expand "Complement")
     (expand "every")
     (skosimp)
     (typepred "x!1")
     (skosimp)
     (inst - "b!1")
     (expand "open?")
     (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "t!1")
   (typepred "indiscrete_topology")
   (expand "subset?")
   (skosimp)
   (expand "member")
   (expand "indiscrete_topology")
   (expand "indiscrete_topology_set")
   (split -3)
   (("1"
     (hide -2)
     (rewrite "emptyset_is_empty?")
     (replace -1)
     (expand "topology?")
     (flatten)
     (expand "topology_empty?")
     (expand "member")
     (propax))
    ("2"
     (rewrite "fullset_is_full?")
     (replace -1)
     (hide -1 -2)
     (expand "topology?")
     (flatten)
     (expand "topology_full?")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "t!1")
   (expand "subset?")
   (skosimp*)
   (expand "discrete_topology")
   (expand "discrete_topology_set")
   (expand "fullset")
   (expand "powerset")
   (expand "member")
   (expand "subset?")
   (skosimp*)
   (expand "member")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "neighbourhood?")
   (expand "interior_point?")
   (expand "open?")
   (split)
   (("1"
     (skosimp*)
     (typepred "x!1")
     (inst + "A!1")
     (("1" (rewrite "subset_reflexive") (expand "member") (propax))
      ("2" (expand "open?") (propax))))
    ("2"
     (skosimp*)
     (name "Ux"
           "{a:set[T] | open?(a) & subset?(a,A!1) & EXISTS (x:(A!1)): a(x)}")
     (case "A!1 = Union(Ux)")
     (("1"
       (lemma "open_Union" ("Y" "Ux"))
       (split -1)
       (("1" (expand "open?") (assert))
        ("2"
         (hide 2)
         (expand "every")
         (skosimp)
         (typepred "x!1")
         (replace -3 -1 rl)
         (assert)
         (flatten))))
      ("2"
       (rewrite "extensionality" 1)
       (replace -1 1 rl)
       (hide -1 2 3)
       (skosimp)
       (expand "Union")
       (case-replace "A!1(x!1)")
       (("1"
         (inst - "x!1")
         (skosimp)
         (inst + "U!1")
         (assert)
         (inst + "x!1"))
        ("2"
         (assert)
         (skosimp*)
         (typepred "a!1")
         (expand "subset?")
         (inst - "x!1")
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "neighbourhood?")
   (expand "interior_point?")
   (skosimp*)
   (expand "member")
   (inst + "intersection(U!1, U!2)")
   (("1"
     (split)
     (("1"
       (expand "subset?")
       (expand "intersection")
       (skosimp*)
       (assert)
       (inst - "x!2")
       (inst - "x!2")
       (flatten)
       (assert)
       (assert))
      ("2" (expand "intersection") (assert))))
    ("2"
     (expand "open?")
     (assert)
     (typepred "U!1")
     (typepred "U!2")
     (lemma "open_intersection" ("U1" "U!1" "U2" "U!2"))
     (expand "open?")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "neighbourhood?")
   (expand "interior_point?")
   (skosimp*)
   (inst + "U!1")
   (lemma "subset_transitive" ("a" "U!1" "b" "A!1" "c" "B!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "extensionality")
   (hide 2)
   (skosimp)
   (expand "union")
   (expand "derived_set")
   (expand "limit_point?")
   (assert)
   (expand "Cl")
   (case-replace "A!1(x!1)")
   (("1"
     (expand "adherent_point?")
     (skosimp)
     (expand "neighbourhood?")
     (expand "interior_point?")
     (skosimp)
     (expand "nonempty?")
     (expand "intersection")
     (expand "empty?")
     (inst - "x!1")
     (assert)
     (expand "subset?")
     (inst - "x!1")
     (assert))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "disjoint?")
   (expand "intersection")
   (expand "derived_set")
   (expand "limit_point?")
   (expand "empty?")
   (skosimp*)
   (assert)
   (flatten))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "subset?")
   (expand "Cl")
   (skosimp*)
   (assert)
   (expand "adherent_point?")
   (expand "nonempty?")
   (skosimp*)
   (typepred "U!1")
   (expand "neighbourhood?")
   (expand "interior_point?")
   (expand "empty?")
   (skosimp)
   (typepred "U!2")
   (expand "subset?")
   (inst - "x!1")
   (assert)
   (inst - "x!1")
   (expand "intersection")
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Cl")
   (expand "subset?")
   (expand "member")
   (expand "adherent_point?")
   (expand "nonempty?")
   (expand "empty?")
   (expand "member")
   (skosimp*)
   (inst -2 "U!1")
   (assert)
   (skosimp)
   (inst - "x!2")
   (inst - "x!2")
   (expand "intersection")
   (flatten)
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "subset_of_Cl" ("A" "Cl(A!1)"))
   (case "subset?(Cl(Cl(A!1)), Cl(A!1))")
   (("1"
     (lemma "subset_antisymmetric" ("a" "Cl(A!1)" "b" "Cl(Cl(A!1))"))
     (assert))
    ("2"
     (hide 2)
     (expand "subset?")
     (expand "Cl")
     (expand "adherent_point?")
     (assert)
     (skosimp*)
     (inst - "U!1")
     (expand "nonempty?")
     (expand "empty?")
     (expand "intersection")
     (assert)
     (expand "neighbourhood?")
     (expand "interior_point?")
     (assert)
     (skosimp*)
     (inst -2 "U!1")
     (hide -6)
     (split -2)
     (("1" (propax)) ("2" (inst + "U!1") (rewrite "subset_reflexive"))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "subset_of_Cl" ("A" "A!1"))
   (case-replace "subset?(Cl(A!1),A!1) IFF closed?(A!1)")
   (("1" (rewrite "subset_antisymmetric" 1 :dir rl) (assert))
    ("2"
     (hide -1 2)
     (rewrite "open_complement" :dir rl)
     (rewrite "subset_complement" :dir rl)
     (lemma "open_def" ("A" "complement(A!1)"))
     (split 1)
     (("1"
       (flatten 1)
       (assert)
       (skosimp)
       (expand "neighbourhood?")
       (expand "subset?")
       (expand "Cl")
       (expand "interior_point?")
       (inst - "x!1")
       (assert)
       (expand "complement")
       (expand "member")
       (expand "adherent_point?")
       (skosimp*)
       (inst + "U!1")
       (assert)
       (expand "neighbourhood?")
       (expand "interior_point?")
       (skosimp*)
       (assert)
       (expand "subset?")
       (inst-cp - "x!1")
       (assert)
       (skosimp)
       (expand "nonempty?")
       (expand "empty?")
       (expand "intersection")
       (inst -4 "x!2")
       (assert)
       (assert))
      ("2"
       (flatten 1)
       (assert)
       (expand "subset?")
       (skosimp*)
       (assert)
       (inst - "x!1")
       (expand "Cl")
       (expand "complement")
       (assert)
       (expand "adherent_point?")
       (inst - "{x: T | NOT A!1(x)}")
       (assert)
       (expand "nonempty?")
       (expand "empty?")
       (expand "intersection")
       (skosimp*)
       (assert)
       (flatten))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "V!1")
   (rewrite "eq_Cl_is_closed" -1 :dir rl)
   (lemma "Cl_subset" ("A" "A!1" "B" "V!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "subset_of_Cl" ("A" "A!1"))
   (lemma "subset_of_Cl" ("A" "B!1"))
   (lemma "Cl_closed" ("A" "A!1"))
   (lemma "Cl_closed" ("A" "B!1"))
   (lemma "closed_union" ("V1" "Cl(A!1)" "V2" "Cl(B!1)"))
   (("1"
     (lemma "union_upper_bound"
      ("a" "A!1" "b" "B!1" "c" "union(Cl(A!1), Cl(B!1))"))
     (split -1)
     (("1"
       (lemma "Cl_subset_closed"
        ("A" "union(A!1,B!1)" "V" "union(Cl(A!1),Cl(B!1))"))
       (("1"
         (assert)
         (lemma "subset_antisymmetric"
          ("a" "Cl(union(A!1,B!1))" "b" "union(Cl(A!1),Cl(B!1))"))
         (assert)
         (hide 2)
         (expand "subset?")
         (expand "union")
         (skosimp*)
         (assert)
         (inst - "x!1")
         (inst - "x!1")
         (split -1)
         (("1"
           (expand "Cl")
           (hide-all-but (-1 1))
           (expand "adherent_point?")
           (skosimp)
           (inst - "U!1")
           (assert)
           (expand "nonempty?")
           (expand "empty?")
           (expand "intersection")
           (skosimp*)
           (assert)
           (flatten)
           (inst - "x!2")
           (assert))
          ("2"
           (hide-all-but (-1 1))
           (expand "Cl")
           (expand "adherent_point?")
           (skosimp)
           (inst - "U!1")
           (assert)
           (hide -2)
           (expand "nonempty?")
           (expand "empty?")
           (expand "intersection")
           (skosimp*)
           (assert)
           (flatten)
           (inst - "x!2")
           (assert))))
        ("2" (propax))))
      ("2"
       (lemma "union_subset1" ("a" "Cl(A!1)" "b" "Cl(B!1)"))
       (assert)
       (lemma "subset_transitive"
        ("a" "A!1" "b" "Cl(A!1)" "c" "union(Cl(A!1), Cl(B!1))"))
       (assert))
      ("3"
       (lemma "subset_transitive"
        ("a" "B!1" "b" "Cl(B!1)" "c" "union(Cl(A!1), Cl(B!1))"))
       (rewrite "union_commutative" -1)
       (rewrite "union_subset1" -1)
       (assert))))
    ("2" (propax)) ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (Y: setofsets[T], n: nat):
                 is_finite(Y) => (card(Y) = n => Cl(Union(Y)) = Union(image(Cl, Y)))")
   (("1" (skosimp) (inst - "Y!1" "card(Y!1)") (assert))
    ("2"
     (hide 2)
     (induct "n")
     (("1"
       (skosimp)
       (rewrite "card_is_0")
       (lemma "emptyset_is_empty?" ("a" "Y!1"))
       (assert)
       (lemma "Union_empty" ("A" "Y!1"))
       (assert)
       (rewrite "emptyset_is_empty?" -1)
       (replace -1)
       (lemma "eq_Cl_is_closed" ("A" "emptyset[T]"))
       (rewrite "closed_emptyset")
       (assert)
       (replace -1 * rl)
       (expand "image")
       (apply-extensionality 1 :hide? t)
       (expand "Union")
       (expand "emptyset")
       (skosimp*)
       (typepred "a!1")
       (assert)
       (skosimp)
       (typepred "x!2")
       (expand "empty?")
       (inst - "x!2")
       (assert))
      ("2"
       (skosimp*)
       (lemma "nonempty_card" ("S" "Y!1"))
       (("1"
         (assert)
         (lemma "Union_split" ("A" "Y!1"))
         (assert)
         (lemma "card_rest" ("S" "Y!1"))
         (split -1)
         (("1"
           (replace -6 -1)
           (assert)
           (inst - "rest(Y!1)")
           (assert)
           (lemma "finite_rest" ("A" "Y!1"))
           (assert)
           (replace -3 1)
           (rewrite "Cl_union" 1)
           (replace -5)
           (hide-all-but (-4 1))
           (apply-extensionality :hide? t)
           (expand "image")
           (expand "Union")
           (expand "union")
           (case-replace
            "EXISTS (a: ({y: set[T] | EXISTS (x: (Y!1)): y = Cl(x)})): a(x!1)")
           (("1"
             (skosimp*)
             (assert)
             (typepred "a!1")
             (skosimp)
             (case-replace "x!2=choose(Y!1)")
             (("1" (assert))
              ("2"
               (inst + "a!1")
               (inst + "x!2")
               (expand "rest")
               (expand "nonempty?")
               (assert)
               (expand "remove")
               (assert))))
            ("2"
             (replace 1 2)
             (assert)
             (split)
             (("1"
               (typepred "choose(Y!1)")
               (inst + "Cl(choose(Y!1))")
               (inst + "choose(Y!1)"))
              ("2"
               (skosimp)
               (typepred "a!1")
               (skosimp)
               (inst + "a!1")
               (inst + "x!2")
               (typepred "x!2")
               (expand "rest")
               (expand "nonempty?")
               (assert)
               (expand "remove")
               (assert))))))
          ("2" (expand "nonempty?") (propax))))
        ("2" (propax))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "Intersection")
   (expand "subset?")
   (skosimp*)
   (expand "member")
   (skosimp)
   (typepred "a!1")
   (expand "image")
   (skosimp)
   (replace -1 1)
   (expand "Cl")
   (typepred "x!2")
   (expand "adherent_point?")
   (skosimp)
   (inst - "U!1")
   (assert)
   (expand "nonempty?")
   (expand "intersection")
   (expand "empty?")
   (skosimp*)
   (inst - "x!3")
   (assert)
   (flatten)
   (inst - "x!2")
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "U!1")
   (typepred "V!1")
   (rewrite "difference_intersection")
   (rewrite "open_complement" -1 :dir rl)
   (lemma "open_intersection" ("U1" "U!1" "U2" "complement(V!1)"))
   (("1" (propax)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "open_complement" 1 :dir rl)
   (rewrite "complement_difference")
   (typepred "U!1")
   (typepred "V!1")
   (rewrite "open_complement" -1 :dir rl)
   (rewrite "open_union"))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (Y: setofsets[T],n:nat):
                 is_finite(Y) AND card[set[T]](Y) = n & every(compact?, Y) => compact?(Union(Y))")
   (("1" (skosimp) (inst - "Y!1" "card[set[T]](Y!1)") (assert))
    ("2"
     (hide 2)
     (induct "n")
     (("1"
       (skosimp)
       (rewrite "card_is_0[set[T]]")
       (replace -2)
       (case-replace "Union(emptyset[set[T]])=emptyset[T]")
       (("1" (rewrite "emptyset_is_compact"))
        ("2"
         (hide-all-but 1)
         (apply-extensionality :hide? t)
         (expand "emptyset")
         (expand "Union")
         (skosimp))))
      ("2"
       (skosimp*)
       (lemma "nonempty_card[set[T]]" ("S" "Y!1"))
       (assert)
       (expand "nonempty?")
       (lemma "choose_rest[set[T]]" ("a" "Y!1"))
       (lemma "card_rest[set[T]]" ("S" "Y!1"))
       (assert)
       (replace -5)
       (assert)
       (inst - "rest[set[T]](Y!1)")
       (assert)
       (rewrite "finite_rest[set[T]]")
       (split -3)
       (("1"
         (expand "every")
         (inst - "choose[set[T]](Y!1)")
         (lemma "union_is_compact"
          ("C1" "Union(rest[set[T]](Y!1))" "C2" "choose[set[T]](Y!1)"))
         (("1"
           (case-replace
            "union[T](Union(rest[set[T]](Y!1)), choose[set[T]](Y!1))=Union(Y!1)")
           (hide-all-but (1 2 -4))
           (apply-extensionality :hide? t)
           (expand "union")
           (expand "member")
           (case-replace "Union(Y!1)(x!1)")
           (("1"
             (flatten)
             (expand "Union")
             (skosimp)
             (inst + "a!1")
             (expand "rest")
             (expand "remove")
             (expand "member")
             (assert))
            ("2"
             (replace 1 2)
             (assert)
             (expand "Union")
             (split)
             (("1"
               (skosimp)
               (inst + "a!1")
               (typepred "a!1")
               (expand "rest")
               (expand "remove")
               (expand "member")
               (flatten))
              ("2" (inst + "choose[set[T]](Y!1)"))))))
          ("2" (propax)) ("3" (propax))))
        ("2"
         (hide-all-but (-5 1))
         (expand "every")
         (skosimp)
         (typepred "x!1")
         (expand "rest")
         (expand "remove")
         (expand "member")
         (flatten)
         (inst - "x!1"))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "compact_space?")
   (expand "compact_subset?")
   (split)
   (("1"
     (skosimp*)
     (expand "nonempty?" 1)
     (inst - "Complement(Y!1)")
     (case-replace "open_cover?(Complement(Y!1), Union(S), S)")
     (("1"
       (skosimp)
       (inst - "Complement(V!1)")
       (case-replace
        "subset?(Complement(V!1), Y!1) AND is_finite(Complement(V!1))")
       (("1"
         (flatten)
         (expand "nonempty?")
         (expand "finite_cover?")
         (expand "open_cover?")
         (flatten)
         (rewrite "Demorgan1" 1 :dir rl)
         (rewrite "emptyset_is_empty?" 1)
         (lemma "complement_equal"
          ("a" "complement(Union(V!1))" "b" "emptyset[T]"))
         (replace -1 1 rl)
         (hide -1)
         (rewrite "complement_emptyset")
         (rewrite "complement_complement")
         (hide-all-but (-7 1))
         (expand "cover?")
         (expand "subset?")
         (expand "member")
         (apply-extensionality :hide? t)
         (inst - "x!1")
         (expand "fullset")
         (split)
         (("1" (propax))
          ("2"
           (hide 2)
           (expand "Union")
           (inst + "fullset[T]")
           (("1" (expand "fullset") (propax))
            ("2"
             (lemma "fullset_is_open")
             (expand "open?")
             (expand "member")
             (propax))))))
        ("2"
         (split)
         (("1"
           (hide-all-but (-2 1))
           (expand "subset?")
           (skosimp)
           (expand "member")
           (expand "Complement")
           (skosimp)
           (typepred "b!1")
           (inst - "b!1")
           (assert)
           (skosimp)
           (replace -3)
           (rewrite "complement_complement")
           (assert))
          ("2"
           (expand "finite_cover?")
           (flatten)
           (hide-all-but (-3 1))
           (expand "is_finite")
           (skosimp)
           (inst + "N!1"
            "lambda (x:(Complement(V!1))): f!1(complement(x))")
           (("1"
             (expand "injective?")
             (skosimp)
             (inst - "complement(x1!1)" "complement(x2!1)")
             (assert)
             (rewrite "complement_equal"))
            ("2"
             (skosimp)
             (typepred "x!1")
             (expand "Complement")
             (skosimp)
             (replace -1)
             (rewrite "complement_complement")
             (assert))))))))
      ("2"
       (hide -1 -3)
       (expand "open_cover?")
       (rewrite "emptyset_is_empty?")
       (lemma "Demorgan2" ("A" "Y!1"))
       (replace -3)
       (rewrite "complement_emptyset")
       (split)
       (("1"
         (hide -1 -3)
         (expand "subset?")
         (expand "every")
         (skosimp)
         (expand "Complement")
         (expand "member")
         (skosimp)
         (typepred "b!1")
         (inst - "b!1")
         (expand "closed?")
         (expand "member")
         (assert))
        ("2"
         (expand "cover?")
         (replace -1 * rl)
         (expand "subset?")
         (expand "member")
         (expand "fullset")
         (propax))))))
    ("2"
     (skosimp*)
     (expand "open_cover?")
     (flatten)
     (inst - "Complement(U!1)")
     (case-replace "every(closed?, Complement(U!1))")
     (("1"
       (split -2)
       (("1"
         (expand "nonempty?")
         (expand "empty?")
         (skosimp)
         (expand "member")
         (rewrite "Demorgan1" -1 :dir rl)
         (expand "cover?")
         (expand "subset?" -4)
         (inst - "x!1")
         (split -4)
         (("1" (expand "complement") (propax))
          ("2"
           (hide-all-but 1)
           (expand "member")
           (expand "Union")
           (inst + "fullset[T]")
           (("1" (expand "fullset") (propax))
            ("2"
             (lemma "open_fullset")
             (expand "open?")
             (expand "member")
             (propax))))))
        ("2"
         (skosimp)
         (expand "nonempty?")
         (inst + "Complement(Y1!1)")
         (split)
         (("1"
           (hide-all-but (-1 1))
           (expand "subset?")
           (skosimp)
           (expand "Complement")
           (expand "member")
           (skosimp)
           (replace -1)
           (typepred "b!1")
           (inst - "b!1")
           (assert)
           (skosimp)
           (replace -3)
           (rewrite "complement_complement")
           (assert))
          ("2"
           (expand "finite_cover?")
           (split)
           (("1"
             (hide-all-but (-2 1))
             (expand "is_finite")
             (skosimp)
             (inst + "N!1"
              "lambda (x:(Complement(Y1!1))): f!1(complement(x))")
             (("1"
               (expand "injective?")
               (skosimp)
               (inst - "complement(x1!1)" "complement(x2!1)")
               (assert)
               (rewrite "complement_equal"))
              ("2"
               (skosimp)
               (typepred "x!1")
               (expand "Complement")
               (skosimp)
               (replace -1)
               (rewrite "complement_complement")
               (assert))))
            ("2"
             (expand "cover?")
             (rewrite "Demorgan2" 1 :dir rl)
             (expand "subset?" 1)
             (skosimp)
             (expand "member")
             (expand "complement")
             (expand "member")
             (expand "empty?" -5)
             (inst - "x!1")
             (expand "member")
             (propax))))))))
      ("2"
       (hide-all-but (-2 1))
       (expand "every")
       (skosimp)
       (expand "closed?")
       (expand "subset?")
       (expand "member")
       (typepred "x!1")
       (expand "Complement")
       (skosimp)
       (inst - "b!1")
       (assert)
       (replace -1)
       (rewrite "complement_complement"))))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "open?")
   (typepred "S")
   (expand "topology?")
   (expand "topology_empty?")
   (flatten))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (typepred "S")
   (expand "closed?")
   (rewrite "complement_emptyset")
   (expand "topology?")
   (expand "topology_full?")
   (flatten))


proof_type: t_proof
decl_type: tcc
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "compact?")
   (expand "compact_subset?")
   (skosimp)
   (inst + "emptyset[set[T]]")
   (hide -1)
   (expand "finite_cover?")
   (rewrite "subset_emptyset")
   (expand "cover?")
   (rewrite "subset_emptyset"))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "compact?")
   (expand "compact_subset?")
   (skosimp)
   (expand "open_cover?")
   (flatten)
   (expand "cover?")
   (expand "subset?")
   (expand "member")
   (inst -2 "x!1")
   (expand "singleton" -2)
   (hide -1)
   (expand "Union")
   (skosimp)
   (typepred "a!1")
   (inst + "singleton[set[T]](a!1)")
   (split)
   (("1" (skosimp) (expand "singleton") (assert))
    ("2"
     (expand "finite_cover?")
     (expand "cover?")
     (expand "subset?")
     (expand "member")
     (skosimp)
     (expand "singleton")
     (replace -1)
     (expand "Union")
     (inst + "a!1"))))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "C1!1")
   (typepred "C2!1")
   (expand "compact?")
   (expand "compact_subset?")
   (skosimp)
   (inst - "U!1")
   (inst - "U!1")
   (expand "open_cover?")
   (flatten)
   (assert)
   (expand "union" -4)
   (expand "cover?")
   (expand "member")
   (hide -3)
   (expand "subset?" -1 1)
   (expand "subset?" -2 1)
   (expand "subset?" -3 1)
   (expand "member")
   (split -1)
   (("1"
     (split -2)
     (("1"
       (hide -3)
       (skosimp*)
       (inst + "union(V!1,V!2)")
       (split)
       (("1"
         (hide -2 -4)
         (expand "union")
         (expand "subset?")
         (expand "member")
         (skosimp)
         (inst - "x!1")
         (inst - "x!1")
         (split -1)
         (("1" (assert)) ("2" (assert))))
        ("2"
         (expand "finite_cover?")
         (flatten)
         (split)
         (("1" (rewrite "finite_union" 1))
          ("2"
           (expand "cover?")
           (hide-all-but (-3 -6 1))
           (expand "subset?")
           (expand "union")
           (expand "member")
           (expand "Union")
           (skosimp)
           (inst - "x!1")
           (inst - "x!1")
           (split)
           (("1" (assert) (skosimp) (inst + "a!1"))
            ("2" (assert) (skosimp) (inst + "a!1"))))))))
      ("2" (skosimp) (inst - "x!1") (assert))))
    ("2" (skosimp) (inst -3 "x!1") (assert))))


proof_type: j_proof
decl_type: tcc
library: topology
theory: topology
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "forall (X:finite_set[T],n:nat): card[T](X) = n => compact?(X)")
   (("1" (skosimp) (inst - "x!1" "card[T](x!1)"))
    ("2"
     (hide 2)
     (induct "n")
     (("1"
       (skosimp)
       (rewrite "card_is_0[T]")
       (replace -1)
       (rewrite "emptyset_is_compact"))
      ("2"
       (skosimp)
       (skosimp)
       (lemma "nonempty_card[T]" ("S" "X!1"))
       (assert)
       (lemma "card_rest[T]" ("S" "X!1"))
       (lemma "choose_rest[T]" ("a" "X!1"))
       (expand "nonempty?")
       (assert)
       (replace -4)
       (inst - "rest[T](X!1)")
       (assert)
       (lemma "singleton_is_compact" ("x" "choose(X!1)"))
       (rewrite "add_as_union[T]")
       (lemma "union_is_compact"
        ("C1" "rest[T](X!1)" "C2" "singleton[T](choose[T](X!1))"))
       (replace -3)
       (propax))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: connected_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "clopen?")
   (typepred "S")
   (expand "connected_space?")
   (flatten)
   (expand "connected?")
   (split 1)
   (("1"
     (flatten)
     (expand "open?")
     (expand "closed?")
     (expand "member")
     (inst - "A!1")
     (assert))
    ("2"
     (flatten)
     (hide -3)
     (split)
     (("1"
       (replace -1)
       (assert)
       (rewrite "open_emptyset")
       (rewrite "closed_emptyset"))
      ("2"
       (replace -1)
       (rewrite "closed_fullset")
       (rewrite "open_fullset"))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous?")
   (expand "continuous_at?")
   (skosimp*)
   (split)
   (("1"
     (skosimp*)
     (lemma "image_inverse_image" ("f" "f!1" "Y" "Y!1"))
     (rewrite "open_def[T1,S]" 1)
     (("1"
       (skosimp)
       (typepred "x!1")
       (inst - "x!1")
       (inst - "Y!1")
       (split)
       (("1" (propax))
        ("2"
         (hide 2)
         (expand "neighbourhood?")
         (expand "interior_point?")
         (expand "inverse_image")
         (inst + "Y!1")
         (assert)
         (expand "subset?")
         (skosimp))))
      ("2" (lemma "topology1") (propax))))
    ("2"
     (expand "neighbourhood?")
     (expand "interior_point?")
     (skosimp*)
     (typepred "U!2")
     (inst - "U!2")
     (assert)
     (inst + "inverse_image(f!1, U!2)")
     (lemma "inverse_image_subset" ("Y1" "U!2" "Y2" "U!1" "f" "f!1"))
     (assert)
     (expand "inverse_image")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "continuous_open_sets")
   (split)
   (("1"
     (skosimp*)
     (expand "closed?")
     (expand "member")
     (inst - "complement(Y!1)")
     (assert)
     (expand "open?")
     (expand "member")
     (rewrite "inverse_image_complement"))
    ("2"
     (skosimp*)
     (expand "closed?")
     (expand "open?")
     (expand "member")
     (inst - "complement(Y!1)")
     (rewrite "complement_complement")
     (assert)
     (rewrite "inverse_image_complement")
     (rewrite "complement_complement"))))


proof_type: f_proof
decl_type: formula
library: topology
theory: continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "continuous_open_sets")
   (split)
   (("1"
     (skosimp*)
     (typepred "Y!1")
     (typepred "B!1")
     (expand "base?")
     (flatten)
     (inst -4 "Y!1")
     (split -4)
     (("1" (propax))
      ("2"
       (hide 2)
       (expand "subset?")
       (expand "open?")
       (expand "member")
       (inst - "Y!1")
       (assert))))
    ("2"
     (skosimp*)
     (typepred "B!1")
     (expand "base?")
     (flatten)
     (expand "open?" -4)
     (expand "member")
     (inst - "Y!1")
     (skosimp)
     (replace -3 * rl)
     (case-replace
      "inverse_image(f!1, Union(V!1)) =
             Union({X | EXISTS Y: V!1(Y) & X=inverse_image(f!1, Y)})")
     (("1"
       (hide -1)
       (lemma "open_Union"
        ("Y" "{X | EXISTS Y: V!1(Y) & X = inverse_image(f!1, Y)}"))
       (split -1)
       (("1" (propax))
        ("2"
         (hide 2)
         (expand "every")
         (skosimp)
         (typepred "x!1")
         (skosimp)
         (replace -2)
         (hide -2)
         (inst - "Y!2")
         (expand "subset?")
         (expand "member")
         (inst -3 "Y!2")
         (assert))))
      ("2"
       (hide 2)
       (apply-extensionality 1 :hide? t)
       (expand "Union")
       (expand "inverse_image")
       (expand "member")
       (case-replace "EXISTS (a: (V!1)): a(f!1(x!1))")
       (("1"
         (skosimp)
         (typepred "a!1")
         (inst + "inverse_image(f!1, a!1)")
         (("1" (expand "inverse_image") (expand "member") (propax))
          ("2" (inst + "a!1"))))
        ("2"
         (replace 1 2)
         (assert)
         (skosimp)
         (typepred "a!1")
         (skosimp)
         (inst + "Y!2")
         (replace -2 -3)
         (expand "inverse_image")
         (expand "member")
         (propax))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: connected_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "U!1")
   (expand "connected?")
   (split)
   (("1"
     (skosimp*)
     (typepred "A!1")
     (typepred "B!1")
     (case-replace "B!1=complement(A!1)")
     (("1"
       (inst - "A!1")
       (assert)
       (hide-all-but (-4 -5 -6))
       (split)
       (("1" (replace -1) (hide-all-but -2) (grind))
        ("2" (replace -1) (hide-all-but -3) (grind))))
      ("2"
       (lemma "extensionality_postulate"
        ("f" "Union(U!1)" "g" "union(A!1, B!1)"))
       (replace -1 -8 rl)
       (hide -1 -4)
       (expand "union")
       (expand "member")
       (apply-extensionality 1 :hide? t)
       (case-replace "B!1(x!1)")
       (("1"
         (expand "disjoint?")
         (expand "intersection")
         (expand "empty?")
         (inst - "x!1")
         (inst - "x!1")
         (assert)
         (expand "complement")
         (assert))
        ("2"
         (assert)
         (expand "complement")
         (inst - "x!1")
         (assert)
         (expand "topology?")
         (flatten)
         (expand "topology_full?")
         (expand "Union")
         (inst + "fullset[T]")
         (("1" (expand "fullset") (propax)) ("2" (assert))))))))
    ("2"
     (skosimp*)
     (inst - "A!1" "complement(A!1)")
     (rewrite "emptyset_is_empty?" 1 :dir rl)
     (rewrite "fullset_is_full?" 2 :dir rl)
     (expand "nonempty?")
     (assert)
     (expand "disjoint?")
     (expand "complement" -1 2)
     (expand "complement" -1 2)
     (expand "intersection")
     (expand "union")
     (expand "empty?" -1 2)
     (assert)
     (split -1)
     (("1" (skosimp))
      ("2"
       (apply-extensionality 1 :hide? t)
       (typepred "A!1")
       (case-replace "A!1(x!1)")
       (("1" (expand "Union") (inst + "A!1"))
        ("2"
         (expand "Union")
         (assert)
         (inst + "complement(A!1)")
         (expand "complement")
         (assert))))
      ("3"
       (expand "full?")
       (skosimp)
       (expand "empty?")
       (inst - "x!1")
       (expand "complement")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: connected_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "U!1")
   (rewrite "connected_def")
   (split)
   (("1"
     (skosimp*)
     (typepred "f!1")
     (rewrite "continuous_open_sets")
     (expand "surjective?")
     (inst-cp - "false")
     (inst - "true")
     (skosimp*)
     (inst-cp -4 "singleton(false)")
     (inst -4 "singleton(true)")
     (split -4)
     (("1"
       (split -5)
       (("1"
         (case-replace
          "inverse_image(f!1, singleton(FALSE)) = complement(inverse_image(f!1, singleton(TRUE)))")
         (("1"
           (name-replace "AA" "inverse_image(f!1, singleton(TRUE))")
           (hide -1)
           (case "AA(x!1)")
           (("1"
             (case "complement(AA)(x!2)")
             (("1"
               (hide -5 -6)
               (expand "open?")
               (expand "member")
               (inst - "AA" "complement(AA)")
               (split -5)
               (("1"
                 (expand "disjoint?")
                 (expand "complement")
                 (expand "intersection")
                 (expand "empty?")
                 (skosimp)
                 (assert)
                 (flatten))
                ("2"
                 (apply-extensionality 1 :hide? t)
                 (expand "complement")
                 (expand "union")
                 (assert)
                 (case-replace "AA(x!3)")
                 (("1" (expand "Union") (inst + "AA"))
                  ("2"
                   (assert)
                   (expand "Union")
                   (inst + "{x: T | NOT AA(x)}"))))
                ("3"
                 (expand "nonempty?")
                 (expand "empty?")
                 (inst - "x!1")
                 (assert))
                ("4"
                 (expand "nonempty?")
                 (expand "empty?")
                 (inst - "x!2")
                 (assert))))
              ("2"
               (hide-all-but (-5 1))
               (grind)
               (expand "AA")
               (expand "inverse_image")
               (grind))))
            ("2" (hide-all-but (-3 1)) (grind) (expand "AA") (grind))))
          ("2"
           (apply-extensionality 1 :hide? t)
           (hide-all-but 1)
           (expand "complement")
           (expand "singleton")
           (expand "inverse_image")
           (expand "member")
           (propax))))
        ("2" (hide-all-but 1) (grind))))
      ("2" (hide-all-but 1) (grind))))
    ("2"
     (skosimp*)
     (name "F" "lambda (x:T): A!1(x)")
     (typepred "B!1")
     (case-replace "B!1=complement(A!1)")
     (("1"
       (hide-all-but (-2 -4 -5 -6 -9))
       (typepred "A!1")
       (case "surjective?[T,bool](A!1)")
       (("1"
         (inst - "A!1")
         (rewrite "continuous_open_sets")
         (skosimp)
         (case "Y!1=emptyset[bool] OR Y!1=singleton(true) OR Y!1=singleton(false) OR Y!1=fullset[bool]")
         (("1"
           (split -1)
           (("1"
             (replace -1)
             (case-replace
              "inverse_image(A!1, emptyset[bool]) = emptyset[T]")
             (("1"
               (expand "topology?")
               (flatten)
               (expand "topology_empty?")
               (expand "open?")
               (propax))
              ("2"
               (hide-all-but 1)
               (apply-extensionality 1 :hide? t)
               (expand "emptyset")
               (expand "inverse_image")
               (expand "member")
               (propax))))
            ("2"
             (replace -1)
             (case-replace "inverse_image(A!1, singleton(TRUE)) = A!1")
             (("1" (expand "open?") (assert))
              ("2"
               (hide 2)
               (apply-extensionality 1 :hide? t)
               (expand "singleton")
               (expand "inverse_image")
               (expand "member")
               (propax))))
            ("3"
             (replace -1)
             (case-replace
              "inverse_image(A!1, singleton(FALSE)) = complement(A!1)")
             (("1" (expand "open?") (assert))
              ("2"
               (apply-extensionality 1 :hide? t)
               (expand "complement")
               (expand "singleton")
               (expand "inverse_image")
               (expand "member")
               (propax))))
            ("4"
             (replace -1)
             (case-replace
              "inverse_image(A!1, fullset[bool]) = fullset[T]")
             (("1"
               (expand "topology?")
               (flatten)
               (expand "topology_full?")
               (expand "open?")
               (propax))
              ("2"
               (apply-extensionality 1 :hide? t)
               (expand "fullset")
               (expand "inverse_image")
               (expand "member")
               (propax))))))
          ("2"
           (hide -2 -3 2)
           (flatten)
           (apply-extensionality 2 :hide? t)
           (apply-extensionality 3 :hide? t)
           (expand "singleton")
           (case-replace "x!1")
           (("1"
             (case-replace "x!2")
             (("1" (assert))
              ("2"
               (assert)
               (apply-extensionality 4 :hide? t)
               (expand "emptyset")
               (hide-all-but (-1 2 3))
               (ground)
               (case-replace "x!3")
               (assert))))
            ("2"
             (assert)
             (case-replace "x!2")
             (("1"
               (assert)
               (apply-extensionality 3 :hide? t)
               (expand "fullset")
               (case-replace "x!3")
               (assert))
              ("2" (assert))))))))
        ("2"
         (expand "surjective?")
         (skosimp)
         (case-replace "y!1")
         (("1"
           (expand "nonempty?" -5)
           (expand "empty?")
           (skosimp)
           (inst + "x!1")
           (assert))
          ("2"
           (expand "nonempty?" -5)
           (expand "complement")
           (expand "empty?")
           (skosimp)
           (inst + "x!1")
           (assert))))))
      ("2"
       (hide -1 -2 -3)
       (apply-extensionality 1 :hide? t)
       (expand "disjoint?")
       (expand "empty?")
       (inst - "x!1")
       (expand "intersection")
       (expand "member")
       (expand "complement")
       (case-replace "A!1(x!1)")
       (("1" (assert))
        ("2"
         (assert)
         (lemma "extensionality_postulate"
          ("f" "Union(U!1)" "g" "union(A!1, B!1)"))
         (replace -1 -4 rl)
         (inst -4 "x!1")
         (expand "union")
         (expand "member")
         (expand "Union")
         (expand "topology?")
         (flatten)
         (expand "topology_full?")
         (expand "member")
         (inst + "fullset[T]")
         (expand "fullset")
         (propax))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: subseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem + ("f" "_"))
   (typepred "f")
   (expand "strict_increasing?")
   (induct "i")
   (("1" (assert)) ("2" (skosimp) (inst - "j!1" "j!1+1") (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: subseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "subseq?")
   (inst + "lambda i:i")
   (("1" (skosimp)) ("2" (expand "strict_increasing?") (skosimp))))


proof_type: f_proof
decl_type: formula
library: topology
theory: subseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "subseq?")
   (skosimp*)
   (inst + "f!2 o f!1")
   (("1"
     (skosimp)
     (inst - "i!1")
     (inst - "f!1(i!1)")
     (expand "o ")
     (assert))
    ("2"
     (hide -1 -2)
     (typepred "f!2")
     (typepred "f!1")
     (expand "o")
     (expand "strict_increasing?")
     (skosimp)
     (inst - "x!1" "y!1")
     (inst - "f!1(x!1)" "f!1(y!1)")
     (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topological_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "v!1")
   (expand "convergent?")
   (skosimp)
   (expand "limit")
   (lemma "epsilon_ax" ("p" "LAMBDA l: convergence?(v!1,l)"))
   (split -1)
   (("1" (assert)) ("2" (inst + "l!1"))))


proof_type: f_proof
decl_type: formula
library: topology
theory: topological_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "accumulation?")
   (expand "convergence?")
   (skosimp*)
   (inst - "U!1")
   (assert)
   (skosimp)
   (inst + "max(n!1,n!2)")
   (inst - "max(n!1,n!2)")
   (expand "max")
   (grind))


proof_type: f_proof
decl_type: formula
library: topology
theory: topological_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "subseq?")
   (expand "convergence?")
   (skosimp*)
   (inst - "U!1")
   (assert)
   (skosimp)
   (inst + "n!1")
   (skosimp)
   (inst - "f!1(i!1)")
   (inst - "i!1")
   (replace -2)
   (split -1)
   (("1" (propax))
    ("2"
     (hide -1 -2 2)
     (case "forall n: n <= f!1(n)")
     (("1" (inst - "i!1") (assert))
      ("2"
       (hide-all-but 1)
       (induct "n")
       (("1" (assert))
        ("2"
         (skosimp*)
         (typepred "f!1")
         (expand "strict_increasing?")
         (inst - "j!1" "j!1+1")
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: hausdorff_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "S")
   (expand "hausdorff_space?")
   (flatten)
   (expand "hausdorff?")
   (expand "is_T2?")
   (inst - "l1!1" "l2!1")
   (assert)
   (skosimp)
   (expand "convergence?")
   (inst - "U!1")
   (("1"
     (inst - "V!1")
     (("1"
       (assert)
       (skosimp*)
       (inst - "max(n!1,n!2)")
       (inst - "max(n!1,n!2)")
       (expand "disjoint?")
       (expand "empty?")
       (inst - "u!1(max(n!1, n!2))")
       (expand "intersection")
       (expand "member")
       (name-replace "DRL1" "u!1(max(n!1, n!2))")
       (hide-all-but (-4 -5 1))
       (grind))
      ("2"
       (typepred "V!1")
       (expand "open?")
       (expand "member")
       (propax))))
    ("2" (expand "open?") (typepred "U!1") (expand "member") (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: hausdorff_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1" (flatten) (replace -1 1 rl) (rewrite "limit_lemma"))
    ("2"
     (flatten)
     (lemma "limit_lemma" ("v" "v!1"))
     (lemma "unique_limit" ("u" "v!1" "l1" "limit(v!1)" "l2" "l!1"))
     (("1" (assert))
      ("2" (typepred "S") (expand "hausdorff_space?") (flatten))))))


proof_type: j_proof
decl_type: tcc
library: topology
theory: hausdorff_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "S")
   (expand "hausdorff_space?")
   (flatten)
   (expand "hausdorff?")
   (expand "is_T2?")
   (name "A" "{(U:(S)) | NOT U(x!1)}")
   (case "forall (x:T): Union(A)(x) IFF x /= x!1")
   (("1"
     (lemma "open_Union" ("Y" "A"))
     (split -1)
     (("1"
       (case-replace
        "Union(extend[setof[T], (S), bool, FALSE](A)) = complement(singleton(x!1))")
       (("1" (expand "closed?") (expand "open?") (propax))
        ("2"
         (hide-all-but (-2 1))
         (apply-extensionality 1 :hide? t)
         (expand "singleton")
         (expand "complement")
         (expand "member")
         (inst - "x!2")
         (replace -1)
         (hide -1)
         (assert))))
      ("2"
       (expand "A")
       (expand "extend")
       (expand "open?")
       (expand "every")
       (expand "member")
       (propax))))
    ("2"
     (hide 2)
     (skosimp)
     (case-replace "x!2=x!1")
     (("1"
       (assert)
       (expand "extend")
       (expand "A")
       (expand "Union")
       (skosimp)
       (typepred "a!1")
       (assert))
      ("2"
       (assert)
       (expand "extend")
       (expand "A")
       (expand "Union")
       (inst - "x!2" "x!1")
       (assert)
       (skosimp)
       (inst + "U!1")
       (expand "disjoint?")
       (expand "intersection")
       (expand "empty?")
       (inst - "x!1")
       (assert))))))


proof_type: j_proof
decl_type: tcc
library: topology
theory: hausdorff_convergence
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem + ("X"))
   (typepred "X")
   (name "B" "difference(fullset[T],X)")
   (case "nonempty?(B)")
   (("1"
     (case "forall x: B(x) => EXISTS (U:open): U(x) & subset?(U,B)")
     (("1"
       (name "BB" "Union({U:set[T] | open?(U) & subset?(U,B)})")
       (("1"
         (case-replace "BB=B")
         (("1"
           (lemma "open_Union"
            ("Y" "{U: set[T] | open?(U) & subset?(U, B)}"))
           (replace -3)
           (split -1)
           (("1"
             (lemma "difference_intersection" ("a" "fullset[T]" "b" "X"))
             (replace -7)
             (lemma "closed_complement" ("A" "B"))
             (assert)
             (replace -2 -1)
             (rewrite "demorgan2")
             (rewrite "complement_complement")
             (rewrite "complement_fullset[T]")
             (rewrite "union_commutative")
             (rewrite "union_empty"))
            ("2" (expand "every") (propax))))
          ("2"
           (hide 2)
           (apply-extensionality :hide? t)
           (replace -1 1 rl)
           (expand "Union")
           (case-replace "B(x!1)")
           (("1" (inst - "x!1") (assert) (skosimp) (inst + "U!1"))
            ("2"
             (replace 1 2)
             (assert)
             (skosimp)
             (typepred "a!1")
             (expand "subset?")
             (inst - "x!1")
             (assert))))))
        ("2" (typepred "S") (expand "hausdorff_space?") (flatten))))
      ("2"
       (case-replace "X=emptyset[T]")
       (("1" (rewrite "emptyset_is_closed"))
        ("2"
         (case "nonempty?(X)")
         (("1"
           (hide 1 3)
           (skosimp)
           (expand "compact?")
           (expand "compact_subset?")
           (name "UV"
                 "lambda (y:(X)): choose({uv:[set[T],set[T]]| open?(uv`1) & open?(uv`2) & uv`1(x!1) & uv`2(y) & disjoint?(uv`1,uv`2)})")
           (("1"
             (inst -6 "{a:set[T] | exists (y:(X)): UV(y)`2 = a}")
             (split -6)
             (("1"
               (skosimp)
               (case "forall (v:(V!1)): exists (u: open): disjoint?(v,u) & u(x!1)")
               (("1"
                 (expand "finite_cover?")
                 (flatten)
                 (case "forall (v:(V!1)): nonempty?[open]({u: open | disjoint?(v, u) & u(x!1)})")
                 (("1"
                   (lemma "finite_image[(V!1),open]"
                    ("f"
                     "lambda (v: (V!1)): choose[open]({u:open | disjoint?(v, u) & u(x!1)})"
                     "S"
                     "V!1"))
                   (("1"
                     (lemma "open_Intersection"
                      ("Y"
                       "(image[(V!1), open]
                                      (LAMBDA (v: (V!1)):
                                         choose[open]({u: open | disjoint?(v, u) & u(x!1)}),
                                       restrict[setof[T], ((V!1)), boolean](V!1)))"))
                     (("1"
                       (expand "restrict")
                       (expand "image")
                       (expand "extend")
                       (split -1)
                       (("1"
                         (hide -2 -6 -8)
                         (inst +
                          "(Intersection(LAMBDA (t: setof[T]):
                                                     IF open?[T, S](t)
                                                       THEN EXISTS (x:
                                                                    (LAMBDA (s: (((V!1)))): TRUE)):
                                                              t
                                                              =
                                                              choose[open]
                                                              ({u_1: open
                                                                |
                                                                disjoint?(x, u_1) & u_1(x!1)})
                                                     ELSE FALSE
                                                     ENDIF))")
                         (("1"
                           (hide -1)
                           (split)
                           (("1"
                             (expand "Intersection")
                             (skosimp)
                             (typepred "a!1")
                             (assert)
                             (skosimp)
                             (typepred "x!2")
                             (inst -4 "x!2")
                             (lemma "choose_member[open]"
                              ("a"
                               "{u_1: open | disjoint?(x!2, u_1) & u_1(x!1)}"))
                             (expand "nonempty?")
                             (assert))
                            ("2"
                             (expand "Intersection")
                             (expand "subset?")
                             (expand "member")
                             (skosimp*)
                             (case "X(x!2)")
                             (("1"
                               (expand "cover?")
                               (expand "subset?")
                               (inst -6 "x!2")
                               (assert)
                               (expand "Union" -6)
                               (skosimp)
                               (typepred "a!1")
                               (inst -
                                "choose[open]
                                                                 ({u_1: open |
                                                                     disjoint?(a!1, u_1) & u_1(x!1)})")
                               (("1"
                                 (lemma
                                  "choose_member[open]"
                                  ("a"
                                   "{u_1: open | disjoint?(a!1, u_1) & u_1(x!1)}"))
                                 (split -1)
                                 (("1"
                                   (expand "member")
                                   (flatten)
                                   (name-replace
                                    "AA"
                                    "choose({u_1: open | disjoint?(a!1, u_1) & u_1(x!1)})")
                                   (("1"
                                     (expand "disjoint?")
                                     (expand "empty?")
                                     (inst - "x!2")
                                     (expand "intersection")
                                     (expand "member")
                                     (assert))
                                    ("2" (inst - "a!1"))))
                                  ("2"
                                   (inst - "a!1")
                                   (expand "nonempty?")
                                   (propax))))
                                ("2" (inst + "a!1")) ("3" (inst - "a!1"))
                                ("4"
                                 (typepred "S")
                                 (expand "hausdorff_space?")
                                 (flatten))))
                              ("2"
                               (expand "B" 2)
                               (expand "fullset")
                               (expand "difference")
                               (expand "member")
                               (propax))))))
                          ("2" (skosimp))
                          ("3"
                           (skosimp)
                           (skosimp)
                           (typepred "S")
                           (expand "hausdorff_space?")
                           (flatten))
                          ("4"
                           (typepred "S")
                           (expand "hausdorff_space?")
                           (flatten))))
                        ("2"
                         (hide-all-but (-1 1))
                         (expand "is_finite")
                         (skosimp)
                         (inst + "N!1" "f!1")
                         (("1"
                           (expand "injective?")
                           (skosimp)
                           (inst - "x1!1" "x2!1")
                           (assert))
                          ("2"
                           (skosimp)
                           (case-replace "open?[T, S](x2!1)")
                           (("1"
                             (split)
                             (("1" (flatten)) ("2" (flatten))))
                            ("2" (replace 1) (assert))))))
                        ("3"
                         (hide -1 -5 -7 2)
                         (expand "every")
                         (propax))))
                      ("2"
                       (typepred "S")
                       (expand "hausdorff_space?")
                       (flatten))))
                    ("2" (propax))
                    ("3"
                     (hide-all-but (-4 1))
                     (expand "restrict")
                     (expand "is_finite")
                     (propax))))
                  ("2"
                   (hide-all-but (-1 1))
                   (skosimp)
                   (inst - "v!1")
                   (skosimp)
                   (expand "nonempty?")
                   (expand "empty?")
                   (expand "member")
                   (inst - "u!1")
                   (assert))))
                ("2"
                 (hide 2)
                 (skosimp)
                 (expand "subset?")
                 (inst - "v!1")
                 (assert)
                 (skosimp)
                 (inst + "UV(y!1)`1")
                 (("1"
                   (typepred "UV(y!1)")
                   (assert)
                   (expand "disjoint?")
                   (rewrite "intersection_commutative")
                   (assert))
                  ("2" (typepred "UV(y!1)") (propax))))
                ("3"
                 (skosimp)
                 (typepred "S")
                 (expand "hausdorff_space?")
                 (flatten))))
              ("2"
               (hide 2)
               (expand "open_cover?")
               (split)
               (("1"
                 (expand "subset?")
                 (expand "member")
                 (skosimp)
                 (skosimp)
                 (typepred "UV(y!1)")
                 (replace -6)
                 (expand "open?")
                 (expand "member")
                 (propax))
                ("2"
                 (expand "cover?")
                 (expand "subset?")
                 (expand "member")
                 (skosimp)
                 (expand "Union")
                 (inst + "UV(x!2)`2")
                 (("1" (typepred "UV(x!2)") (propax))
                  ("2" (inst + "x!2"))))))))
            ("2"
             (hide -5 2)
             (skosimp)
             (typepred "y!1")
             (typepred "S")
             (expand "hausdorff_space?")
             (flatten)
             (expand "hausdorff?")
             (expand "is_T2?")
             (inst - "x!1" "y!1")
             (assert)
             (split -2)
             (("1"
               (skosimp)
               (expand "nonempty?" 1)
               (expand "empty?" -6)
               (expand "member")
               (inst - "(U!1,V!1)")
               (assert)
               (typepred "U!1")
               (typepred "V!1")
               (expand "open?")
               (expand "member")
               (propax))
              ("2"
               (hide 2)
               (replace -6 -4 rl)
               (expand "fullset")
               (expand "difference")
               (expand "member")
               (assert))))
            ("3"
             (skosimp)
             (typepred "S")
             (expand "hausdorff_space?")
             (flatten))
            ("4"
             (skosimp)
             (typepred "S")
             (expand "hausdorff_space?")
             (flatten))))
          ("2" (expand "nonempty?") (rewrite "emptyset_is_empty?"))))))
      ("3"
       (skosimp)
       (typepred "S")
       (expand "hausdorff_space?")
       (flatten))))
    ("2"
     (expand "nonempty?")
     (rewrite "difference_fullset2")
     (rewrite "emptyset_is_empty?")
     (replace -1)
     (expand "closed?")
     (replace -2)
     (assert)
     (typepred "S")
     (expand "hausdorff_space?")
     (expand "topology?")
     (flatten)
     (expand "topology_empty?")
     (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: composition_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_at?")
   (skosimp*)
   (inst -2 "U1!1")
   (expand "o" -3)
   (assert)
   (inst - "inverse_image(f!1, U1!1)")
   (assert)
   (expand "neighbourhood?")
   (expand "interior_point?")
   (skosimp*)
   (inst + "U!1")
   (assert)
   (expand "subset?")
   (skosimp*)
   (inst - "x!2")
   (assert)
   (expand "inverse_image")
   (assert)
   (expand "o")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: composition_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "continuous?")
   (skosimp*)
   (inst - "x!1")
   (inst - "g!1(x!1)")
   (lemma "composition_continuous_at" ("f" "f!1" "g" "g!1" "x" "x!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: homeomorphism_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "homeomorphism?")
   (case-replace "bijective?[T1, T2](f!1)")
   (("1"
     (case "nonempty?(fullset[T1])")
     (("1"
       (case "nonempty?(fullset[T2])")
       (("1"
         (case "EXISTS (x:T1): TRUE")
         (("1"
           (case "forall (y:T2): f!1(inverse_alt(f!1)(y)) = y")
           (("1"
             (case "forall (x:T1): inverse_alt(f!1)(f!1(x)) = x")
             (("1"
               (split 1)
               (("1"
                 (flatten)
                 (skosimp)
                 (split)
                 (("1"
                   (flatten)
                   (rewrite "continuous_open_sets" -3)
                   (("1"
                     (inst - "X!1")
                     (assert)
                     (lemma "extensionality"
                      ("f"
                       "inverse_image(inverse_alt(f!1), X!1)"
                       "g"
                       "image(f!1, X!1)"))
                     (("1"
                       (split -1)
                       (("1" (assert))
                        ("2"
                         (hide-all-but (-4 -5 -6 1 -9))
                         (skosimp)
                         (expand "inverse_image")
                         (expand "member")
                         (case-replace "image(f!1, X!1)(x!1)")
                         (("1"
                           (expand "image")
                           (skosimp)
                           (replace -1)
                           (typepred "x!2")
                           (inst -3 "x!2")
                           (assert))
                          ("2"
                           (replace 1 2)
                           (assert)
                           (expand "image")
                           (inst + "inverse_alt(f!1)(x!1)")
                           (("1" (inst -3 "x!1") (assert))
                            ("2" (flatten))))))))
                      ("2" (flatten))))
                    ("2" (flatten))))
                  ("2"
                   (flatten)
                   (rewrite "continuous_open_sets" -2)
                   (inst - "image(f!1,X!1)")
                   (assert)
                   (rewrite "injective_inverse_image_image")
                   (expand "bijective?")
                   (propax))))
                ("2"
                 (flatten)
                 (split)
                 (("1"
                   (rewrite "continuous_open_sets" 1)
                   (skosimp)
                   (inst - "inverse_image(f!1, Y!1)")
                   (replace -2)
                   (rewrite "surjective_image_inverse_image" 1)
                   (expand "bijective?")
                   (propax))
                  ("2"
                   (rewrite "continuous_open_sets" 1)
                   (("1"
                     (skosimp)
                     (inst - "Y!1")
                     (assert)
                     (lemma "extensionality"
                      ("f"
                       "image(f!1, Y!1)"
                       "g"
                       "inverse_image(inverse_alt(f!1), Y!1)"))
                     (("1"
                       (split -1)
                       (("1" (assert))
                        ("2"
                         (hide 2 -1 -2)
                         (skosimp)
                         (case-replace "image(f!1, Y!1)(x!1)")
                         (("1"
                           (expand "image")
                           (skosimp)
                           (replace -1)
                           (expand "inverse_image")
                           (expand "member")
                           (inst -2 "x!2")
                           (assert))
                          ("2"
                           (replace 1 2)
                           (assert)
                           (expand "inverse_image")
                           (expand "member")
                           (expand "image")
                           (inst + "inverse_alt(f!1)(x!1)")
                           (("1" (inst -3 "x!1") (assert))
                            ("2" (flatten))))))))
                      ("2" (flatten))))
                    ("2" (flatten))))))))
              ("2"
               (skosimp)
               (expand "bijective?")
               (flatten)
               (expand "injective?")
               (inst - "f!1(x!1)")
               (inst - "inverse_alt(f!1)(f!1(x!1))" "x!1")
               (("1" (assert)) ("2" (flatten))))
              ("3" (skosimp))))
            ("2"
             (hide-all-but (-1 -4 1))
             (skosimp)
             (typepred "inverse_alt(f!1)")
             (("1"
               (expand "inverse?")
               (inst - "y!1")
               (split -1)
               (("1" (propax))
                ("2"
                 (expand "bijective?")
                 (flatten)
                 (expand "surjective?")
                 (inst -3 "y!1"))))
              ("2" (flatten))))
            ("3" (skosimp))))
          ("2"
           (hide-all-but (-2 1))
           (expand "fullset")
           (expand "nonempty?")
           (expand "empty?")
           (skosimp)
           (inst + "x!1"))))
        ("2"
         (hide-all-but (-1 1))
         (expand "fullset")
         (expand "nonempty?")
         (expand "empty?")
         (skosimp)
         (inst - "f!1(x!1)")
         (expand "member")
         (propax))))
      ("2"
       (expand "nonempty?")
       (case "empty?(fullset[T2])")
       (("1"
         (rewrite "emptyset_is_empty?")
         (rewrite "emptyset_is_empty?")
         (split)
         (("1"
           (flatten)
           (skosimp)
           (case-replace "X!1=emptyset[T1]")
           (("1"
             (rewrite "image_emptyset")
             (expand "open?")
             (expand "member")
             (typepred "S")
             (typepred "T")
             (expand "topology?")
             (flatten)
             (expand "topology_empty?")
             (expand "member")
             (assert))
            ("2"
             (apply-extensionality 1 :hide? t)
             (expand "emptyset")
             (rewrite "extensionality_postulate" -5 :dir rl)
             (inst -5 "x!1")
             (expand "fullset")
             (propax))))
          ("2"
           (skosimp*)
           (expand "continuous?")
           (split)
           (("1"
             (skosimp)
             (rewrite "extensionality_postulate" -3 :dir rl)
             (inst -3 "x!1")
             (expand "emptyset")
             (expand "fullset")
             (propax))
            ("2"
             (skosimp)
             (rewrite "extensionality_postulate" -2 :dir rl)
             (inst -2 "x!1")
             (expand "emptyset")
             (expand "fullset")
             (propax))))))
        ("2"
         (hide 2)
         (expand "fullset")
         (expand "empty?")
         (skosimp)
         (expand "member")
         (expand "bijective?")
         (flatten)
         (expand "surjective?")
         (inst -3 "x!1")
         (skosimp)
         (inst - "x!2"))))))
    ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: homeomorphism_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (skosimp)
   (expand "bijective?")
   (flatten)
   (expand "surjective?")
   (inst - "r!1")
   (skosimp)
   (inst + "x!1"))


proof_type: f_proof
decl_type: formula
library: topology
theory: homeomorphic_transitive
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "homeomorphic?")
   (skosimp*)
   (expand "homeomorphism?")
   (flatten)
   (inst + "f!2 o f!1")
   (lemma "composition_bijective[T1,T2,T3]" ("f1" "f!1" "f2" "f!2"))
   (("1"
     (assert)
     (lemma "composition_continuous[T1,S,T2,T,T3,U]"
      ("f" "f!2" "g" "f!1"))
     (assert)
     (rewrite "composition_inverse_alt" 1)
     (lemma "composition_continuous[T3,U,T2,T,T1,S]")
     (case "nonempty?(fullset[T1])")
     (("1"
       (case "EXISTS (x:T1): TRUE")
       (("1"
         (case "EXISTS (y:T2): TRUE")
         (("1"
           (case "EXISTS (z:T3): TRUE")
           (("1"
             (inst - "inverse_alt(f!1)" "inverse_alt(f!2)")
             (("1" (assert)) ("2" (flatten)) ("3" (flatten))))
            ("2" (skolem! -) (inst + "f!2(y!1)"))))
          ("2" (skolem! -) (inst + "f!1(x!1)"))))
        ("2"
         (hide-all-but (-1 1))
         (expand "fullset")
         (expand "nonempty?")
         (expand "empty?")
         (skosimp)
         (inst + "x!1"))))
      ("2"
       (expand "nonempty?")
       (rewrite "emptyset_is_empty?" -1)
       (hide -2 -3 -4 -6 -7 -9 -10)
       (expand "bijective?")
       (flatten)
       (expand "continuous?")
       (skosimp)
       (expand "surjective?")
       (inst -5 "x!1")
       (skosimp)
       (inst - "x!2")
       (skosimp)
       (rewrite "extensionality_postulate" -1 :dir rl)
       (inst - "x!3")
       (expand "emptyset")
       (expand "fullset")
       (propax))))
    ("2" (propax)) ("3" (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: homeomorphic_symmetric
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (split)
   (("1"
     (expand "homeomorphic?")
     (skosimp*)
     (inst + "inverse_alt(f!1)")
     (("1"
       (expand "homeomorphism?")
       (flatten)
       (lemma "bijective_inverse_alt_is_bijective[T1,T2]" ("f" "f!1"))
       (("1" (assert) (lemma "inverse_inverse_alt" ("f" "f!1")) (assert))
        ("2" (propax))
        ("3"
         (hide-all-but (1 -1))
         (expand "bijective?")
         (flatten)
         (expand "surjective?")
         (skosimp*)
         (inst - "r!1")
         (skosimp)
         (inst + "x!1"))))
      ("2"
       (expand "homeomorphism?")
       (flatten)
       (expand "bijective?")
       (flatten)
       (expand "surjective?")
       (skosimp*)
       (inst - "r!1")
       (skosimp*)
       (inst + "x!1"))))
    ("2"
     (expand "homeomorphic?")
     (skosimp*)
     (inst + "inverse_alt(f!1)")
     (("1"
       (expand "homeomorphism?")
       (flatten)
       (lemma "bij_inv_is_bij_alt" ("f" "f!1" "g" "inverse_alt(f!1)"))
       (("1" (assert) (lemma "inverse_inverse_alt" ("f" "f!1")) (assert))
        ("2"
         (hide-all-but (-1 1))
         (expand "bijective?")
         (flatten)
         (skosimp*)
         (expand "surjective?")
         (inst - "r!1")
         (skosimp)
         (inst + "x!1"))
        ("3" (propax))))
      ("2"
       (expand "homeomorphism?")
       (expand "bijective?")
       (expand "surjective?")
       (flatten)
       (skosimp)
       (inst - "r!1")
       (skosimp)
       (inst + "x!1"))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: homeomorphic_reflexive
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "homeomorphic?")
   (inst + "lambda (x:T): x")
   (expand "homeomorphism?")
   (case-replace "continuous?[T, S, T, S](LAMBDA (x: T): x)")
   (("1"
     (case-replace "bijective?[T, T](LAMBDA (x: T): x)")
     (("1"
       (case "EXISTS (x:T): TRUE")
       (("1"
         (case-replace
          "inverse_alt(LAMBDA (x: T): x) = (LAMBDA (x: T): x)")
         (("1"
           (hide 2)
           (hide -3)
           (lemma "bijective_inverse_is_inverse_alt"
            ("f" "LAMBDA (x: T): x" "g" "(LAMBDA (x: T): x)"))
           (("1" (replace -1 1 rl) (propax))
            ("2" (hide 2) (expand "inverse?") (propax)) ("3" (propax))
            ("4" (flatten))))
          ("2" (flatten))))
        ("2" (expand "continuous?") (skosimp*) (inst + "x!1"))))
      ("2"
       (hide-all-but 1)
       (expand "bijective?")
       (expand "injective?")
       (expand "surjective?")
       (split)
       (("1" (skosimp)) ("2" (skosimp) (inst + "y!1"))))))
    ("2"
     (hide 2)
     (expand "continuous?")
     (expand "continuous_at?")
     (expand "inverse_image")
     (skosimp*)
     (expand "neighbourhood?")
     (expand "interior_point?")
     (skosimp*)
     (inst + "U!2")
     (assert)
     (expand "subset?")
     (skosimp*)
     (inst - "x!2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: identity_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_at?")
   (expand "neighbourhood?")
   (expand "interior_point?")
   (expand "subset?")
   (skosimp*)
   (assert)
   (expand "I")
   (expand "inverse_image")
   (assert)
   (typepred "U!2")
   (inst + "U!2")
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: constant_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_at?")
   (expand "neighbourhood?")
   (expand "interior_point?")
   (skosimp*)
   (typepred "U!2")
   (assert)
   (inst + "inverse_image(const_fun(a!1), U!2)")
   (("1"
     (lemma "inverse_image_subset[T1,T2]"
      ("Y1" "U!2" "Y2" "U!1" "f" "const_fun[T1,T2](a!1)"))
     (assert)
     (lemma "topology1")
     (lemma "open_fullset[T1,S]")
     (("1" (expand "inverse_image") (assert)) ("2" (propax))))
    ("2"
     (expand "inverse_image")
     (expand "const_fun")
     (expand "member")
     (replace -3)
     (lemma "open_fullset[T1,S]")
     (("1" (expand "fullset") (propax))
      ("2" (lemma "topology1") (propax))))))


proof_type: f_proof
decl_type: formula
library: topology
theory: constant_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous?")
   (skosimp*)
   (lemma "const_continuous_at" ("a" "a!1" "x" "x!1"))
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: subspace
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "induced_topology")
   (typepred "S")
   (expand "topology?")
   (flatten)
   (name "SS" "image(restrict[T1, T2, bool], S)")
   (replace -1)
   (split)
   (("1"
     (hide-all-but (-2 1))
     (expand "topology_empty?")
     (assert)
     (expand "SS")
     (expand "image")
     (inst + "emptyset[T1]")
     (expand "restrict")
     (apply-extensionality 1 :hide? t)
     (typepred "x!1")
     (expand "emptyset")
     (propax))
    ("2"
     (hide-all-but (-1 -3 1))
     (expand "topology_full?")
     (expand "member")
     (replace -1 1 rl)
     (expand "image")
     (expand "restrict")
     (inst + "fullset[T1]")
     (apply-extensionality 1 :hide? t)
     (expand "fullset")
     (propax))
    ("3"
     (expand "topology_Union?")
     (skosimp)
     (case "EXISTS (V:setofsets[T1]): subset?(V,S) & image(restrict[T1,T2,bool],V) = U!1")
     (("1"
       (skosimp)
       (inst - "V!1")
       (assert)
       (expand "restrict")
       (expand "image")
       (replace -4 1 rl)
       (assert)
       (inst + "Union(V!1)")
       (expand "Union")
       (apply-extensionality 1 :hide? t)
       (case-replace "EXISTS (a: (V!1)): a(x!1)")
       (("1"
         (skosimp)
         (typepred "a!1")
         (expand "subset?")
         (inst - "a!1")
         (expand "member")
         (inst + "a!1")
         (("1" (expand "restrict") (propax))
          ("2"
           (replace -4 1 rl)
           (assert)
           (expand "restrict")
           (inst + "a!1"))))
        ("2"
         (replace 1 2)
         (assert)
         (skosimp)
         (typepred "a!1")
         (replace -4 -1 rl)
         (assert)
         (skosimp)
         (replace -1)
         (assert)
         (typepred "x!2")
         (inst + "x!2"))))
      ("2"
       (hide 2)
       (inst + "{A:(S) | EXISTS (B:(U!1)): B = restrict[T1,T2,bool](A)}")
       (split)
       (("1"
         (expand "subset?")
         (expand "extend")
         (expand "member")
         (skosimp*)
         (assert))
        ("2"
         (apply-extensionality 1 :hide? t)
         (expand "extend")
         (expand "restrict")
         (expand "image")
         (expand "subset?")
         (inst - "x!1")
         (expand "member")
         (case-replace "U!1(x!1)")
         (("1"
           (replace -3 -2 rl)
           (assert)
           (skosimp)
           (inst + "x!2")
           (replace -2 1 rl)
           (inst + "x!1"))
          ("2"
           (replace 1 2)
           (assert)
           (skosimp)
           (typepred "x!2")
           (assert))))))))
    ("4"
     (hide-all-but (-1 -5 1))
     (expand "topology_intersection?")
     (skosimp)
     (typepred "A!1")
     (typepred "B!1")
     (replace -3 * rl)
     (hide -3)
     (expand "restrict")
     (expand "image")
     (skosimp*)
     (replace -1)
     (replace -2)
     (assert)
     (typepred "x!1")
     (typepred "x!2")
     (inst - "x!2" "x!1")
     (inst + "intersection(x!2, x!1)")
     (apply-extensionality 1 :hide? t)
     (expand "intersection")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: topology
theory: continuity_subspace
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_at?")
   (expand "restrict")
   (skosimp*)
   (expand "neighbourhood?")
   (expand "interior_point?")
   (skosimp*)
   (typepred "U!2")
   (inst -2 "U!2")
   (split -2)
   (("1"
     (skosimp*)
     (typepred "U!3")
     (inst + "U!3")
     (("1"
       (typepred "x!1")
       (assert)
       (expand "restrict")
       (expand "subset?")
       (expand "inverse_image")
       (assert)
       (skosimp)
       (inst -6 "f!1(x!2)")
       (assert)
       (inst - "x!2")
       (assert))
      ("2"
       (expand "open?")
       (expand "induced_topology")
       (expand "restrict")
       (expand "image")
       (assert)
       (inst + "U!3"))))
    ("2" (hide 2) (inst + "U!2") (assert) (expand "subset?") (skosimp))))


proof_type: f_proof
decl_type: formula
library: topology
theory: continuity_subspace
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "subspace_continuous_at")
   (expand "continuous?")
   (skosimp*)
   (typepred "x!1")
   (inst - "f!1" "x!1")
   (inst - "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "cross_product")
   (expand "empty?")
   (skosimp)
   (expand "member")
   (flatten)
   (inst - "x!1`1"))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "cross_product")
   (expand "empty?")
   (skosimp)
   (expand "member")
   (flatten)
   (inst - "x!1`2"))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "cross_product_empty1" ("A" "emptyset[T1]" "B" "B!1"))
   (lemma "emptyset_is_empty?" ("a" "emptyset[T1]"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "emptyset_is_empty?" ("a" "emptyset[T2]"))
   (lemma "cross_product_empty2" ("B" "emptyset[T2]" "A" "A!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "fullset")
   (expand "cross_product")
   (expand "full?")
   (skosimp)
   (expand "member")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "NB!1")
   (expand "nonempty?")
   (expand "empty?")
   (skosimp)
   (expand "member")
   (expand "cross_product")
   (expand "projection_1")
   (apply-extensionality :hide? t)
   (case-replace "A!1(x!2)")
   (("1" (inst + "(x!2,x!1)") (assert))
    ("2" (assert) (skosimp) (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "NA!1")
   (expand "nonempty?")
   (expand "empty?")
   (skosimp)
   (expand "cross_product")
   (expand "projection_2")
   (expand "member")
   (apply-extensionality :hide? t)
   (case-replace "B!1(x!2)")
   (("1" (inst + "(x!1,x!2)") (assert))
    ("2" (assert) (skosimp) (assert))))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality :hide? t)
   (expand "fullset")
   (expand "projection_1")
   (inst + "(x!1,b!1)"))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality :hide? t)
   (expand "fullset")
   (expand "projection_2")
   (inst + "(a!1,x!1)"))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "cross_product_emptyset1" ("B" "B!1"))
   (lemma "emptyset_is_empty?" ("a" "cross_product(emptyset[T1], B!1)"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "cross_product_emptyset2" ("A" "A!1"))
   (lemma "emptyset_is_empty?" ("a" "cross_product(A!1,emptyset[T2])"))
   (assert))


proof_type: f_proof
decl_type: formula
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "Y!1")
   (skosimp)
   (replace -1)
   (hide -1)
   (case "nonempty?(A!1)")
   (("1"
     (rewrite "projection_product2" 1)
     (case "nonempty?(B!1)")
     (("1" (rewrite "projection_product1"))
      ("2"
       (expand "nonempty?" 1)
       (lemma "cross_product_empty2" ("A" "A!1" "B" "B!1"))
       (assert)
       (lemma "emptyset_is_empty?" ("a" "cross_product(A!1, B!1)"))
       (assert)
       (replace -1)
       (lemma "projection_1_emptyset")
       (replace -1 1)
       (lemma "cross_product_emptyset1" ("B" "B!1"))
       (rewrite "emptyset_is_empty?" -1))))
    ("2"
     (expand "nonempty?" 1)
     (lemma "cross_product_empty1" ("A" "A!1" "B" "B!1"))
     (assert)
     (lemma "emptyset_is_empty?" ("a" "cross_product(A!1, B!1)"))
     (lemma "emptyset_is_empty?" ("a" "A!1"))
     (assert)
     (replace -2)
     (lemma "projection_1_emptyset")
     (lemma "projection_2_emptyset")
     (replace -1)
     (replace -2)
     (lemma "cross_product_emptyset1" ("B" "emptyset[T2]"))
     (lemma "emptyset_is_empty?"
      ("a" "cross_product(emptyset[T1], emptyset[T2])"))
     (assert))))


proof_type: t_proof
decl_type: tcc
library: topology
theory: cross_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "emptyset[[T1,T2]]")
   (inst + "emptyset[T1]" "emptyset[T2]")
   (apply-extensionality :hide? t)
   (expand "emptyset")
   (expand "cross_product")
   (propax))


proof_type: f_proof
decl_type: formula
library: topology
theory: lindelof
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "S")
   (expand "second_countable?")
   (flatten)
   (expand "has_countable_basis?")
   (skosimp)
   (expand "open_cover?")
   (flatten)
   (expand "cover?")
   (lemma "synthetic_base_is_base" ("B" "B!1"))
   (replace -5)
   (expand "base?")
   (flatten)
   (expand "subcover?")
   (expand "cover?" 1 1)
   (assert)
   (hide -3 -6 -5)
   (name "UU" "{x:set[T] | U!1(x) & nonempty?(x)}")
   (case "Union(U!1)=Union(UU)")
   (("1"
     (case "subset?(UU,S)")
     (("1"
       (case "EXISTS V:
                     is_countable(V) AND cover?(V, fullset[T]) AND subset?(V, UU)")
       (("1"
         (skosimp)
         (inst + "V!1")
         (assert)
         (hide-all-but (-3 1))
         (expand "UU")
         (expand "subset?")
         (skosimp)
         (expand "member")
         (inst - "x!1")
         (assert))
        ("2"
         (hide 2)
         (replace -2)
         (hide -2 -3 -7)
         (name "BB"
               "{x:set[T] | B!1(x) & exists (y:(UU)): subset?(x,y)}")
         (case "is_countable(BB)")
         (("1"
           (hide -6)
           (case "forall (x:(BB)): exists (y:(UU)): subset?(x,y)")
           (("1"
             (hide -3)
             (name "F"
                   "lambda (x:(BB)): choose[set[T]]({y:set[T] | UU(y) & subset?(x, y)})")
             (("1"
               (case "forall (x: (BB)): UU(F(x)) & subset?(x,F(x))")
               (("1"
                 (hide -2)
                 (hide -2)
                 (name "VV" "image[(BB),set[T]](F,BB)")
                 (lemma "countable_image[(BB),set[T]]"
                  ("S" "BB" "f" "F"))
                 (expand "image" -1)
                 (replace -2)
                 (split -1)
                 (("1"
                   (inst + "VV")
                   (split 1)
                   (("1" (propax))
                    ("2"
                     (expand "fullset")
                     (expand "cover?")
                     (expand "subset?" (-8 1))
                     (expand "member")
                     (skosimp)
                     (inst -8 "x!1")
                     (expand "Union" (-8 1))
                     (skosimp)
                     (typepred "a!1")
                     (expand "subset?" -6)
                     (inst -6 "a!1")
                     (expand "member")
                     (inst -8 "a!1")
                     (skosimp)
                     (copy -10)
                     (replace -10 -1 rl)
                     (expand "Union" -1)
                     (skosimp)
                     (typepred "a!2")
                     (expand "subset?" -10)
                     (inst -10 "a!2")
                     (expand "member")
                     (inst -6 "a!2")
                     (("1"
                       (flatten)
                       (expand "subset?" -7)
                       (inst -7 "x!1")
                       (assert)
                       (inst + "F(a!2)")
                       (expand "VV")
                       (expand "restrict")
                       (expand "image")
                       (inst + "a!2"))
                      ("2"
                       (hide 2)
                       (expand "BB" 1)
                       (assert)
                       (inst + "a!1")
                       (replace -10 1 rl)
                       (expand "subset?")
                       (expand "member")
                       (expand "Union")
                       (skosimp)
                       (inst + "a!2"))))
                    ("3"
                     (expand "subset?" 1)
                     (skolem!)
                     (expand "member")
                     (flatten)
                     (expand "VV" -1)
                     (expand "restrict" -1)
                     (expand "image" -1)
                     (skolem!)
                     (typepred "x!2")
                     (inst -5 "x!2")
                     (flatten)
                     (assert))))
                  ("2"
                   (hide-all-but (-3 1))
                   (expand "restrict")
                   (expand "is_countable")
                   (propax))))
                ("2"
                 (hide-all-but (-2 1))
                 (skosimp)
                 (expand "F")
                 (typepred
                  "choose[set[T]]({y: set[T] | UU(y) & subset?(x!1, y)})")
                 (("1" (propax))
                  ("2"
                   (hide 2)
                   (expand "nonempty?")
                   (inst - "x!1")
                   (skosimp)
                   (expand "empty?")
                   (inst - "y!1")
                   (assert))))))
              ("2"
               (hide 2)
               (skosimp)
               (inst - "x!1")
               (skosimp)
               (expand "nonempty?")
               (expand "empty?")
               (inst - "y!1")
               (expand "member")
               (propax))))
            ("2" (skosimp) (typepred "x!1") (expand "BB") (flatten))))
          ("2"
           (hide-all-but (-5 1))
           (expand "BB")
           (lemma "countable_subset[set[T]]"
            ("S"
             "{x: set[T] | B!1(x) & (EXISTS (y: (UU)): subset?(x, y))}"
             "Count"
             "B!1"))
           (split -1)
           (("1" (propax))
            ("2"
             (hide -1 2)
             (expand "subset?")
             (expand "member")
             (skosimp*))))))))
      ("2"
       (hide-all-but (1 -6))
       (expand "UU")
       (expand "subset?")
       (expand "member")
       (skosimp)
       (inst - "x!1")
       (assert))))
    ("2"
     (hide-all-but 1)
     (apply-extensionality :hide? t)
     (expand "UU")
     (expand "Union")
     (case-replace "EXISTS (a: (U!1)): a(x!1)")
     (("1"
       (skosimp)
       (inst + "a!1")
       (expand "nonempty?")
       (expand "empty?")
       (inst - "x!1")
       (assert))
      ("2"
       (replace 1 2)
       (assert)
       (skosimp)
       (typepred "a!1")
       (inst + "a!1"))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "atan_deriv_fn")
   (expand "continuous?")
   (skolem 1 ("x"))
   (lemma "identity_continuous[real]" ("x0" "x"))
   (expand "I")
   (lemma "prod_continuous[real]"
    ("f1" "LAMBDA (x: real): x" "f2" "LAMBDA (x: real): x" "x0" "x"))
   (assert)
   (lemma "const_continuous[real]" ("u" "1" "x0" "x"))
   (expand "const_fun")
   (expand "*")
   (lemma "sum_continuous[real]"
    ("f1" "LAMBDA (x: real): 1" "f2" "LAMBDA (x: real): x*x" "x0" "x"))
   (assert)
   (expand "+")
   (lemma "inv_continuous[real]"
    ("g" "LAMBDA (x: real): 1 + x * x" "x0" "x"))
   (("1" (assert) (expand "/") (propax))
    ("2"
     (hide-all-but 1)
     (skosimp*)
     (lemma "sq_pos" ("a" "x!1"))
     (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "atan_value")
   (lemma "Integral_a_to_a[real]" ("a" "0" "f" "atan_deriv_fn"))
   (("1" (propax)) ("2" (assert) (expand "connected?") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: fixit
script:
  (""
   (lemma "derivs_eq[real]"
    ("F"
     "LAMBDA (z:real): atan_value(-z)"
     "G"
     "LAMBDA (z:real): -atan_value(z)"))
   (("1"
     (skolem 1 ("x"))
     (lemma "identity_derivable_fun[real]")
     (lemma "deriv_id_fun[real]")
     (lemma "neg_derivable_fun[real]" ("f" "LAMBDA (x:real): x"))
     (lemma "deriv_neg_fun[real]" ("ff" "LAMBDA (x: real): x"))
     (("1"
       (expand "I")
       (lemma "one_over_one_plus_t_sq_cont")
       (lemma "fundamental[real]"
        ("f" "atan_deriv_fn" "a" "0" "F" "atan_value"))
       (split -1)
       (("1"
         (flatten -1)
         (lemma "composition_derivable_fun[real,real]"
          ("f" "-(LAMBDA (x: real): x)" "g" "atan_value"))
         (lemma "composition_derivable_fun[real,real]"
          ("g" "-(LAMBDA (x: real): x)" "f" "atan_value"))
         (assert)
         (assert)
         (lemma "deriv_comp_fun[real,real]"
          ("ff" "-(LAMBDA (x: real): x)" "gg" "atan_value"))
         (lemma "deriv_comp_fun[real,real]"
          ("gg" "-(LAMBDA (x: real): x)" "ff" "atan_value"))
         (expand "o")
         (expand "-")
         (expand "*")
         (assert)
         (replace -6)
         (expand "const_fun")
         (replace -10)
         (simplify -8)
         (replace -8)
         (simplify -2)
         (simplify -1)
         (replace -1)
         (replace -2)
         (lemma "extensionality_postulate"
          ("f"
           "LAMBDA (x: real): atan_deriv_fn(-x) * -1"
           "g"
           "LAMBDA (x: real): -1 * atan_deriv_fn(x)"))
         (split -13)
         (("1"
           (skosimp*)
           (lemma "extensionality_postulate"
            ("f"
             "(LAMBDA (z: real): atan_value(-z))"
             "g"
             "(LAMBDA (z: real): -atan_value(z)) + (LAMBDA (x: real): c!1)"))
           (replace -1 -2 rl)
           (inst-cp -2 "0")
           (expand "+")
           (rewrite "atan_value_0")
           (inst -2 "x")
           (assert))
          ("2" (skosimp*) (expand "atan_deriv_fn") (assert))))
        ("2" (propax)) ("3" (expand "atan_value" 1) (propax))))
      ("2" (assert) (expand "I") (propax))))
    ("2"
     (skosimp*)
     (assert)
     (lemma "not_one_element")
     (expand "not_one_element?")
     (expand "connected?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "derivs_eq[posreal]"
    ("F"
     "LAMBDA (x:posreal): atan_value(x)"
     "G"
     "LAMBDA (x:posreal): atan_value(-1/x)"))
   (("1"
     (skolem 1 ("x"))
     (lemma "fundamental[real]"
      ("f" "atan_deriv_fn" "F" "atan_value" "a" "0"))
     (("1"
       (split -1)
       (("1"
         (flatten -1)
         (lemma "restrict2_derivable[posreal,real]" ("f" "atan_value"))
         (("1"
           (lemma "restrict2_deriv[posreal,real]" ("f" "atan_value"))
           (expand "restrict2")
           (replace -2)
           (lemma "composition_derivable_fun[posreal,real]"
            ("f" "LAMBDA (x: posreal): -(1 / x)" "g" "atan_value"))
           (lemma "identity_derivable_fun[posreal]")
           (lemma "deriv_id_fun[posreal]")
           (expand "I")
           (expand "const_fun")
           (lemma "inv_derivable_fun[posreal]"
            ("g" "(LAMBDA (x: posreal): x)"))
           (assert)
           (expand "/")
           (lemma "deriv_inv_fun[posreal]"
            ("gg" "(LAMBDA (x: posreal): x)"))
           (replace -3)
           (expand "-")
           (expand "/")
           (expand "*")
           (lemma "neg_derivable_fun[posreal]"
            ("f" "LAMBDA (x_1: posreal): 1 / x_1"))
           (assert)
           (expand "-")
           (lemma "deriv_neg_fun[posreal]"
            ("ff" "LAMBDA (x_1: posreal): 1 / x_1"))
           (expand "-")
           (replace -3 -1)
           (simplify -1)
           (lemma "composition_derivable_fun[posreal,real]"
            ("f" "LAMBDA (x: posreal): -(1 / x)" "g" "atan_value"))
           (lemma "deriv_comp_fun[posreal,real]"
            ("ff" "LAMBDA (x: posreal): -(1 / x)" "gg" "atan_value"))
           (("1"
             (expand "o")
             (assert)
             (replace -13)
             (replace -3)
             (expand "*")
             (expand "atan_deriv_fn" -1)
             (lemma "deriv_comp_fun[posreal,real]"
              ("ff" "LAMBDA (x:posreal): x" "gg" "atan_value"))
             (expand "o")
             (replace -13)
             (replace -8)
             (expand "*")
             (expand "atan_deriv_fn" -1)
             (replace -1 -14)
             (replace -2 -14)
             (lemma "extensionality_postulate"
              ("f"
               "(LAMBDA (x_1: posreal): 1 / (1 + x_1 * x_1))"
               "g"
               "(LAMBDA (x_1: posreal): 1 / (1 + -(1 / x_1) * -(1 / x_1)) * -(-1 / (x_1 * x_1)))"))
             (("1"
               (replace -1 -15 rl)
               (hide -1)
               (simplify -14)
               (split -14)
               (("1"
                 (skolem -1 ("c"))
                 (lemma "extensionality_postulate"
                  ("f"
                   "(LAMBDA (x: posreal): atan_value(x))"
                   "g"
                   "(LAMBDA (x: posreal): atan_value(-1 / x)) + (LAMBDA (x: posreal): c)"))
                 (replace -1 -2 rl)
                 (hide-all-but (-2 1))
                 (expand "+")
                 (inst-cp - "1")
                 (inst - "x")
                 (lemma "atan_neg_value")
                 (inst-cp - "1")
                 (inst - "1/x")
                 (replace -1)
                 (replace -2)
                 (assert))
                ("2"
                 (hide-all-but 1)
                 (skolem 1 ("z"))
                 (lemma "div_times"
                  ("x"
                   "1"
                   "n0x"
                   "1 + -(1 / z) * -(1 / z)"
                   "y"
                   "1"
                   "n0y"
                   "z*z"))
                 (replace -1 1)
                 (hide -1)
                 (rewrite "cross_mult"))))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (typepred "1/x!1")
               (lemma "negreal_times_negreal_is_posreal"
                ("nx" "-(1/x!1)" "ny" "-(1/x!1)"))
               (("1"
                 (assert)
                 (name-replace "FF" "-(1 / x!1) * -(1 / x!1)")
                 (assert))
                ("2" (assert))))))
            ("2" (propax))))
          ("2" (skosimp*) (inst + "x!1"))))
        ("2" (assert) (lemma "one_over_one_plus_t_sq_cont") (propax))
        ("3" (expand "atan_value") (propax))))
      ("2"
       (hide-all-but 1)
       (assert)
       (lemma "not_one_element")
       (expand "not_one_element?")
       (expand "connected?")
       (propax))))
    ("2" (hide 2) (assert) (expand "connected?") (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "atan_inv_value" ("px" "-nx!1"))
   (rewrite "atan_neg_value" -1)
   (lemma "atan_neg_value" ("x" "1/nx!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "positive_derivative[real]" ("g" "atan_value"))
   (("1"
     (split -1)
     (("1" (propax))
      ("2"
       (hide 2)
       (skolem 1 ("x"))
       (lemma "one_over_one_plus_t_sq_cont")
       (lemma "fundamental[real]"
        ("f" "atan_deriv_fn" "F" "atan_value" "a" "0"))
       (assert)
       (split -1)
       (("1"
         (flatten)
         (expand "deriv" -2)
         (lemma "extensionality_postulate"
          ("g"
           "atan_deriv_fn"
           "f"
           "LAMBDA (x: real): deriv(atan_value, x)"))
         (("1"
           (replace -1 -3 rl)
           (inst -3 "x")
           (replace -3 1)
           (typepred "atan_deriv_fn(x)")
           (propax))
          ("2" (skosimp*) (assert) (expand "derivable?" -1) (inst?))))
        ("2" (expand "atan_value") (propax))))))
    ("2"
     (hide 2)
     (lemma "one_over_one_plus_t_sq_cont")
     (lemma "fundamental[real]"
      ("f" "atan_deriv_fn" "F" "atan_value" "a" "0"))
     (("1" (assert) (expand "atan_value") (propax))
      ("2" (assert) (expand "connected?") (propax))))
    ("3" (assert) (expand "connected?") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z" "x"))
   (flatten)
   (typepred "z")
   (hide -1)
   (lemma "div_mult_pos_lt1" ("z" "-1" "py" "z" "x" "x"))
   (assert)
   (lemma "fundamental[real]"
    ("f" "atan_deriv_fn" "F" "atan_value" "a" "0"))
   (("1"
     (lemma "one_over_one_plus_t_sq_cont")
     (expand "atan_value" -2 1)
     (replace -1)
     (flatten -2)
     (lemma "identity_derivable_fun[{a:real| -1/z<a}]")
     (("1"
       (lemma "deriv_id_fun[{a:real| -1/z<a}]")
       (expand "I")
       (lemma "deriv_const_fun[{a: real | -1 / z < a}]" ("b" "1"))
       (lemma "const_derivable_fun[{a: real | -1 / z < a}]" ("b" "1"))
       (lemma "const_derivable_fun[{a: real | -1 / z < a}]" ("b" "z"))
       (lemma "deriv_const_fun[{a: real | -1 / z < a}]" ("b" "z"))
       (lemma "prod_derivable_fun[{a: real | -1 / z < a}]"
        ("f1"
         "LAMBDA (x: {a: real | -1 / z < a}): x"
         "f2"
         "LAMBDA (x: {a: real | -1 / z < a}): z"))
       (assert)
       (lemma "deriv_prod_fun[{a: real | -1 / z < a}]"
        ("ff1"
         "LAMBDA (x: {a: real | -1 / z < a}): x"
         "ff2"
         "LAMBDA (x: {a: real | -1 / z < a}): z"))
       (expand "*")
       (expand "+")
       (replace -3)
       (replace -7)
       (simplify -1)
       (lemma "deriv_sum_fun[{a: real | -1 / z < a}]"
        ("ff1"
         "LAMBDA (x: {a: real | -1 / z < a}): 1"
         "ff2"
         "LAMBDA (x_1: {a: real | -1 / z < a}): x_1 * z"))
       (("1"
         (lemma "sum_derivable_fun[{a: real | -1 / z < a}]"
          ("f1"
           "LAMBDA (x: {a: real | -1 / z < a}): 1"
           "f2"
           "LAMBDA (x_1: {a: real | -1 / z < a}): x_1 * z"))
         (assert)
         (replace -3)
         (replace -8)
         (expand "+")
         (lemma "diff_derivable_fun[{a: real | -1 / z < a}]"
          ("f1"
           "LAMBDA (x: {a: real | -1 / z < a}): x"
           "f2"
           "LAMBDA (x_1: {a: real | -1 / z < a}): z"))
         (assert)
         (lemma "deriv_diff_fun[{a: real | -1 / z < a}]"
          ("ff1"
           "LAMBDA (x: {a: real | -1 / z < a}): x"
           "ff2"
           "LAMBDA (x_1: {a: real | -1 / z < a}): z"))
         (replace -7)
         (replace -11)
         (expand "-")
         (lemma "div_derivable_fun[{a: real | -1 / z < a}]"
          ("f"
           "LAMBDA (x_1: {a: real | -1 / z < a}): x_1 - z"
           "g"
           "LAMBDA (x_1: {a: real | -1 / z < a}): 1 + x_1 * z"))
         (("1"
           (assert)
           (lemma "deriv_div_fun[{a: real | -1 / z < a}]"
            ("ff"
             "LAMBDA (x_1: {a: real | -1 / z < a}): x_1 - z"
             "gg"
             "LAMBDA (x_1: {a: real | -1 / z < a}): 1 + x_1 * z"))
           (replace -3)
           (replace -6)
           (expand "/")
           (expand "-")
           (expand "*")
           (lemma
            "composition_derivable_fun[{a: real | -1 / z < a},real]"
            ("f"
             "LAMBDA (x: {a: real | -1 / z < a}): x"
             "g"
             "atan_value"))
           (lemma
            "composition_derivable_fun[{a: real | -1 / z < a},real]"
            ("f"
             "LAMBDA (x: {a: real | -1 / z < a}): (x - z) / (1 + x * z)"
             "g"
             "atan_value"))
           (lemma "deriv_comp_fun[{a: real | -1 / z < a},real]"
            ("ff"
             "LAMBDA (x: {a: real | -1 / z < a}): (x - z) / (1 + x * z)"
             "gg"
             "atan_value"))
           (("1"
             (lemma "deriv_comp_fun[{a: real | -1 / z < a},real]"
              ("ff"
               "LAMBDA (x: {a: real | -1 / z < a}): x"
               "gg"
               "atan_value"))
             (assert)
             (expand "o")
             (replace -17)
             (replace -21)
             (replace -5)
             (expand "*")
             (lemma "derivs_eq[{a: real | -1 / z < a}]"
              ("F"
               "LAMBDA (x_1: {a: real | -1 / z < a}): atan_value((x_1 - z) / (1 + x_1 * z))"
               "G"
               "LAMBDA (x_1: {a: real | -1 / z < a}): atan_value(x_1)"))
             (("1"
               (assert)
               (replace -2)
               (replace -3)
               (hide -2 -3 -6 -8 -11)
               (lemma "extensionality_postulate"
                ("f"
                 "LAMBDA (x_1: {a: real | -1 / z < a}): atan_deriv_fn((x_1 - z) / (1 + x_1 * z)) * ((1 + z * z) / (1 + 2 * (x_1 * z) + x_1 * x_1 * z * z))"
                 "g"
                 "LAMBDA (x_1: {a: real | -1 / z < a}): atan_deriv_fn(x_1)"))
               (("1"
                 (replace -1 -2 rl)
                 (hide -1)
                 (split -1)
                 (("1"
                   (skolem -1 ("c"))
                   (expand "const_fun")
                   (expand "+")
                   (lemma "extensionality_postulate"
                    ("f"
                     "LAMBDA (x_1: {a: real | -1 / z < a}): atan_value((x_1 - z) / (1 + x_1 * z))"
                     "g"
                     "LAMBDA (x_1: {a: real | -1 / z < a}): atan_value(x_1) + c"))
                   (replace -1 -2 rl)
                   (hide -1)
                   (simplify -1)
                   (inst-cp -1 "0")
                   (("1"
                     (rewrite "atan_value_0" -2)
                     (simplify -2)
                     (lemma "atan_neg_value" ("x" "z"))
                     (replace -1)
                     (replace -3 -2 rl)
                     (inst -2 "x")
                     (assert))
                    ("2"
                     (lemma "div_mult_pos_lt1"
                      ("z" "-1" "py" "z" "x" "0"))
                     (assert))))
                  ("2"
                   (hide-all-but (1 -18))
                   (skosimp*)
                   (typepred "x!1")
                   (lemma "div_mult_pos_lt1"
                    ("z" "-1" "x" "x!1" "py" "z"))
                   (assert)
                   (lemma "posreal_times_posreal_is_posreal"
                    ("px" "1+x!1*z" "py" "1+x!1*z"))
                   (lemma "div_cancel3"
                    ("x"
                     "atan_deriv_fn((x!1 - z) / (1 + x!1 * z)) * (1 + z * z)"
                     "n0z"
                     "(1 + x!1 * z) * (1 + x!1 * z)"
                     "y"
                     "atan_deriv_fn(x!1)"))
                   (("1"
                     (replace -1 1 lr)
                     (hide -1)
                     (name "XMZ" "x!1-z")
                     (replace -1)
                     (name "XZP1" "1+x!1*z")
                     (replace -1)
                     (name "ZSQP1" "1+z*z")
                     (replace -1)
                     (expand "atan_deriv_fn")
                     (lemma "sq_pos" ("a" "x!1"))
                     (lemma "sq_pos" ("a" "XMZ/XZP1"))
                     (expand "sq")
                     (lemma "cross_mult"
                      ("x"
                       "ZSQP1"
                       "n0x"
                       "1 + XMZ / XZP1 * (XMZ / XZP1)"
                       "y"
                       "XZP1 * XZP1"
                       "n0y"
                       "1 + x!1 * x!1"))
                     (replace -1 1)
                     (hide -1)
                     (lemma "div_times"
                      ("x" "XMZ" "n0x" "XZP1" "y" "XMZ" "n0y" "XZP1"))
                     (replace -1 1)
                     (lemma "div_cancel1"
                      ("n0z" "XZP1 * XZP1" "x" "XMZ * XMZ"))
                     (simplify 1)
                     (replace -1 1)
                     (replace -7 * rl)
                     (replace -6 * rl)
                     (replace -5 * rl)
                     (assert))
                    ("2" (assert))))))
                ("2"
                 (hide -1 2)
                 (skosimp*)
                 (typepred "x!1")
                 (lemma "div_mult_pos_lt1" ("z" "-1" "py" "z" "x" "x!1"))
                 (assert)
                 (lemma "posreal_times_posreal_is_posreal"
                  ("px" "x!1*z+1" "py" "x!1*z+1"))
                 (assert))))
              ("2" (assert) (hide-all-but 1) (inst + "0") (cross-mult 1))
              ("3" (assert) (expand "connected?") (skosimp*) (assert))))
            ("2" (propax))))
          ("2"
           (hide-all-but 1)
           (skosimp*)
           (typepred "x!1")
           (cross-mult -1)
           (assert))))
        ("2" (propax))))
      ("2"
       (assert)
       (expand "not_one_element?")
       (skosimp*)
       (inst + "x!1+1")
       (assert))
      ("3"
       (hide 2 -1 -2 -3)
       (expand "deriv_domain?")
       (skosimp*)
       (inst + "e!1/2")
       (grind))))
    ("2" (hide-all-but 1) (assert) (expand "connected?") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z" "x"))
   (flatten)
   (typepred "z")
   (hide -1)
   (lemma "atan_inv_value" ("px" "z"))
   (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "z"))
   (lemma "atan_inv_neg_value" ("nx" "x"))
   (("1"
     (lemma "atan_value_minus_x1" ("py" "1/z" "x" "1/x"))
     (("1"
       (rewrite "div_div1" -1)
       (lemma "div_mult_neg_lt2" ("z" "1" "x" "-z" "ny" "x"))
       (lemma "div_mult_pos_lt2" ("z" "-1" "x" "x" "py" "z"))
       (assert)
       (lemma "minus_div1" ("x" "1" "y" "1" "n0x" "x" "n0y" "z"))
       (replace -1 -4)
       (lemma "add_div" ("x" "1" "y" "1" "n0x" "1" "n0y" "x*z"))
       (replace -1 -5)
       (rewrite "div_div1" -5)
       (lemma "div_cancel2" ("x" "z-x" "n0z" "x*z"))
       (replace -1 -6)
       (lemma "atan_neg_value" ("x" "(z - x) / (1 + x * z)"))
       (replace -1 1)
       (assert))
      ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x" "y"))
   (split 1)
   (("1"
     (flatten)
     (lemma "trichotomy" ("x" "y"))
     (split -1)
     (("1"
       (lemma "atan_value_minus_x1" ("x" "x" "py" "y"))
       (("1"
         (lemma "div_mult_pos_lt1" ("z" "-1" "py" "y" "x" "x"))
         (assert))
        ("2" (assert))))
      ("2" (replace -1) (rewrite "atan_value_0") (assert))
      ("3"
       (lemma "atan_value_minus_x1" ("x" "-x" "py" "-y"))
       (("1"
         (lemma "div_mult_pos_lt1" ("z" "-1" "py" "-y" "x" "-x"))
         (assert)
         (rewrite "atan_neg_value" -2)
         (rewrite "atan_neg_value" -2)
         (lemma "atan_neg_value" ("x" "(x - y) / (1 + x * y)"))
         (replace -1 -3)
         (assert))
        ("2" (assert))))))
    ("2"
     (flatten)
     (lemma "atan_value_minus_x2" ("x" "x" "py" "y"))
     (("1"
       (lemma "div_mult_pos_lt2" ("x" "x" "py" "y" "z" "-1"))
       (assert))
      ("2" (assert))))
    ("3"
     (flatten)
     (lemma "atan_value_minus_x2" ("x" "-x" "py" "-y"))
     (("1"
       (lemma "div_mult_pos_lt2" ("x" "-x" "py" "-y" "z" "-1"))
       (rewrite "atan_neg_value" -2)
       (rewrite "atan_neg_value" -2)
       (lemma "atan_neg_value" ("x" "(x - y) / (1 + x * y)"))
       (("1" (replace -1 -3) (assert))
        ("2" (hide-all-but (-3 -4 1)) (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "bijective?")
   (split 1)
   (("1"
     (expand "injective?")
     (skolem 1 ("x" "y"))
     (flatten)
     (lemma "atan_strict_increasing")
     (expand "strict_increasing?")
     (lemma "trich_lt" ("x" "x" "y" "y"))
     (split -1)
     (("1" (inst - "x" "y") (assert)) ("2" (propax))
      ("3" (inst - "y" "x") (assert))))
    ("2"
     (expand "surjective?")
     (skosimp*)
     (typepred "y!1")
     (lemma "derivable_cont_fun[real]" ("f" "atan_value"))
     (split -1)
     (("1"
       (expand "atan")
       (lemma "atan_value_strict_increasing")
       (expand "strict_increasing?")
       (lemma "trichotomy" ("x" "y!1"))
       (split -1)
       (("1"
         (lemma "trich_lt" ("x" "y!1" "y" "atan_value(1)"))
         (split -1)
         (("1"
           (lemma "intermediate1[real]"
            ("g" "atan_value" "a" "0" "b" "1" "x" "y!1"))
           (("1"
             (rewrite "atan_value_0")
             (assert)
             (skosimp*)
             (inst + "c!1"))
            ("2" (propax))))
          ("2" (inst + "1") (assert))
          ("3"
           (inst-cp - "0" "1")
           (assert)
           (rewrite "atan_value_0")
           (expand "pi")
           (inst-cp - "0" "1")
           (assert)
           (lemma "intermediate1[real]"
            ("a" "0" "b" "1" "x" "2*atan_value(1)-y!1" "g" "atan_value"))
           (rewrite "atan_value_0")
           (assert)
           (skolem -1 ("c"))
           (flatten)
           (expand "<=" -1)
           (split -1)
           (("1"
             (lemma "atan_inv_value" ("px" "1/c"))
             (("1" (inst + "1/c") (assert))
              ("2"
               (assert)
               (lemma "posreal_div_posreal_is_posreal"
                ("px" "1" "py" "c"))
               (assert))
              ("3" (assert))))
            ("2"
             (assert)
             (replace -1 * rl)
             (rewrite "atan_value_0")
             (assert))))))
        ("2" (inst + "0") (rewrite "atan_value_0") (assert))
        ("3"
         (lemma "trich_lt" ("x" "y!1" "y" "-atan_value(1)"))
         (assert)
         (split -1)
         (("1"
           (expand "pi")
           (lemma "intermediate1[real]"
            ("a"
             "-1"
             "b"
             "0"
             "x"
             "-2*atan_value(1)-y!1"
             "g"
             "atan_value"))
           (rewrite "atan_neg_value" -1)
           (rewrite "atan_value_0" -1)
           (assert)
           (skolem -1 ("c"))
           (flatten)
           (expand "<=" -2)
           (split -2)
           (("1"
             (lemma "atan_inv_neg_value" ("nx" "c"))
             (("1" (replace -4 -1) (simplify -1) (inst + "1/c"))
              ("2" (assert))))
            ("2"
             (assert)
             (replace -1)
             (rewrite "atan_value_0")
             (assert))))
          ("2" (inst + "-1") (rewrite "atan_neg_value") (assert))
          ("3"
           (lemma "intermediate1[real]"
            ("a" "-1" "b" "0" "x" "y!1" "g" "atan_value"))
           (rewrite "atan_value_0")
           (rewrite "atan_neg_value")
           (assert)
           (skolem -1 ("c"))
           (flatten -1)
           (inst + "c"))))))
      ("2"
       (lemma "one_over_one_plus_t_sq_cont")
       (lemma "fundamental[real]"
        ("f" "atan_deriv_fn" "F" "atan_value" "a" "0"))
       (("1"
         (split -1)
         (("1" (flatten)) ("2" (propax))
          ("3" (expand "atan_value") (propax))))
        ("2" (assert) (expand "connected?") (propax))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "pi")
   (expand "atan")
   (lemma "atan_inv_value" ("px" "px!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "pi")
   (expand "atan")
   (lemma "atan_inv_neg_value" ("nx" "nx!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x"))
   (expand "atan")
   (expand "atan_value")
   (expand "atan_deriv_fn")
   (propax))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x" "y"))
   (lemma "atan_value_minus" ("x" "x" "y" "y"))
   (flatten -1)
   (expand "pi")
   (expand "atan")
   (replace -1)
   (replace -2)
   (assert))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "one_over_one_plus_t_sq_cont")
   (lemma "extensionality_postulate"
    ("f" "atan_deriv_fn" "g" "LAMBDA (x: real): 1 / (1 + x * x)"))
   (("1"
     (flatten -1)
     (hide -2)
     (split -1)
     (("1"
       (lemma "fundamental[real]"
        ("f" "atan_deriv_fn" "F" "atan" "a" "0"))
       (("1"
         (split -1)
         (("1" (replace -2 -1) (propax)) ("2" (propax))
          ("3" (expand "atan" 1) (expand "atan_value" 1) (propax))))
        ("2" (assert) (expand "connected?") (propax))))
      ("2" (expand "atan_deriv_fn" 1) (propax))))
    ("2"
     (skosimp*)
     (lemma "sq_pos" ("a" "x!1"))
     (expand "sq")
     (assert)
     (hide -3 1)
     (grind))))


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


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x"))
   (lemma "deriv_atan_fun")
   (flatten)
   (lemma "atan_0")
   (lemma "mean_value[nnreal]" ("a" "0"))
   (("1"
     (inst - "x" "_")
     (lemma "restrict2_derivable[nnreal,real]" ("f" "atan"))
     (("1"
       (lemma "restrict2_deriv[nnreal,real]" ("f" "atan"))
       (expand "restrict2")
       (replace -6 -1)
       (simplify -1)
       (lemma "extensionality"
        ("f"
         "LAMBDA (a: nnreal): 1 / (1 + a * a)"
         "g"
         "deriv[nnreal](LAMBDA (u: nnreal): atan(u))"))
       (("1"
         (simplify -1)
         (replace -2 -1)
         (hide -2 -6 -7)
         (lemma "identity_derivable_fun[nnreal]")
         (lemma "deriv_id_fun[nnreal]")
         (lemma "deriv_const_fun[nnreal]" ("b" "1"))
         (expand "I")
         (split 1)
         (("1"
           (lemma "prod_derivable_fun[nnreal]"
            ("f1" "LAMBDA (x: nnreal): x" "f2" "LAMBDA (x: nnreal): x"))
           (assert)
           (lemma "deriv_prod_fun[nnreal]"
            ("ff1"
             "LAMBDA (x: nnreal): x"
             "ff2"
             "LAMBDA (x: nnreal): x"))
           (replace -4 -1)
           (expand "*")
           (expand "+" -1)
           (lemma "sum_derivable_fun[nnreal]"
            ("f1"
             "LAMBDA (x: nnreal): 1"
             "f2"
             "LAMBDA (x: nnreal): x*x"))
           (lemma "const_derivable_fun[nnreal]" ("b" "1"))
           (assert)
           (lemma "deriv_sum_fun[nnreal]"
            ("ff1"
             "LAMBDA (x: nnreal): 1"
             "ff2"
             "LAMBDA (x: nnreal): x*x"))
           (replace -4 -1)
           (replace -6 -1)
           (expand "+")
           (lemma "div_derivable_fun[nnreal]"
            ("f"
             "LAMBDA (x: nnreal): x"
             "g"
             "LAMBDA (x: nnreal): 1 + x*x"))
           (assert)
           (expand "/" -1)
           (lemma "deriv_div_fun[nnreal]"
            ("ff"
             "LAMBDA (x: nnreal): x"
             "gg"
             "LAMBDA (x: nnreal): 1 + x*x"))
           (replace -3 -1)
           (replace -9 -1)
           (expand "/")
           (expand "-" -1)
           (expand "*" -1)
           (lemma "diff_derivable_fun[nnreal]"
            ("f1"
             "LAMBDA (u: nnreal): atan(u)"
             "f2"
             "LAMBDA (x: nnreal): x/(1+x*x)"))
           (assert)
           (lemma "deriv_diff_fun[nnreal]"
            ("ff1"
             "LAMBDA (u: nnreal): atan(u)"
             "ff2"
             "LAMBDA (x: nnreal): x/(1+x*x)"))
           (expand "-")
           (replace -3 -1)
           (replace -13 -1 rl)
           (simplify -1)
           (inst -15
            "LAMBDA (x_1: nnreal): atan(x_1) - x_1 / (1 + x_1 * x_1)")
           (assert)
           (skolem - "c")
           (expand "deriv" -1)
           (lemma "congruence"
            ("f"
             "(LAMBDA (x: nnreal):
                                            deriv(LAMBDA (x_1: nnreal): atan(x_1) - x_1 / (1 + x_1 * x_1), x))"
             "g"
             "(LAMBDA (x_1: nnreal):
                                             1 / (1 + x_1 * x_1) -
                                              (1 - x_1 * x_1) / (1 + 2 * (x_1 * x_1) + x_1 * x_1 * x_1 * x_1))"
             "x1"
             "c"
             "x2"
             "c"))
           (("1"
             (assert)
             (replace -1 -16)
             (replace -17 -16)
             (hide-all-but (-16 1))
             (flatten)
             (lemma "posreal_times_posreal_is_posreal"
              ("px" "c" "py" "c"))
             (("1"
               (lemma "posreal_times_posreal_is_posreal"
                ("px" "1+c*c" "py" "1+c*c"))
               (lemma "minus_div1"
                ("x"
                 "1"
                 "n0x"
                 "1+c*c"
                 "y"
                 "1-c*c"
                 "n0y"
                 "(1 + c * c) * (1 + c * c)"))
               (replace -1 -6)
               (lemma "div_cancel1"
                ("x"
                 "2*(c*c)/((1 + c * c) * (1 + c * c))"
                 "n0z"
                 "1+c*c"))
               (name "CC" "c*c")
               (replace -1)
               (name "CCP1" "1+CC")
               (replace -1)
               (rewrite "div_div2" -3)
               (case "1 * (CCP1 * CCP1) - (1 - CC) * CCP1 = CCP1 * 2*CC")
               (("1"
                 (replace -1 -10)
                 (replace -4 -10)
                 (lemma "posreal_div_posreal_is_posreal"
                  ("px" "2*CC" "py" "CCP1*CCP1"))
                 (("1"
                   (lemma "posreal_times_posreal_is_posreal"
                    ("px" "2*CC/(CCP1*CCP1)"))
                   (("1" (inst - "x") (replace -12 -1) (assert))
                    ("2" (propax))))
                  ("2" (assert))))
                ("2" (expand "CCP1" 1) (assert))))
              ("2" (assert))))
            ("2" (expand "derivable?" -2) (propax))))
          ("2"
           (lemma "diff_derivable_fun[nnreal]"
            ("f1"
             "LAMBDA (x: nnreal): x"
             "f2"
             "LAMBDA (u: nnreal): atan(u)"))
           (lemma "deriv_diff_fun[nnreal]"
            ("ff1"
             "LAMBDA (x: nnreal): x"
             "ff2"
             "LAMBDA (u: nnreal): atan(u)"))
           (("1"
             (expand "-" (-1 -2))
             (replace -4 -1)
             (replace -6 -1 rl)
             (simplify -1)
             (assert)
             (inst - "LAMBDA (x_1: nnreal): x_1 - atan(x_1)")
             (assert)
             (skolem -8 ("c"))
             (expand "deriv" -1)
             (replace -9 -8)
             (lemma "congruence"
              ("f"
               "(LAMBDA (x: nnreal): deriv(LAMBDA (x_1: nnreal): x_1 - atan(x_1), x))"
               "g"
               "(LAMBDA (x_1: nnreal): 1 - 1 / (1 + x_1 * x_1))"
               "x1"
               "c"
               "x2"
               "c"))
             (("1"
               (assert)
               (replace -1 -9)
               (hide -1 -2 -3 -4 -5 -6 -7 -8 -10)
               (flatten)
               (lemma "minus_div1"
                ("x" "1" "n0x" "1" "y" "1" "n0y" "1+c*c"))
               (case "1+c*c > 0")
               (("1"
                 (replace -2 -5)
                 (simplify -5)
                 (lemma "posreal_div_posreal_is_posreal"
                  ("px" "c*c" "py" "1+c*c"))
                 (("1"
                   (lemma "posreal_times_posreal_is_posreal"
                    ("px" "c*c/(1+c*c)"))
                   (("1" (inst -1 "x") (assert) (replace -7 -1) (assert))
                    ("2" (propax))))
                  ("2"
                   (lemma "posreal_times_posreal_is_posreal"
                    ("px" "c" "py" "c"))
                   (("1" (propax)) ("2" (assert))))))
                ("2"
                 (lemma "sq_pos" ("a" "c"))
                 (hide-all-but (-1 1))
                 (grind))))
              ("2" (assert) (expand "derivable?" -2) (propax))))
            ("2" (propax))))))
        ("2" (propax))))
      ("2" (hide 2) (skosimp*) (inst + "x!1"))))
    ("2" (assert) (expand "connected?") (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (rewrite "pi_value")
   (rewrite "atan_1")
   (lemma "atan_bnds" ("px" "1/5"))
   (lemma "atan_bnds" ("px" "1/239"))
   (flatten)
   (case-replace "1 / 239 / (1 + 1 / 239 * (1 / 239)) = 239/57122")
   (("1"
     (case-replace "1 / 5 / (1 + 1 / 5 * (1 / 5)) = 5/26")
     (("1"
       (hide -1 -2)
       (lemma "both_sides_times_pos_lt1"
        ("pz" "16" "x" "5/26" "y" "atan(1/5)"))
       (lemma "both_sides_times_pos_lt1"
        ("pz" "16" "y" "1/5" "x" "atan(1/5)"))
       (lemma "both_sides_times_neg_lt1"
        ("nz" "-4" "x" "1/239" "y" "atan(1/239)"))
       (lemma "both_sides_times_neg_lt1"
        ("nz" "-4" "y" "239/57122" "x" "atan(1/239)"))
       (assert))
      ("2" (assert))))
    ("2" (hide 2) (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "atanS")
   (skolem 1 ("n" "x"))
   (lemma "sq_le"
    ("nna"
     "abs(harmonic_poly_real(1 + 2 * n, 1, x))"
     "nnb"
     "(1 + x * x) ^ n * sqrt(1 + x * x)"))
   (("1"
     (replace -1 1 rl)
     (hide -1)
     (rewrite "sq_times")
     (lemma "sq_sqrt" ("x" "1+x*x"))
     (assert)
     (expand "sq" 1 2)
     (lemma "expt_plus" ("n0x" "1+x*x" "i" "1" "j" "n"))
     (("1"
       (rewrite "expt_x1" -1)
       (lemma "expt_plus" ("n0x" "1+x*x" "i" "n+1" "j" "n"))
       (hide -1 -2 -3)
       (case "FORALL (x:real): sq(abs(x)) = sq(x)")
       (("1"
         (inst - "harmonic_poly_real(1 + 2 * n, 1, x)")
         (hide -1)
         (lemma "harmonic_polynomial_modulus"
          ("pn" "2*n+1" "x" "1" "y" "x"))
         (name-replace "U" "sq(harmonic_poly_real(2 * n + 1, 1, x))")
         (name-replace "V" "harmonic_poly_imag(2 * n + 1, 1, x)")
         (lemma "sq_pos" ("a" "V"))
         (expand "sq")
         (assert)
         (case-replace
          "(1 + x * x) ^ n * (1 + x * x) ^ n +
                  (1 + x * x) ^ n * (1 + x * x) ^ n * x * x = (1 + x * x) ^ (1 + 2 * n)")
         (("1" (assert))
          ("2"
           (hide-all-but 1)
           (case "1+x*x>0")
           (("1"
             (lemma "expt_plus" ("n0x" "1+x*x" "i" "1" "j" "2*n"))
             (rewrite "expt_x1" -1)
             (lemma "expt_times" ("n0x" "1+x*x" "i" "n" "j" "2"))
             (expand "^" -1 3)
             (expand "expt")
             (expand "expt")
             (expand "expt")
             (assert))
            ("2"
             (assert)
             (hide 2)
             (lemma "trichotomy" ("x" "x"))
             (split)
             (("1"
               (lemma "posreal_times_posreal_is_posreal"
                ("px" "x" "py" "x"))
               (("1" (assert)) ("2" (assert))))
              ("2" (assert))
              ("3"
               (lemma "negreal_times_negreal_is_posreal"
                ("nx" "x" "ny" "x"))
               (("1" (assert)) ("2" (assert))))))))))
        ("2"
         (hide 2)
         (skosimp*)
         (lemma "trichotomy" ("x" "x!1"))
         (split -1)
         (("1" (grind)) ("2" (grind)) ("3" (grind))))))
      ("2" (lemma "sq_pos" ("a" "x")) (hide -2 2) (grind))))
    ("2"
     (lemma "expt_pos" ("px" "1+x*x" "i" "n"))
     (typepred "sqrt(1 + x * x)")
     (lemma "both_sides_times_pos_le1"
      ("x" "0" "pz" "(1 + x * x) ^ n" "y" "sqrt(1 + x * x)"))
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "extensionality_postulate"
    ("f" "(-1) ^ n * factorial(2 * n) * atanS(n)" "g" "atanN(n)"))
   (replace -1 1 rl)
   (hide -1)
   (skolem 1 ("x"))
   (expand "atanS")
   (expand "atanN")
   (expand "*")
   (expand "harmonic_poly_real")
   (expand "polynomial")
   (expand "sigma" 1 1)
   (lemma "sigma_scal"
    ("low"
     "0"
     "high"
     "2*n"
     "a"
     "factorial(2 * n) * (-1) ^ n"
     "F"
     "             LAMBDA (i: nat):
                    IF i > 1 + 2 * n OR odd?(i) THEN 0
                    ELSE C(1 + 2 * n, i) * (-1) ^ (i / 2) *
                          (IF i = 0 THEN 1 ^ (1 + 2 * n)
                           ELSIF i = 1 + 2 * n THEN x ^ (1 + 2 * n)
                           ELSE (1 ^ (1 - i + 2 * n)) * x ^ i
                           ENDIF)
                    ENDIF"))
   (("1"
     (replace -1 1 rl)
     (hide -1)
     (lemma "sigma_eq[nat]"
      ("low"
       "0"
       "high"
       "2*n"
       "F"
       "LAMBDA (i_1: nat):
                     factorial(2 * n) * (-1) ^ n *
                      (LAMBDA (i: nat):
                         IF i > 1 + 2 * n OR odd?(i) THEN 0
                         ELSE C(1 + 2 * n, i) * (-1) ^ (i / 2) *
                               (IF i = 0 THEN 1 ^ (1 + 2 * n)
                                ELSIF i = 1 + 2 * n THEN x ^ (1 + 2 * n)
                                ELSE (1 ^ (1 - i + 2 * n)) * x ^ i
                                ENDIF)
                         ENDIF)
                          (i_1)"
       "G"
       "             LAMBDA (i: nat):
                      atanF(n)(i) * (IF i = 0 THEN 1 ELSE x ^ i ENDIF)"))
     (("1"
       (split -1)
       (("1" (propax))
        ("2"
         (hide 2)
         (skolem 1 ("i"))
         (typepred "i")
         (expand "atanF")
         (case "odd?(i)")
         (("1" (assert) (lift-if) (assert))
          ("2"
           (assert)
           (rewrite "expt_1i")
           (rewrite "expt_1i")
           (lemma "expt_plus" ("n0x" "-1" "i" "i/2" "j" "n"))
           (("1"
             (replace -1 2)
             (case "i=0")
             (("1" (assert)) ("2" (assert))))
            ("2"
             (hide 3)
             (case "even?(i)")
             (("1"
               (expand "even?")
               (skosimp*)
               (replace -1)
               (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
               (replace -1)
               (assert))
              ("2" (rewrite "even_or_odd"))))))))))
      ("2"
       (hide 2)
       (skosimp*)
       (case "even?(i!1)")
       (("1"
         (expand "even?")
         (skosimp*)
         (replace -1)
         (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
         (replace -1)
         (assert))
        ("2" (rewrite "even_or_odd") (assert))))
      ("3" (hide 2) (grind))))
    ("2"
     (skosimp*)
     (hide 4)
     (case "even?(i!1)")
     (("1"
       (expand "even?")
       (skosimp*)
       (replace -1)
       (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
       (replace -1)
       (assert))
      ("2" (rewrite "even_or_odd"))))
    ("3" (hide 2) (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("m" "n"))
   (expand "atanN")
   (expand "atanD")
   (lemma "derivable_n_times_polynomial"
    ("b" "atanF(n)" "m" "2*n" "n" "m"))
   (replace -1)
   (hide -1)
   (lemma "extensionality"
    ("f"
     "LAMBDA (x: real): (1 + x * x) ^ (1 + 2 * n)"
     "g"
     "LAMBDA (x: real): (LAMBDA (z:real): (1 + z) ^ (1 + 2 * n))(x^2)"))
   (split -1)
   (("1"
     (replace -1)
     (lemma "power_polynomial" ("pn" "1+2*n"))
     (replace -1)
     (hide -1 -2)
     (case "(LAMBDA (x: real): polynomial(power_fs(1 + 2 * n), 1 + 2 * n)(x ^ 2)) = polynomial((LAMBDA (i:nat): IF even?(i) THEN power_fs(2*n+1)(i/2) ELSE 0 ENDIF),2+4*n)")
     (("1"
       (replace -1 1)
       (lemma "derivable_n_times_polynomial"
        ("b"
         "(LAMBDA (i: nat):
                                            IF even?(i)
                                              THEN power_fs(2 * n + 1)(i / 2)
                                            ELSE 0
                                            ENDIF)"
         "m"
         "2 + 4 * n"
         "n"
         "m"))
       (("1" (propax))
        ("2"
         (hide -2 2)
         (skosimp*)
         (assert)
         (hide -2)
         (expand "even?")
         (propax))))
      ("2"
       (hide 2)
       (lemma "extensionality"
        ("f"
         "(LAMBDA (x: real): polynomial(power_fs(1 + 2 * n), 1 + 2 * n)(x ^ 2))"
         "g"
         "       polynomial((LAMBDA (i: nat):
                           IF even?(i) THEN power_fs(2 * n + 1)(i / 2)
                           ELSE 0
                           ENDIF),
                        2 + 4 * n)"))
       (("1"
         (split -1)
         (("1" (propax))
          ("2"
           (hide 2)
           (skolem 1 ("x"))
           (lemma "even_polynomial"
            ("n"
             "1+2*n"
             "x"
             "x"
             "a"
             "(LAMBDA (i: nat):
                               IF even?(i) THEN power_fs(2 * n + 1)(i / 2)
                               ELSE 0
                               ENDIF)"))
           (("1"
             (split -1)
             (("1"
               (replace -1 1)
               (hide -1)
               (lemma "extensionality"
                ("f"
                 "power_fs(1 + 2 * n)"
                 "g"
                 "LAMBDA (i_1: nat):
                                  (LAMBDA (i: nat):
                                     IF even?(i) THEN power_fs(2 * n + 1)(i / 2)
                                     ELSE 0
                                     ENDIF)
                                      (2 * i_1)"))
               (("1"
                 (split -1)
                 (("1" (replace -1 1 rl) (propax))
                  ("2"
                   (hide 2)
                   (skolem 1 ("j"))
                   (lemma "div_cancel1" ("x" "j" "n0z" "2"))
                   (replace -1)
                   (case "even?(2*j)")
                   (("1" (assert))
                    ("2" (expand "even?") (inst + "j"))))))
                ("2" (hide 2) (skosimp*) (assert))))
              ("2"
               (hide 2)
               (expand "even_fs?")
               (skolem 1 ("i"))
               (flatten)
               (assert)
               (rewrite "even_or_odd"))))
            ("2"
             (hide 2)
             (skosimp*)
             (assert)
             (expand "even?")
             (propax))))))
        ("2" (hide 2) (skosimp*) (assert) (expand "even?") (propax))))
      ("3" (hide 2) (skosimp*) (assert) (expand "even?") (propax))))
    ("2"
     (hide 2)
     (skolem 1 ("x"))
     (expand "^" 1 2)
     (expand "expt")
     (expand "expt")
     (expand "expt")
     (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "atan_taylors_prep3")
   (inst?)
   (inst - "1")
   (flatten)
   (expand "derivable_n_times?")
   (flatten))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (expand "atanN")
   (lemma "deriv_polynomial" ("a" "atanF(n)" "n" "2*n"))
   (expand "const_fun")
   (case "n=0")
   (("1" (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "atan_taylors_prep3" ("m" "1"))
   (inst-cp - "0")
   (inst - "n")
   (flatten)
   (hide -1 -3)
   (expand "atanD")
   (expand "derivable_n_times?")
   (flatten)
   (hide -2 -4)
   (expand "^" -2)
   (expand "expt" -2)
   (expand "expt" -2)
   (lemma "identity_derivable_fun[real]")
   (lemma "deriv_id_fun[real]")
   (lemma "const_derivable_fun[real]" ("b" "1"))
   (lemma "deriv_const_fun[real]" ("b" "1"))
   (expand "I")
   (expand "const_fun")
   (lemma "prod_derivable_fun[real]"
    ("f1" "LAMBDA (x: real): x" "f2" "LAMBDA (x: real): x"))
   (assert)
   (lemma "deriv_prod_fun[real]"
    ("ff1" "LAMBDA (x: real): x" "ff2" "LAMBDA (x: real): x"))
   (replace -5)
   (expand "*")
   (expand "+")
   (lemma "deriv_sum_fun[real]"
    ("ff1" "LAMBDA (x: real): 1" "ff2" "LAMBDA (x_1: real): x_1 * x_1"))
   (("1"
     (expand "+")
     (replace -4)
     (replace -2)
     (simplify -1)
     (lemma "deriv_exp_fun[real]"
      ("f" "LAMBDA (x: real): (1 + x * x)" "n" "1+2*n"))
     (assert)
     (flatten -1)
     (expand "^" -2)
     (replace -3 -2)
     (expand "*" -2)
     (propax))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "nderiv_polynomial" ("n" "2" "m" "2*n" "b" "atanF(n)"))
   (expand "atanN")
   (expand "const_fun")
   (expand "nderiv" -1)
   (expand "nderiv" -1)
   (expand "nderiv" -1)
   (case "n=0")
   (("1" (replace -1) (assert))
    ("2"
     (assert)
     (replace -1 2)
     (hide -1)
     (lemma "extensionality"
      ("f"
       "LAMBDA (i: nat):
                       atanF(n)(2 + i) * factorial(2) * C(2 + i, 2)"
       "g"
       "LAMBDA (i: nat):
                        2 * atanF(n)(2 + i) + 3 * (i * atanF(n)(2 + i)) +
                         i * i * atanF(n)(2 + i)"))
     (split -1)
     (("1" (replace -1 2 rl) (propax))
      ("2"
       (hide 3)
       (skolem 1 ("i"))
       (name-replace "K1" "atanF(n)(2+i)")
       (case "i=0")
       (("1" (replace -1) (rewrite "C_n") (grind))
        ("2"
         (rewrite "C_2")
         (expand "factorial")
         (expand "factorial")
         (expand "factorial")
         (lemma "div_cancel1"
          ("x" "2 * K1 + K1 * i * i + 3 * (i * K1)" "n0z" "2"))
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("pn" "ff" "gg"))
   (flatten)
   (lemma "deriv_exp_fun[real]" ("f" "gg" "n" "pn"))
   (assert)
   (flatten)
   (lemma "div_derivable_fun[real]" ("f" "ff" "g" "gg^pn"))
   (("1"
     (assert)
     (lemma "deriv_div_fun[real]" ("ff" "ff" "gg" "gg^pn"))
     (replace -1 1)
     (replace -4 1)
     (name-replace "F" "deriv(ff)")
     (name-replace "G" "deriv(gg)")
     (lemma "extensionality"
      ("f"
       "(F * gg ^ pn - pn * gg ^ (pn - 1) * G * ff) / (gg ^ pn * gg ^ pn)"
       "g"
       "(F * gg - pn * ff * G) / (gg ^ (1 + pn))"))
     (split -1)
     (("1" (propax))
      ("2"
       (hide-all-but 1)
       (skolem 1 ("x"))
       (expand "/")
       (expand "*")
       (expand "-")
       (expand "^")
       (lemma "cross_mult"
        ("x"
         "(F(x) * gg(x) ^ pn - G(x) * ff(x) * gg(x) ^ (pn - 1) * pn)"
         "n0x"
         "(gg(x) ^ pn * gg(x) ^ pn)"
         "y"
         "(F(x) * gg(x) - G(x) * ff(x) * pn)"
         "n0y"
         "gg(x) ^ (1 + pn)"))
       (replace -1 1)
       (hide -1)
       (typepred "gg(x)")
       (lemma "expt_plus" ("n0x" "gg(x)" "i" "1" "j" "pn"))
       (rewrite "expt_x1")
       (replace -1)
       (assert)
       (lemma "expt_plus" ("n0x" "gg(x)" "i" "1" "j" "pn-1"))
       (rewrite "expt_x1")
       (replace -1)
       (assert))))
    ("2"
     (hide-all-but 1)
     (skolem 1 ("x"))
     (expand "^")
     (typepred "gg(x)")
     (lemma "expt_nonzero" ("n0x" "gg(x)" "i" "1+pn"))
     (hide-all-but 1)
     (expand "^")
     (lemma "expt_nonzero" ("n0x" "gg(x)" "i" "1+pn"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "atan_taylors_prep3" ("n" "n" "m" "2"))
   (expand "derivable_n_times?")
   (expand "derivable_n_times?")
   (expand "derivable_n_times?")
   (flatten)
   (lemma "identity_derivable_fun[real]")
   (lemma "const_derivable_fun[real]" ("b" "1"))
   (lemma "deriv_const_fun[real]" ("b" "1"))
   (lemma "deriv_id_fun[real]")
   (expand "I")
   (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 "*")
   (expand "+" -1)
   (replace -3 -1)
   (simplify -1)
   (lemma "sum_derivable_fun[real]"
    ("f1" "LAMBDA (x: real): 1" "f2" "LAMBDA (x_1: real): x_1 * x_1"))
   (assert)
   (expand "+")
   (lemma "deriv_sum_fun[real]"
    ("ff1" "LAMBDA (x: real): 1" "ff2" "LAMBDA (x_1: real): x_1 * x_1"))
   (replace -6 -1)
   (replace -3)
   (expand "+")
   (lemma "atan_taylors_prep7"
    ("f" "atanN(n)" "g" "LAMBDA (x:real):1+x*x" "pn" "2*n+1"))
   (("1"
     (assert)
     (flatten)
     (expand "atanD")
     (replace -3 -2)
     (expand "^" -2)
     (replace -2)
     (lemma "atan_taylors_prep7"
      ("f"
       "((deriv(atanN(n)) * (LAMBDA (x: real): 1 + x * x)) - (1 + 2 * n) * atanN(n) * (LAMBDA (x_1: real): 2 * x_1))"
       "g"
       "LAMBDA (t: real): (1 + t * t)"
       "pn"
       "2 + 2 * n"))
     (assert)
     (lemma "prod_derivable_fun[real]"
      ("f1" "deriv(atanN(n))" "f2" "LAMBDA (x: real): 1 + x * x"))
     (lemma "prod_derivable_fun[real]"
      ("f1" "atanN(n)" "f2" "LAMBDA (x:real):x"))
     (assert)
     (lemma "scal_derivable_fun[real]"
      ("f" "atanN(n) * (LAMBDA (x: real): x)" "b" "2+4*n"))
     (assert)
     (lemma "diff_derivable_fun[real]"
      ("f2"
       "(2 + 4 * n) * atanN(n) * (LAMBDA (x: real): x)"
       "f1"
       "deriv(atanN(n)) * (LAMBDA (x: real): 1 + x * x)"))
     (assert)
     (expand "*")
     (assert)
     (expand "-")
     (assert)
     (flatten -5)
     (replace -9)
     (simplify -6)
     (lemma "deriv_prod_fun[real]"
      ("ff1" "LAMBDA (x:real): x*x" "ff2" "deriv(atanN(n))"))
     (expand "*")
     (expand "+")
     (replace -12 -1)
     (simplify -1)
     (lemma "deriv_prod_fun[real]"
      ("ff1" "LAMBDA (x:real):x" "ff2" "atanN(n)"))
     (replace -15 -1)
     (expand "*")
     (expand "+")
     (lemma "deriv_scal_fun[real]"
      ("b" "4*n+2" "ff" "LAMBDA (x_1: real): x_1 * atanN(n)(x_1)"))
     (replace -2 -1)
     (expand "*" -1)
     (lemma "deriv_diff_fun[real]"
      ("ff1"
       "deriv(atanN(n))"
       "ff2"
       "LAMBDA (x:real): 2 * (x * atanN(n)(x)) + 4 * (x * atanN(n)(x) * n)"))
     (replace -2 -1)
     (expand "-" -1)
     (lemma "deriv_sum_fun[real]"
      ("ff1"
       "LAMBDA (x_1: real):
                                    deriv(atanN(n))(x_1) - 2 * (x_1 * atanN(n)(x_1)) -
                                     4 * (x_1 * atanN(n)(x_1) * n)"
       "ff2"
       "LAMBDA (x: real):x * x * deriv(atanN(n))(x)"))
     (("1"
       (replace -2 -1)
       (replace -5 -1)
       (expand "+" -1)
       (replace -1 -11)
       (simplify -11)
       (expand "^" -11)
       (replace -11 1)
       (hide-all-but (-22 -23 1))
       (lemma "extensionality"
        ("f"
         "LAMBDA (x_1: real):
                                        deriv(deriv(atanN(n)))(x_1) +
                                         deriv(deriv(atanN(n)))(x_1) * (x_1 * x_1)
                                         - 2 * atanN(n)(x_1)
                                         - 4 * (x_1 * deriv(atanN(n))(x_1))
                                         - 4 * (atanN(n)(x_1) * n)
                                         - 4 * (x_1 * x_1 * x_1 * deriv(atanN(n))(x_1))
                                         - 8 * (x_1 * deriv(atanN(n))(x_1) * n)
                                         - 8 * (x_1 * x_1 * x_1 * deriv(atanN(n))(x_1) * n)
                                         + 6 * (x_1 * x_1 * atanN(n)(x_1))
                                         + x_1 * x_1 * deriv(deriv(atanN(n)))(x_1)
                                         + 20 * (x_1 * x_1 * atanN(n)(x_1) * n)
                                         + x_1 * x_1 * x_1 * x_1 * deriv(deriv(atanN(n)))(x_1)
                                         + 16 * (x_1 * x_1 * atanN(n)(x_1) * n * n)"
         "g"
         "atanN(1+n)"))
       (split -1)
       (("1" (replace -1) (propax))
        ("2"
         (hide 2)
         (skolem 1 ("x"))
         (rewrite "atan_taylors_prep6")
         (rewrite "atan_taylors_prep4")
         (expand "atanN")
         (case "n=0")
         (("1"
           (replace -1)
           (expand "const_fun")
           (hide -2 -3 -1)
           (expand "polynomial")
           (expand "sigma")
           (expand "sigma")
           (expand "sigma")
           (rewrite "expt_x1")
           (rewrite "expt_x2")
           (expand "atanF")
           (rewrite "expt_x0")
           (rewrite "C_0")
           (rewrite "C_0")
           (rewrite "expt_x2")
           (rewrite "expt_x1")
           (rewrite "C_n_1")
           (case "odd?(0)")
           (("1" (expand "odd?") (propax)) ("2" (assert) (grind))))
          ("2"
           (hide -1 -2)
           (assert)
           (name "FS1"
                 "LAMBDA (i: nat):
                                                                               2 * atanF(n)(2 + i) + 3 * (i * atanF(n)(2 + i)) +
                                                                                i * i * atanF(n)(2 + i)")
           (replace -1)
           (name "FS2"
                 "LAMBDA (i: nat): atanF(n)(1 + i) + i * atanF(n)(1 + i)")
           (replace -1)
           (case "FORALL (a:sequence[real],n:nat,pn:posnat): polynomial(a,n)(x) * x^pn = polynomial(LAMBDA (i:nat): IF i < pn THEN 0 ELSE a(i-pn) ENDIF,n+pn)(x)")
           (("1"
             (inst-cp - "FS1" "2*n-2" "2")
             (inst-cp - "FS2" "2*n-1" "3")
             (inst-cp - "FS2" "2*n-1" "1")
             (inst-cp - "atanF(n)" "2*n" "2")
             (inst - "FS1" "2*n-2" "4")
             (rewrite "expt_x1")
             (rewrite "expt_x2")
             (rewrite "expt_x3")
             (rewrite "expt_x4")
             (case "FORALL (y:real,a:sequence[real],n:nat): y * polynomial(a,n)(x) = polynomial(const_fun(y)*a,n)(x)")
             (("1"
               (expand "const_fun" -1)
               (name "FS3"
                     "LAMBDA (i: nat): IF i < 2 THEN 0 ELSE FS1(i - 2) ENDIF")
               (("1"
                 (replace -1)
                 (name "FS4"
                       "LAMBDA (i: nat): IF i < 3 THEN 0 ELSE FS2(i - 3) ENDIF")
                 (("1"
                   (replace -1)
                   (simplify -7)
                   (name "FS5"
                         "LAMBDA (i: nat): IF i < 1 THEN 0 ELSE FS2(i - 1) ENDIF")
                   (("1"
                     (replace -1)
                     (name "FS6"
                           "LAMBDA (i: nat): IF i < 2 THEN 0 ELSE atanF(n)(i - 2) ENDIF")
                     (replace -1)
                     (name "FS7"
                           "LAMBDA (i: nat): IF i < 4 THEN 0 ELSE FS1(i - 4) ENDIF")
                     (("1"
                       (replace -1)
                       (simplify -7)
                       (replace -7 2)
                       (inst-cp - "16*n*n" "FS6" "2*n+2")
                       (replace -9 -7 rl)
                       (replace -7 2)
                       (hide -7)
                       (inst-cp - "20*n" "FS6" "2*n+2")
                       (replace -9 -7 rl)
                       (replace -7 2)
                       (replace -12 2)
                       (hide -7)
                       (inst-cp - "6" "FS6" "2*n+2")
                       (replace -9 -7 rl)
                       (replace -7 2)
                       (hide -7)
                       (inst-cp - "8*n" "FS4" "2+2*n")
                       (replace -11 -7 rl)
                       (replace -7 2)
                       (hide -7)
                       (inst-cp - "8*n" "FS5" "2*n")
                       (replace -10 -7 rl)
                       (replace -7 2)
                       (hide -7)
                       (inst-cp - "4" "FS5" "2*n")
                       (replace -10 -7 rl)
                       (replace -7 2)
                       (hide -7)
                       (inst-cp - "4" "FS4" "2+2*n")
                       (replace -11 -7 rl)
                       (replace -7 2)
                       (hide -7)
                       (inst-cp - "4*n" "atanF(n)" "2*n")
                       (replace -7)
                       (inst - "2" "atanF(n)" "2*n")
                       (replace -6 2)
                       (hide -6 -7 -8 -9 -10 -11 -12)
                       (simplify 2)
                       (lemma "extend_polynomial"
                        ("a" "FS1" "n" "2*n-2" "m" "4"))
                       (split -1)
                       (("1"
                         (simplify -1)
                         (replaces -1)
                         (lemma "extend_polynomial"
                          ("a" "FS3" "n" "2*n" "m" "2"))
                         (split -1)
                         (("1"
                           (replaces -1)
                           (lemma "extend_polynomial"
                            ("a"
                             "(LAMBDA (x: nat): 2) * atanF(n)"
                             "n"
                             "2*n"
                             "m"
                             "2"))
                           (split -1)
                           (("1"
                             (replaces -1)
                             (lemma "extend_polynomial"
                              ("a"
                               "(LAMBDA (x: nat): 4*n) * atanF(n)"
                               "n"
                               "2*n"
                               "m"
                               "2"))
                             (split -1)
                             (("1"
                               (replaces -1)
                               (lemma "extend_polynomial"
                                ("a"
                                 "(LAMBDA (x: nat): 4) * FS5"
                                 "n"
                                 "2*n"
                                 "m"
                                 "2"))
                               (split -1)
                               (("1"
                                 (replaces -1)
                                 (lemma
                                  "extend_polynomial"
                                  ("a"
                                   "(LAMBDA (x: nat): 8*n) * FS5"
                                   "n"
                                   "2*n"
                                   "m"
                                   "2"))
                                 (split -1)
                                 (("1"
                                   (replaces -1)
                                   (assert)
                                   (grind :defs nil :theories "poly_rew")
                                   (case-replace
                                    "2 * FS3 +
                                                                                        ((LAMBDA (x: nat): 20 * n) * FS6 +
                                                                                          ((LAMBDA (x: nat): 6) * FS6 +
                                                                                            (LAMBDA (x: nat): 16 * (n * n)) * FS6)
                                                                                          + FS1)
                                                                                        + FS7
                                                                                        - (LAMBDA (x: nat): 2) * atanF(n)
                                                                                        - (LAMBDA (x: nat): 4) * FS4
                                                                                        - (LAMBDA (x: nat): 4) * FS5
                                                                                        - (LAMBDA (x: nat): 4 * n) * atanF(n)
                                                                                        - (LAMBDA (x: nat): 8 * n) * FS4
                                                                                        - (LAMBDA (x: nat): 8 * n) * FS5 = atanF(1 + n)")
                                   (hide 3)
                                   (decompose-equality 1)
                                   (expand "+" 1)
                                   (expand "-" 1)
                                   (expand "FS7" 1)
                                   (expand "FS6" 1)
                                   (expand "FS5" 1)
                                   (expand "*" 1)
                                   (expand "FS4" 1)
                                   (hide-all-but (1 2))
                                   (expand "FS3")
                                   (expand "FS2")
                                   (expand "FS1")
                                   (case "x!1=0")
                                   (("1"
                                     (replace -1)
                                     (assert)
                                     (expand "atanF")
                                     (rewrite "C_0")
                                     (rewrite "C_0")
                                     (rewrite "C_2")
                                     (case "odd?(0)")
                                     (("1"
                                       (case "odd?(2)")
                                       (("1" (assert))
                                        ("2"
                                         (assert)
                                         (expand "odd?")
                                         (propax))))
                                      ("2"
                                       (assert)
                                       (case "NOT odd?(2)")
                                       (("1"
                                         (assert)
                                         (lemma
                                          "expt_plus"
                                          ("n0x" "-1" "i" "1" "j" "n"))
                                         (rewrite "expt_x1")
                                         (replace -1)
                                         (hide -1)
                                         (expand "factorial" 3 4)
                                         (expand "factorial" 3 4)
                                         (expand "factorial" 3 2)
                                         (grind-reals))
                                        ("2"
                                         (expand "odd?")
                                         (propax))))))
                                    ("2"
                                     (assert)
                                     (case "x!1=1")
                                     (("1"
                                       (assert)
                                       (expand "atanF")
                                       (propax))
                                      ("2"
                                       (case "x!1=2")
                                       (("1"
                                         (assert)
                                         (expand "atanF")
                                         (replace -1)
                                         (case "odd?(2)")
                                         (("1" (expand "odd?") (propax))
                                          ("2"
                                           (assert)
                                           (case "odd?(0)")
                                           (("1"
                                             (expand "odd?")
                                             (propax))
                                            ("2"
                                             (case "odd?(4)")
                                             (("1"
                                               (expand "odd?")
                                               (propax))
                                              ("2"
                                               (assert)
                                               (rewrite "C_0")
                                               (case "n=1")
                                               (("1"
                                                 (replace -1)
                                                 (assert)
                                                 (eval-formula 6))
                                                ("2"
                                                 (assert)
                                                 (lemma
                                                  "expt_plus"
                                                  ("n0x" "-1" "i" "n"))
                                                 (inst-cp - "1")
                                                 (rewrite "expt_x1" -2)
                                                 (replace -2)
                                                 (inst - "2")
                                                 (rewrite "expt_x2" -1)
                                                 (replace -1)
                                                 (expand "factorial" 7 7)
                                                 (expand "factorial" 7 7)
                                                 (expand "factorial" 7 8)
                                                 (rewrite "C_2")
                                                 (rewrite "C_2")
                                                 (name-replace
                                                  "K1"
                                                  "(-1)^n")
                                                 (lemma
                                                  "div_cancel1"
                                                  ("x"
                                                   "2*(n*n)+n"
                                                   "n0z"
                                                   "2"))
                                                 (replace -1)
                                                 (lemma
                                                  "div_cancel1"
                                                  ("x"
                                                   "3+5*n+2*(n*n)"
                                                   "n0z"
                                                   "2"))
                                                 (replace -1)
                                                 (name "K2" "C(1+2*n,4)")
                                                 (replace -1)
                                                 (simplify 7)
                                                 (name-replace
                                                  "K3"
                                                  "factorial(2 * n) * K1")
                                                 (expand "C" -1)
                                                 (case-replace
                                                  "factorial(4)=24")
                                                 (("1"
                                                   (hide -1)
                                                   (case-replace
                                                    "factorial(1+2*n) = (1+2*n)*(2*n)*(2*n-1)*(2*n-2)*factorial(2*n-3)")
                                                   (("1"
                                                     (hide -1)
                                                     (assert))
                                                    ("2"
                                                     (hide-all-but 1)
                                                     (grind))))
                                                  ("2"
                                                   (eval-formula))))))))))))
                                        ("2"
                                         (case "x!1=3")
                                         (("1"
                                           (assert)
                                           (expand "atanF")
                                           (replace -1)
                                           (case "odd?(5)")
                                           (("1" (assert))
                                            ("2"
                                             (expand "odd?" 1)
                                             (inst + "2")
                                             (assert))))
                                          ("2"
                                           (assert)
                                           (case "x!1>=4")
                                           (("1"
                                             (hide 1 2 3 4)
                                             (expand "atanF")
                                             (case "odd?(x!1)")
                                             (("1"
                                               (assert)
                                               (case
                                                "odd?(x!1+2) AND odd?(x!1-2)")
                                               (("1"
                                                 (flatten -1)
                                                 (assert))
                                                ("2"
                                                 (hide 2 3)
                                                 (expand "odd?")
                                                 (skosimp*)
                                                 (split 1)
                                                 (("1"
                                                   (inst + "j!1+1")
                                                   (assert))
                                                  ("2"
                                                   (inst + "j!1-1")
                                                   (assert))))))
                                              ("2"
                                               (case "odd?(x!1+2)")
                                               (("1"
                                                 (hide 2 3)
                                                 (expand "odd?")
                                                 (skosimp*)
                                                 (inst + "j!1-1")
                                                 (assert))
                                                ("2"
                                                 (case "odd?(x!1-2)")
                                                 (("1"
                                                   (hide 3 4)
                                                   (hide -2 1)
                                                   (expand "odd?")
                                                   (skosimp*)
                                                   (inst + "j!1+1")
                                                   (assert))
                                                  ("2"
                                                   (assert)
                                                   (case "x!1>2+2*n")
                                                   (("1" (assert))
                                                    ("2"
                                                     (case "x!1= 2+2*n")
                                                     (("1"
                                                       (replace -1)
                                                       (assert)
                                                       (rewrite "C_n_1")
                                                       (rewrite "C_n_1")
                                                       (lemma
                                                        "div_cancel1"
                                                        ("x"
                                                         "n"
                                                         "n0z"
                                                         "2"))
                                                       (replace -1)
                                                       (lemma
                                                        "expt_plus"
                                                        ("n0x"
                                                         "-1"
                                                         "i"
                                                         "2"
                                                         "j"
                                                         "n+n"))
                                                       (rewrite
                                                        "expt_x2"
                                                        -1)
                                                       (replace -1 5)
                                                       (expand
                                                        "factorial"
                                                        5
                                                        4)
                                                       (expand
                                                        "factorial"
                                                        5
                                                        5)
                                                       (expand
                                                        "factorial"
                                                        5
                                                        4)
                                                       (expand
                                                        "factorial"
                                                        5
                                                        3)
                                                       (propax))
                                                      ("2"
                                                       (case
                                                        "x!1= 1+2*n")
                                                       (("1"
                                                         (hide 6)
                                                         (replace -1)
                                                         (expand
                                                          "odd?"
                                                          5)
                                                         (inst + "n"))
                                                        ("2"
                                                         (case "x!1=2*n")
                                                         (("1"
                                                           (replace -1)
                                                           (assert)
                                                           (lemma
                                                            "div_cancel1"
                                                            ("x"
                                                             "n"
                                                             "n0z"
                                                             "2"))
                                                           (replace -1)
                                                           (lemma
                                                            "expt_plus"
                                                            ("n0x"
                                                             "-1"
                                                             "i"
                                                             "1"
                                                             "j"
                                                             "n+n"))
                                                           (rewrite
                                                            "expt_x1")
                                                           (replace -1)
                                                           (lemma
                                                            "expt_plus"
                                                            ("n0x"
                                                             "-1"
                                                             "i"
                                                             "-1"
                                                             "j"
                                                             "n+n"))
                                                           (lemma
                                                            "not_even_m1_pow"
                                                            ("i" "-1"))
                                                           (split -1)
                                                           (("1"
                                                             (replace -1)
                                                             (replace -2)
                                                             (name-replace
                                                              "K10"
                                                              "(-1) ^ (n + n)")
                                                             (hide
                                                              -1
                                                              -2
                                                              -3
                                                              -4)
                                                             (rewrite
                                                              "C_n_1")
                                                             (expand
                                                              "factorial"
                                                              7
                                                              7)
                                                             (expand
                                                              "factorial"
                                                              7
                                                              8)
                                                             (expand
                                                              "factorial"
                                                              7
                                                              10)
                                                             (name-replace
                                                              "K11"
                                                              "factorial(2*n)")
                                                             (name
                                                              "K12"
                                                              "C(1 + 2 * n, 2 * n - 2)")
                                                             (replace -1)
                                                             (name
                                                              "K13"
                                                              "C(3 + 2 * n, 2 * n)")
                                                             (replace -1)
                                                             (expand "C")
                                                             (case-replace
                                                              "factorial(3)=6")
                                                             (("1"
                                                               (hide -1)
                                                               (case-replace
                                                                "factorial(3+2*n) = (3+2*n)*(2+2*n)*(1+2*n)*factorial(2*n)")
                                                               (("1"
                                                                 (hide
                                                                  -1)
                                                                 (case-replace
                                                                  "factorial(1+2*n)=(1+2*n)*(2*n)*(2*n-1)*factorial(2*n-2)")
                                                                 (("1"
                                                                   (hide
                                                                    -1)
                                                                   (assert))
                                                                  ("2"
                                                                   (hide-all-but
                                                                    1)
                                                                   (grind))))
                                                                ("2"
                                                                 (hide-all-but
                                                                  1)
                                                                 (grind))))
                                                              ("2"
                                                               (eval-formula))))
                                                            ("2"
                                                             (hide-all-but
                                                              -1)
                                                             (rewrite
                                                              "even_or_odd"))))
                                                          ("2"
                                                           (case
                                                            "x!1=2*n-1")
                                                           (("1"
                                                             (hide 8 9)
                                                             (replace
                                                              -1
                                                              7)
                                                             (expand
                                                              "odd?"
                                                              7)
                                                             (inst
                                                              +
                                                              "n-1")
                                                             (assert))
                                                            ("2"
                                                             (case
                                                              "x!1 <= 2*n-2")
                                                             (("1"
                                                               (assert)
                                                               (rewrite
                                                                "odd_iff_not_even"
                                                                8)
                                                               (rewrite
                                                                "odd_iff_not_even")
                                                               (rewrite
                                                                "odd_iff_not_even")
                                                               (hide
                                                                1
                                                                2
                                                                3
                                                                4
                                                                5)
                                                               (hide
                                                                -2
                                                                -3)
                                                               (expand
                                                                "even?"
                                                                -2)
                                                               (skosimp*)
                                                               (lemma
                                                                "div_cancel1"
                                                                ("x"
                                                                 "j!1"
                                                                 "n0z"
                                                                 "2"))
                                                               (lemma
                                                                "times_div1"
                                                                ("x"
                                                                 "2"
                                                                 "y"
                                                                 "j!1"
                                                                 "n0z"
                                                                 "2"))
                                                               (replace
                                                                -4
                                                                -1
                                                                rl)
                                                               (replace
                                                                -2
                                                                -1)
                                                               (replace
                                                                -1
                                                                1
                                                                rl)
                                                               (lemma
                                                                "expt_plus"
                                                                ("n0x"
                                                                 "-1"
                                                                 "i"
                                                                 "1"
                                                                 "j"
                                                                 "j!1+n"))
                                                               (rewrite
                                                                "expt_x1"
                                                                -1)
                                                               (replace
                                                                -1)
                                                               (lemma
                                                                "div_cancel1"
                                                                ("x"
                                                                 "j!1+1"
                                                                 "n0z"
                                                                 "2"))
                                                               (lemma
                                                                "div_cancel1"
                                                                ("x"
                                                                 "j!1-1"
                                                                 "n0z"
                                                                 "2"))
                                                               (lemma
                                                                "times_div1"
                                                                ("x"
                                                                 "2"
                                                                 "y"
                                                                 "j!1+1"
                                                                 "n0z"
                                                                 "2"))
                                                               (lemma
                                                                "times_div1"
                                                                ("x"
                                                                 "2"
                                                                 "y"
                                                                 "j!1-1"
                                                                 "n0z"
                                                                 "2"))
                                                               (simplify
                                                                -1)
                                                               (replace
                                                                -9
                                                                -1
                                                                rl)
                                                               (simplify
                                                                -2)
                                                               (replace
                                                                -9
                                                                -2
                                                                rl)
                                                               (replace
                                                                -3
                                                                -1)
                                                               (replace
                                                                -4
                                                                -2)
                                                               (replace
                                                                -1
                                                                1
                                                                rl)
                                                               (replace
                                                                -2
                                                                1
                                                                rl)
                                                               (replace
                                                                -5
                                                                1)
                                                               (lemma
                                                                "expt_plus"
                                                                ("n0x"
                                                                 "-1"
                                                                 "i"
                                                                 "-1"
                                                                 "j"
                                                                 "j!1+n"))
                                                               (replace
                                                                -1)
                                                               (name-replace
                                                                "K30"
                                                                "(-1) ^ (j!1 + n)")
                                                               (rewrite
                                                                "expt_inverse")
                                                               (rewrite
                                                                "expt_x1")
                                                               (name
                                                                "K31"
                                                                "factorial(2*n)")
                                                               (replace
                                                                -1)
                                                               (expand
                                                                "factorial"
                                                                1)
                                                               (expand
                                                                "factorial"
                                                                1)
                                                               (replace
                                                                -1)
                                                               (case
                                                                "1/-1 = -1")
                                                               (("1"
                                                                 (replace
                                                                  -1)
                                                                 (hide
                                                                  -1
                                                                  -4
                                                                  -5
                                                                  -6
                                                                  -7
                                                                  -8
                                                                  -9
                                                                  -10
                                                                  -12)
                                                                 (name
                                                                  "K32"
                                                                  "C(3 + 2 * n, x!1)")
                                                                 (replace
                                                                  -1)
                                                                 (name
                                                                  "K33"
                                                                  "C(1 + 2 * n, 2 + x!1)")
                                                                 (replace
                                                                  -1)
                                                                 (name
                                                                  "K34"
                                                                  "C(1 + 2 * n, x!1)")
                                                                 (replace
                                                                  -1)
                                                                 (name
                                                                  "K35"
                                                                  "C(1 + 2 * n, x!1-2)")
                                                                 (lemma
                                                                  "both_sides_times1"
                                                                  ("x"
                                                                   "-1 * (K33 * x!1 * x!1) - 2 * K33  -
                                                                                                                                                                                                                                                                                         2 * K34
                                                                                                                                                                                                                                                                                         - 4 * (K34 * n)
                                                                                                                                                                                                                                                                                         - 6 * (K34 * x!1)
                                                                                                                                                                                                                                                                                         - 8 * (K34 * x!1 * n)
                                                                                                                                                                                                                                                                                         + 8 * (C(1 + 2 * n, x!1 - 2) * x!1 * n)
                                                                                                                                                                                                                                                                                         + 9 * (C(1 + 2 * n, x!1 - 2) * x!1)
                                                                                                                                                                                                                                                                                         - 20 * C(1 + 2 * n, x!1 - 2)
                                                                                                                                                                                                                                                                                         - 36 * (C(1 + 2 * n, x!1 - 2) * n)
                                                                                                                                                                                                                                                                                         + 2 * (K34 * x!1 * x!1)
                                                                                                                                                                                                                                                                                         - C(1 + 2 * n, x!1 - 2) * x!1 * x!1
                                                                                                                                                                                                                                                                                         - 16 * (C(1 + 2 * n, x!1 - 2) * n * n)
                                                                                                                                                                                                                                                                                         - 3 * (x!1 * K33)"
                                                                   "y"
                                                                   "-2 * K32 - 4 * (K32 * n * n) - 6 * (K32 * n)"
                                                                   "n0z"
                                                                   "K30*K31"))
                                                                 (replace
                                                                  -1
                                                                  1)
                                                                 (hide
                                                                  -1)
                                                                 (replace
                                                                  -1)
                                                                 (lemma
                                                                  "C_k_plus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1-2"))
                                                                 (lemma
                                                                  "C_n_plus_1"
                                                                  ("n"
                                                                   "2+2*n"
                                                                   "k"
                                                                   "x!1"))
                                                                 (replace
                                                                  -1
                                                                  -6)
                                                                 (replace
                                                                  -3)
                                                                 (lemma
                                                                  "C_n_plus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1"))
                                                                 (replace
                                                                  -1
                                                                  -7)
                                                                 (lemma
                                                                  "C_n_plus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1-1"))
                                                                 (replace
                                                                  -1
                                                                  -8)
                                                                 (hide
                                                                  -1
                                                                  -2
                                                                  -3)
                                                                 (replace
                                                                  -3)
                                                                 (replace
                                                                  -2)
                                                                 (lemma
                                                                  "C_k_minus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1-1"))
                                                                 (lemma
                                                                  "C_k_minus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1+1"))
                                                                 (replace
                                                                  -1
                                                                  -6)
                                                                 (lemma
                                                                  "C_k_minus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1"))
                                                                 (replace
                                                                  -1
                                                                  -7)
                                                                 (replace
                                                                  -6)
                                                                 (hide
                                                                  -1
                                                                  -2
                                                                  -3)
                                                                 (lemma
                                                                  "C_k_minus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1-1"))
                                                                 (replace
                                                                  -1)
                                                                 (lemma
                                                                  "C_k_minus_1"
                                                                  ("n"
                                                                   "1+2*n"
                                                                   "k"
                                                                   "x!1-2"))
                                                                 (replace
                                                                  -1)
                                                                 (replace
                                                                  -4)
                                                                 (hide
                                                                  -1
                                                                  -2
                                                                  -3)
                                                                 (hide
                                                                  -6
                                                                  -5)
                                                                 (simplify
                                                                  -4)
                                                                 (lemma
                                                                  "div_times"
                                                                  ("x"
                                                                   "1 + 2 * n - (x!1 - 2)"
                                                                   "n0x"
                                                                   "x!1 - 2 + 1"
                                                                   "y"
                                                                   "1 + 2 * n - (x!1 - 1)"
                                                                   "n0y"
                                                                   "x!1 - 1 + 1"))
                                                                 (simplify
                                                                  -1)
                                                                 (simplify
                                                                  -3)
                                                                 (replace
                                                                  -1
                                                                  -3)
                                                                 (hide
                                                                  -1)
                                                                 (simplify
                                                                  -3)
                                                                 (lemma
                                                                  "div_times"
                                                                  ("x"
                                                                   "2 * n - x!1"
                                                                   "n0x"
                                                                   "2 + x!1"
                                                                   "y"
                                                                   "1 - x!1 + 2 * n"
                                                                   "n0y"
                                                                   "1 + x!1"))
                                                                 (replace
                                                                  -1
                                                                  -4)
                                                                 (hide
                                                                  -1)
                                                                 (name
                                                                  "K40"
                                                                  "((6 - 3 * x!1 + 6 * n + (4 * (n * n) - 2 * (x!1 * n) + 4 * n) +
                                                                                                                                                                                                                                                                                       (-2 * (x!1 * n) - 2 * x!1 + x!1 * x!1))
                                                                                                                                                                                                                                                                                      / (x!1 * x!1 - x!1))")
                                                                 (replace
                                                                  -1)
                                                                 (name
                                                                  "K41"
                                                                  "((2 * n - x!1) * (1 - x!1 + 2 * n)) / ((2 + x!1) * (1 + x!1))")
                                                                 (replace
                                                                  -1)
                                                                 (name
                                                                  "K42"
                                                                  "(3 - x!1 + 2 * n) / (x!1 - 1)")
                                                                 (replace
                                                                  -1)
                                                                 (replace
                                                                  -5
                                                                  *
                                                                  rl)
                                                                 (replace
                                                                  -6
                                                                  *
                                                                  rl)
                                                                 (replace
                                                                  -7
                                                                  *
                                                                  rl)
                                                                 (case
                                                                  "-2 * (K40 * K35 + K35 + 2 * (K35 * K42)) -
                                                                                                                                                                                                                                                                                      4 * ((K40 * K35 + K35 + 2 * (K35 * K42)) * n * n)
                                                                                                                                                                                                                                                                                      - 6 * ((K40 * K35 + K35 + 2 * (K35 * K42)) * n) = (-1*K35)*(K40+1+2*K42)*(2+4*n*n+6*n)")
                                                                 (("1"
                                                                   (replace
                                                                    -1
                                                                    1)
                                                                   (case
                                                                    "-1 * (K41 * (K40 * K35) * x!1 * x!1) - 2 * (K41 * (K40 * K35)) -
                                                                                                                                                                                                                                                                                             2 * (K40 * K35)
                                                                                                                                                                                                                                                                                             - 4 * (K40 * K35 * n)
                                                                                                                                                                                                                                                                                             - 6 * (K40 * K35 * x!1)
                                                                                                                                                                                                                                                                                             - 8 * (K40 * K35 * x!1 * n)
                                                                                                                                                                                                                                                                                             + 8 * (K35 * x!1 * n)
                                                                                                                                                                                                                                                                                             + 9 * (K35 * x!1)
                                                                                                                                                                                                                                                                                             - 20 * K35
                                                                                                                                                                                                                                                                                             - 36 * (K35 * n)
                                                                                                                                                                                                                                                                                             + 2 * (K40 * K35 * x!1 * x!1)
                                                                                                                                                                                                                                                                                             - K35 * x!1 * x!1
                                                                                                                                                                                                                                                                                             - 16 * (K35 * n * n)
                                                                                                                                                                                                                                                                                             - 3 * (x!1 * (K41 * (K40 * K35))) = (-1*K35)*(K41*K40*(x!1+2)*(x!1+1) + K40*(2+4*n+6*x!1+8*x!1*n-2*x!1*x!1) + (20-8*x!1*n-9*x!1+36*n+x!1*x!1+16*n*n))")
                                                                   (("1"
                                                                     (replace
                                                                      -1
                                                                      1)
                                                                     (hide
                                                                      -1
                                                                      -2)
                                                                     (simplify
                                                                      -3)
                                                                     (lemma
                                                                      "both_sides_times2"
                                                                      ("n0z"
                                                                       "(-1*K35)"
                                                                       "x"
                                                                       "(K41 * K40 * (x!1 + 2) * (x!1 + 1) +
                                                                                                                                                                                                                                                                                                           K40 * (2 + 4 * n + 6 * x!1 + 8 * x!1 * n - 2 * x!1 * x!1)
                                                                                                                                                                                                                                                                                                           + (20 - 8 * x!1 * n - 9 * x!1 + 36 * n + x!1 * x!1 + 16 * n * n))"
                                                                       "y"
                                                                       "(K40 + 1 + 2 * K42) * (2 + 4 * n * n + 6 * n)"))
                                                                     (replace
                                                                      -1
                                                                      1)
                                                                     (hide
                                                                      -1)
                                                                     (case
                                                                      "K41 * K40 * (x!1 + 2) * (x!1 + 1) = K40*((2 * n - x!1) * (1 - x!1 + 2 * n))")
                                                                     (("1"
                                                                       (replace
                                                                        -1
                                                                        1)
                                                                       (hide
                                                                        -1
                                                                        -3
                                                                        -5
                                                                        -6
                                                                        -7
                                                                        -8)
                                                                       (lemma
                                                                        "div_cancel3"
                                                                        ("x"
                                                                         "6 - 4 * (x!1 * n) - 5 * x!1 + x!1 * x!1 + 4 * (n * n) + 10 * n"
                                                                         "n0z"
                                                                         "x!1 * x!1 - x!1"
                                                                         "y"
                                                                         "K40"))
                                                                       (lemma
                                                                        "both_sides_times2"
                                                                        ("x"
                                                                         "K40 * ((2 * n - x!1) * (1 - x!1 + 2 * n)) +
                                                                                                                                                                                                                                                                                                                  K40 * (2 + 4 * n + 6 * x!1 + 8 * x!1 * n - 2 * x!1 * x!1)
                                                                                                                                                                                                                                                                                                                  + (20 - 8 * x!1 * n - 9 * x!1 + 36 * n + x!1 * x!1 + 16 * n * n)"
                                                                         "y"
                                                                         "(K40 + 1 + 2 * K42) * (2 + 4 * n * n + 6 * n)"
                                                                         "n0z"
                                                                         "x!1*(x!1-1)"))
                                                                       (replace
                                                                        -1
                                                                        1
                                                                        rl)
                                                                       (hide
                                                                        -1)
                                                                       (name-replace
                                                                        "K50"
                                                                        "6 - 4 * (x!1 * n) - 5 * x!1 + x!1 * x!1 + 4 * (n * n) + 10 * n")
                                                                       (name-replace
                                                                        "K51"
                                                                        "2 + 4 * n * n + 6 * n")
                                                                       (name-replace
                                                                        "K52"
                                                                        "(2 * n - x!1) * (1 - x!1 + 2 * n)")
                                                                       (name-replace
                                                                        "K53"
                                                                        "2 + 4 * n + 6 * x!1 + 8 * x!1 * n - 2 * x!1 * x!1")
                                                                       (name-replace
                                                                        "K54"
                                                                        "20 - 8 * x!1 * n - 9 * x!1 + 36 * n + x!1 * x!1 + 16 * n * n")
                                                                       (case
                                                                        "x!1 * (x!1 - 1) * ((K40 + 1 + 2 * K42) * K51) = (K50+x!1*(x!1-1) + 2*(3-x!1+2*n)*x!1)*K51")
                                                                       (("1"
                                                                         (replace
                                                                          -1
                                                                          1)
                                                                         (hide
                                                                          -1)
                                                                         (case
                                                                          "x!1 * (x!1 - 1) * (K40 * K52 + K40 * K53 + K54) = K50*(K52+K53) + x!1*(x!1-1)*K54")
                                                                         (("1"
                                                                           (replace
                                                                            -1
                                                                            1)
                                                                           (hide
                                                                            -1)
                                                                           (hide
                                                                            -1
                                                                            -2
                                                                            -3)
                                                                           (expand
                                                                            "K52")
                                                                           (expand
                                                                            "K54")
                                                                           (expand
                                                                            "K53")
                                                                           (expand
                                                                            "K51")
                                                                           (expand
                                                                            "K50")
                                                                           (propax))
                                                                          ("2"
                                                                           (hide
                                                                            2)
                                                                           (replace
                                                                            -1
                                                                            -3)
                                                                           (replace
                                                                            -3
                                                                            1)
                                                                           (assert))))
                                                                        ("2"
                                                                         (hide
                                                                          2)
                                                                         (replace
                                                                          -1
                                                                          -3)
                                                                         (replace
                                                                          -3
                                                                          1)
                                                                         (assert)
                                                                         (lemma
                                                                          "div_cancel1"
                                                                          ("x"
                                                                           "2 * (3 - x!1 + 2 * n) * x!1"
                                                                           "n0z"
                                                                           "x!1-1"))
                                                                         (replace
                                                                          -3
                                                                          1
                                                                          rl)
                                                                         (assert))))
                                                                      ("2"
                                                                       (hide-all-but
                                                                        (1
                                                                         -2))
                                                                       (lemma
                                                                        "div_cancel1"
                                                                        ("x"
                                                                         "K40 * ((2 * n - x!1) * (1 - x!1 + 2 * n))"
                                                                         "n0z"
                                                                         "(2 + x!1) * (1 + x!1)"))
                                                                       (replace
                                                                        -1
                                                                        1
                                                                        rl)
                                                                       (replace
                                                                        -2
                                                                        1
                                                                        rl)
                                                                       (assert))))
                                                                    ("2"
                                                                     (hide
                                                                      2
                                                                      3)
                                                                     (simplify
                                                                      1)
                                                                     (hide-all-but
                                                                      1)
                                                                     (grind))))
                                                                  ("2"
                                                                   (hide-all-but
                                                                    1)
                                                                   (grind))))
                                                                ("2"
                                                                 (assert))))
                                                              ("2"
                                                               (hide 10)
                                                               (name-replace
                                                                "NN"
                                                                "x!1")
                                                               (assert))))))))))))))))))))
                                            ("2"
                                             (hide 6)
                                             (assert))))))))))))
                                  ("2"
                                   (hide-all-but (1 2))
                                   (skosimp*)
                                   (expand "*")
                                   (expand "FS5")
                                   (expand "FS2")
                                   (expand "atanF")
                                   (propax))))
                                ("2"
                                 (hide-all-but 1)
                                 (expand "*")
                                 (expand "FS5")
                                 (expand "FS2")
                                 (expand "atanF")
                                 (propax))))
                              ("2"
                               (hide-all-but 1)
                               (expand "atanF")
                               (skosimp*)
                               (expand "*")
                               (propax))))
                            ("2"
                             (hide-all-but 1)
                             (skosimp*)
                             (expand "*")
                             (expand "atanF")
                             (propax))))
                          ("2"
                           (replace -5 1 rl)
                           (replace -7 1 rl)
                           (expand "atanF" 1)
                           (propax))))
                        ("2"
                         (hide-all-but (-7 1 2))
                         (replace -1 1 rl)
                         (skosimp*)
                         (hide -1)
                         (expand "atanF")
                         (propax))))
                      ("2" (hide-all-but 1) (grind))))
                    ("2" (hide-all-but 1) (grind))))
                  ("2" (hide-all-but 1) (grind))))
                ("2" (hide-all-but 1) (grind))))
              ("2"
               (hide-all-but 1)
               (skosimp*)
               (lemma "scal_polynomial" ("y" "y!1" "a" "a!1" "n" "n!1"))
               (lemma "extensionality_postulate"
                ("f"
                 "const_fun(y!1) * polynomial(a!1, n!1)"
                 "g"
                 "polynomial(const_fun(y!1) * a!1, n!1)"))
               (replace -1 -2 rl)
               (hide -1)
               (inst - "x")
               (expand "const_fun")
               (replace -1 1 rl)
               (expand "*")
               (propax))))
            ("2"
             (hide-all-but 1)
             (skosimp*)
             (lemma "mul_x_to_n_polynomial"
              ("a" "a!1" "n" "n!1" "pn" "pn!1"))
             (lemma "extensionality_postulate"
              ("f"
               "(polynomial(a!1, n!1) * (LAMBDA (x: real): x ^ pn!1))"
               "g"
               "       polynomial(LAMBDA (i: nat):
                                                                       IF i < pn!1 THEN 0 ELSE a!1(i - pn!1) ENDIF,
                                                                     n!1 + pn!1)"))
             (("1"
               (replace -1 -2 rl)
               (hide -1)
               (inst - "x")
               (replace -1 1 rl)
               (hide -1)
               (expand "*")
               (propax))
              ("2" (hide-all-but 1) (grind))))
            ("3" (hide-all-but 1) (grind))))))))
      ("2"
       (lemma "prod_derivable_fun[real]"
        ("f1" "LAMBDA (x:real):x*x" "f2" "deriv[real](atanN(n))"))
       (assert)
       (expand "*" -1)
       (propax))
      ("3"
       (assert)
       (lemma "diff_derivable_fun[real]"
        ("f1"
         "deriv[real](atanN(n))"
         "f2"
         "LAMBDA (x: real):
                                                2 * (x * atanN(n)(x)) + 4 * (x * atanN(n)(x) * n)"))
       (expand "-" -1)
       (propax))))
    ("2"
     (hide-all-but 1)
     (skeep)
     (case "x*x >= 0")
     (("1" (grind)) ("2" (grind))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "m")
   (("1" (skolem 1 ("n")) (expand "derivable_n_times?") (propax))
    ("2"
     (skolem 1 ("i"))
     (flatten)
     (skolem 1 ("n"))
     (expand "derivable_n_times?" 1)
     (expand "derivable_n_times?" 1)
     (lemma "atan_taylors_prep8" ("n" "n"))
     (replace -1 1)
     (inst - "n+1")
     (replace -2 1)
     (lemma "atan_taylors_prep8_TCC2" ("n" "n"))
     (replace -1 1)
     (lemma "atan_taylors_prep8_TCC3" ("n" "n"))
     (propax))
    ("3"
     (hide 2)
     (skosimp*)
     (lemma "atan_taylors_prep8_TCC1" ("n" "n!1" "x1" "x1!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "m")
   (("1" (expand "nderiv") (propax))
    ("2"
     (skolem 1 ("j"))
     (flatten)
     (skolem 1 ("n"))
     (expand "nderiv" 1)
     (expand "nderiv" 1)
     (inst - "1+n")
     (assert)
     (rewrite "atan_taylors_prep8"))
    ("3"
     (hide 2)
     (skolem 1 ("m" "n"))
     (skolem 1 ("x"))
     (expand "atanD")
     (lemma "expt_pos" ("px" "1+x*x" "i" "1+2*m+2*n"))
     (assert))
    ("4"
     (hide 2)
     (skolem 1 ("m" "n"))
     (lemma "atan_series_prep4" ("n" "n" "m" "m"))
     (propax))
    ("5"
     (hide 2)
     (skolem 1 ("n"))
     (skolem 1 ("x"))
     (expand "atanD")
     (lemma "expt_pos" ("px" "1+x*x" "i" "1+2*n"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "atan_series_prep4" ("n" "0" "m" "n"))
   (lemma "atan_series_prep5" ("n" "0" "m" "n"))
   (expand "atanD" -2)
   (expand "atanD" -1 1)
   (expand "atanN" -1 1)
   (expand "atanN" -2)
   (expand "polynomial")
   (expand "sigma")
   (expand "^")
   (expand "expt")
   (expand "expt")
   (assert)
   (case "odd?(0)")
   (("1" (hide -2 -3 1) (expand "odd?") (propax))
    ("2"
     (assert)
     (expand "/")
     (assert)
     (expand "atanF")
     (rewrite "expt_x0")
     (rewrite "C_0")
     (expand "factorial")
     (replace -1 2)
     (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (typepred "n")
   (expand ">=" -1)
   (expand "<=" -1)
   (split -1)
   (("1"
     (case "even?(n)")
     (("1"
       (assert)
       (expand "even?")
       (skolem -1 ("j"))
       (replace -1)
       (lemma "atan_series_prep6" ("n" "j-1"))
       (("1"
         (flatten)
         (expand "nderiv" 1)
         (assert)
         (lemma "deriv_atan_fun")
         (flatten)
         (replace -2 1)
         (case "FORALL (f:[real->real],n:nat): derivable_n_times?(f, n+1) => nderiv(n+1,f) = deriv(nderiv(n,f))")
         (("1"
           (lemma "div_cancel1" ("x" "j" "n0z" "2"))
           (replace -1)
           (replace -4 1 rl)
           (case "n= 2*j => even?(n)")
           (("1"
             (case "n=1")
             (("1" (replace -1) (expand "even?") (propax))
              ("2"
               (case "n>1")
               (("1"
                 (inst - "LAMBDA (x: real): 1 / (1 + x * x)" "n-2")
                 (("1"
                   (lemma "atan_series_prep6" ("n" "j"))
                   (flatten -1)
                   (replace -8)
                   (replace -11)
                   (lemma "derivable_n_times_lem"
                    ("f"
                     "LAMBDA (x: real): 1 / (1 + x * x)"
                     "n"
                     "2*j"
                     "m"
                     "2*j-1"))
                   (("1"
                     (assert)
                     (replace -11 -7)
                     (replace -7 2)
                     (lemma "atan_taylors_prep4_TCC1" ("n" "j-1"))
                     (lemma "atan_taylors_prep5_TCC1" ("n" "j-1"))
                     (lemma "deriv_div_fun[real]"
                      ("ff" "atanN(j - 1)" "gg" "atanD(j - 1)"))
                     (("1"
                       (replace -1 2)
                       (lemma "extensionality_postulate"
                        ("f"
                         "(deriv(atanN(j - 1)) * atanD(j - 1) -
                                                                               deriv(atanD(j - 1)) * atanN(j - 1))
                                                                              / (atanD(j - 1) * atanD(j - 1))"
                         "g"
                         "(deriv(atanN(j - 1)) * (LAMBDA (x: real): (1 + x * x)) -
                                                                                atanN(j - 1) * (LAMBDA (x: real): 4 * (x * j) - 2 * x))
                                                                               / (atanD(j - 1) * (LAMBDA (x: real): (1 + x * x)))"))
                       (replace -1 2 rl)
                       (hide -1 -2 -11 -7 -9 -13 -12 -15)
                       (skolem 2 ("z"))
                       (expand "/" 2)
                       (expand "-" 2)
                       (expand "*" 2)
                       (lemma "cross_mult"
                        ("x"
                         "(deriv(atanN(j - 1))(z) * atanD(j - 1)(z) -
                                                                                 deriv(atanD(j - 1))(z) * atanN(j - 1)(z))"
                         "n0x"
                         "atanD(j - 1)(z) * atanD(j - 1)(z)"
                         "y"
                         "(deriv(atanN(j - 1))(z) + 2 * (atanN(j - 1)(z) * z) -
                                                                                  4 * (atanN(j - 1)(z) * j * z)
                                                                                  + deriv(atanN(j - 1))(z) * z * z)"
                         "n0y"
                         "(atanD(j - 1)(z) + atanD(j - 1)(z) * z * z)"))
                       (replace -1 2)
                       (hide -1)
                       (name-replace "dD" "deriv(atanN(j - 1))")
                       (name-replace "N" "atanN(j - 1)")
                       (lemma "atan_taylors_prep5" ("n" "j-1"))
                       (replace -1 2)
                       (simplify 2)
                       (expand "atanD" 2)
                       (lemma "expt_plus"
                        ("n0x" "1+z*z" "i" "1" "j" "2*j-2"))
                       (("1"
                         (hide-all-but (-11 -7 1 2 -1))
                         (rewrite "expt_x1")
                         (replace -1 2)
                         (assert))
                        ("2"
                         (hide-all-but 1)
                         (lemma "sq_pos" ("a" "z"))
                         (grind))))
                      ("2" (propax))))
                    ("2"
                     (hide-all-but 1)
                     (assert)
                     (grind)
                     (hide-all-but (-5 1))
                     (grind)
                     (lemma "atan_taylors_prep8_TCC1" ("n" "j-1"))
                     (assert)
                     (hide-all-but 1)
                     (lemma "sq_pos" ("a" "x!1"))
                     (grind))))
                  ("2" (assert))
                  ("3"
                   (skolem 1 ("x"))
                   (hide-all-but 1)
                   (lemma "expt_pos" ("px" "1+x*x" "i" "1"))
                   (grind))))
                ("2" (assert))))))
            ("2"
             (hide-all-but 1)
             (flatten)
             (expand "even?")
             (inst + "j"))))
          ("2"
           (hide-all-but 1)
           (induct "n")
           (("1"
             (skolem 1 ("f"))
             (flatten)
             (expand "nderiv")
             (expand "nderiv")
             (propax))
            ("2"
             (skolem 1 ("i"))
             (flatten)
             (skolem 1 ("f"))
             (flatten)
             (expand "nderiv" 1)
             (inst - "deriv(f)")
             (expand "derivable_n_times?" -2)
             (flatten)
             (assert))
            ("3"
             (hide 2)
             (skosimp*)
             (lemma "nderiv_derivable" ("m" "n!2" "n" "n!2" "f" "f!1"))
             (assert))
            ("4"
             (hide 2)
             (skosimp*)
             (lemma "derivable_n_times_lem"
              ("f" "f!1" "n" "1+n!2" "m" "n!2"))
             (assert))
            ("5" (hide 2) (skosimp*))))
          ("3"
           (hide-all-but 1)
           (skosimp*)
           (lemma "nderiv_derivable" ("m" "n!1" "n" "n!1" "f" "f!1"))
           (assert))
          ("4"
           (hide-all-but 1)
           (skosimp*)
           (lemma "derivable_n_times_lem"
            ("f" "f!1" "n" "1+n!1" "m" "n!1"))
           (assert))
          ("5" (skosimp*))))
        ("2" (assert))))
      ("2"
       (assert)
       (rewrite "even_or_odd")
       (expand "odd?")
       (skolem -1 ("j"))
       (replace -1)
       (lemma "div_cancel1" ("x" "j" "n0z" "2"))
       (replace -1)
       (lemma "deriv_atan_fun")
       (flatten)
       (expand "nderiv")
       (replace -2 1)
       (lemma "atan_series_prep6" ("n" "j"))
       (("1" (flatten)) ("2" (assert))))))
    ("2" (replace -1 1 rl) (expand "nderiv") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (case "n=0")
   (("1" (replace -1 1) (expand "nderiv") (rewrite "atan_0"))
    ("2"
     (case "n>0")
     (("1"
       (lemma "deriv_atan_fun")
       (flatten)
       (expand "nderiv" 2)
       (replace -2 2)
       (assert)
       (case "even?(n)")
       (("1"
         (assert)
         (expand "even?" -1)
         (skolem -1 ("j"))
         (case "j=0")
         (("1" (assert))
          ("2"
           (case "j>0")
           (("1"
             (replace -2)
             (hide -2 1 2 -3 -4 -5)
             (lemma "atan_series_prep6" ("n" "j"))
             (("1"
               (flatten -1)
               (hide -2)
               (lemma "atan_series_prep6" ("n" "j-1"))
               (("1"
                 (flatten -1)
                 (hide -1)
                 (name-replace "F" "LAMBDA (x: real): 1 / (1 + x * x)")
                 (("1"
                   (case "FORALL (f:[real->real],n:nat): derivable_n_times?(f, n+1) IMPLIES
                                                                                                      nderiv(n+1,f) = deriv(nderiv(n,f))")
                   (("1"
                     (inst - "F" "2*(j-1)")
                     (("1"
                       (lemma "derivable_n_times_lem"
                        ("f" "F" "m" "2*j-1" "n" "2*j"))
                       (("1"
                         (assert)
                         (replace -3 -2)
                         (replace -2 1)
                         (hide -1 -2 -3 -4)
                         (expand "/" 1)
                         (lemma "atan_taylors_prep3" ("n" "j-1" "m" "1"))
                         (expand "derivable_n_times?")
                         (expand "derivable_n_times?")
                         (flatten -1)
                         (lemma "atan_taylors_prep4" ("n" "j-1"))
                         (lemma "atan_taylors_prep5" ("n" "j-1"))
                         (lemma "div_derivable_fun[real]"
                          ("f" "atanN(j - 1)" "g" "atanD(j - 1)"))
                         (("1"
                           (assert)
                           (lemma "deriv_div_fun[real]"
                            ("ff" "atanN(j - 1)" "gg" "atanD(j - 1)"))
                           (replace -3 -1)
                           (replace -4 -1)
                           (expand "/" -1 1)
                           (replace -1 1)
                           (hide -1)
                           (case "j = 1")
                           (("1"
                             (replace -1)
                             (assert)
                             (expand "const_fun" 1)
                             (expand "/")
                             (expand "*")
                             (expand "-" 1)
                             (expand "atanD")
                             (hide-all-but 1)
                             (grind))
                            ("2"
                             (case "j>1")
                             (("1"
                               (hide -7 1)
                               (assert)
                               (expand "/" 1)
                               (expand "-")
                               (expand "*")
                               (lemma "polynomial_x0"
                                ("a"
                                 "LAMBDA (i: nat): atanF(j - 1)(1 + i) + i * atanF(j - 1)(1 + i)"
                                 "n"
                                 "2 * j - 3"))
                               (replace -1 1)
                               (simplify 1)
                               (expand "atanD" 1)
                               (rewrite "expt_1i" 1)
                               (expand "atanF" 1)
                               (assert))
                              ("2" (assert))))))
                          ("2"
                           (hide 2)
                           (lemma "atan_taylors_prep8_TCC1" ("n" "j-1"))
                           (propax))))
                        ("2"
                         (lemma "atan_taylors_prep8_TCC1" ("n" "j-1"))
                         (assert))
                        ("3" (assert))))
                      ("2" (assert))))
                    ("2"
                     (hide-all-but 1)
                     (induct "n")
                     (("1" (expand "nderiv") (expand "nderiv") (propax))
                      ("2"
                       (skolem 1 ("k"))
                       (flatten)
                       (skolem 1 ("G"))
                       (flatten)
                       (expand "nderiv" 1)
                       (inst - "deriv(G)")
                       (expand "derivable_n_times?" -2)
                       (flatten)
                       (assert))
                      ("3"
                       (hide-all-but 1)
                       (skosimp*)
                       (lemma "nderiv_derivable[real]")
                       (inst?)
                       (assert)
                       (inst?)
                       (assert))
                      ("4"
                       (hide 2)
                       (skosimp*)
                       (lemma "derivable_n_times_lem")
                       (inst - "f!1" "n!2" "n!2+1")
                       (assert))
                      ("5" (hide 2) (skosimp*))))
                    ("3"
                     (skosimp*)
                     (lemma "nderiv_derivable")
                     (inst?)
                     (inst - "n!1")
                     (assert))
                    ("4"
                     (skosimp*)
                     (hide -2 -3 2)
                     (lemma "derivable_n_times_lem")
                     (inst - "f!1" "n!1" "n!1+1")
                     (assert))
                    ("5" (skosimp*))))
                  ("2"
                   (hide-all-but 1)
                   (skolem 1 ("x"))
                   (lemma "sq_pos" ("a" "x"))
                   (grind))))
                ("2" (assert))))
              ("2" (assert))))
            ("2" (assert))))))
        ("2"
         (assert)
         (rewrite "even_or_odd" 1)
         (expand "odd?" -1)
         (skolem -1 ("j"))
         (replace -1)
         (lemma "atan_series_prep6" ("n" "j"))
         (("1"
           (flatten -1)
           (replace -2 2)
           (expand "/" 2)
           (expand "atanD" 2)
           (rewrite "expt_1i" 2)
           (expand "atanN" 2)
           (lemma "polynomial_x0" ("a" "atanF(j)" "n" "2*j"))
           (("1"
             (replace -1 2)
             (expand "atanF" 2)
             (rewrite "C_0" 2)
             (assert)
             (lemma "div_cancel1" ("x" "j" "n0z" "2"))
             (replace -1 2)
             (case "odd?(0)")
             (("1" (expand "odd?") (propax)) ("2" (assert))))
            ("2" (assert))))
          ("2" (assert))))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "trichotomy" ("x" "n"))
   (split -1)
   (("1"
     (lemma "deriv_atan_fun")
     (flatten)
     (expand "derivable_n_times?" 1)
     (assert)
     (replace -2 1)
     (lemma "trichotomy" ("x" "n-1"))
     (split -1)
     (("1"
       (lemma "atan_series_prep6" ("n" "n"))
       (flatten)
       (lemma "derivable_n_times_lem"
        ("f" "LAMBDA (x: real): 1 / (1 + x * x)" "n" "2*n" "m" "n-1"))
       (("1" (assert))
        ("2"
         (skosimp*)
         (hide-all-but -1)
         (lemma "sq_pos" ("a" "x!1"))
         (grind))))
      ("2" (replace -1) (expand "derivable_n_times?") (propax))
      ("3" (assert))))
    ("2" (expand "derivable_n_times?") (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n" "x"))
   (lemma "atan_taylors_prep2" ("n" "n"))
   (lemma "atan_taylors_prep1" ("n" "n" "x" "x"))
   (replace -2 1 rl)
   (expand "*" 1)
   (rewrite "abs_mult" 1)
   (rewrite "abs_mult" 1)
   (expand "abs" 1 1)
   (lemma "both_sides_times_pos_le1"
    ("x"
     "abs(atanS(n)(x))"
     "pz"
     "factorial(2 * n)"
     "y"
     "(1 + x * x) ^ (1 + 2 * n)"))
   (hide -3 -1)
   (lemma "sqrt_le" ("nny" "1" "nnz" "1+x*x"))
   (lemma "sq_pos" ("a" "x"))
   (expand "sq" -1)
   (rewrite "sqrt_1" -2)
   (case "x*x = 0")
   (("1"
     (replace -1)
     (rewrite "expt_1i")
     (rewrite "expt_1i")
     (rewrite "sqrt_1")
     (case "abs((-1) ^ n) = 1")
     (("1"
       (lemma "both_sides_times_pos_le1"
        ("x" "abs(atanS(n)(x))" "y" "1" "pz" "factorial(2 * n)"))
       (replace -2)
       (assert))
      ("2"
       (hide-all-but 1)
       (case "FORALL (n:nat): abs((-1) ^ n) = 1")
       (("1" (inst - "n"))
        ("2"
         (hide 2)
         (induct "n")
         (("1" (rewrite "expt_x0") (expand "abs") (propax))
          ("2"
           (skosimp*)
           (lemma "expt_plus" ("n0x" "-1" "i" "j!1" "j" "1"))
           (replace -1 1)
           (rewrite "abs_mult")
           (replace -2)
           (hide-all-but 1)
           (grind))))))))
    ("2"
     (lemma "both_sides_expt_pos_lt" ("px" "1" "py" "1+x*x" "pm" "n"))
     (("1"
       (rewrite "expt_1i")
       (assert)
       (lemma "lt_times_lt_pos1"
        ("px" "1" "y" "sqrt(1+x*x)" "nnz" "1" "w" "(1 + x * x) ^ n"))
       (assert)
       (lemma "both_sides_times_pos_lt1"
        ("x"
         "1"
         "y"
         "sqrt(1 + x * x) * (1 + x * x) ^ n"
         "pz"
         "sqrt(1 + x * x) * (1 + x * x) ^ n"))
       (assert)
       (lemma "expt_plus" ("n0x" "1+x*x" "i" "n" "j" "n"))
       (lemma "sqrt_def" ("nnx" "1+x*x"))
       (replace -1 -3)
       (lemma "expt_plus" ("n0x" "1+x*x" "i" "1" "j" "2*n"))
       (rewrite "expt_x1" -1)
       (replace -1 2)
       (replace -3 2)
       (assert)
       (case "FORALL (n:nat): abs((-1) ^ n) = 1")
       (("1"
         (inst - "n")
         (replace -1)
         (replace -4 * rl)
         (lemma "both_sides_times_pos_le1"
          ("x"
           "abs(atanS(n)(x))"
           "y"
           "(1 + x * x) ^ (2 * n) + (1 + x * x) ^ (2 * n) * x * x"
           "pz"
           "factorial(2 * n)"))
         (assert))
        ("2"
         (hide-all-but 1)
         (induct "n")
         (("1" (grind))
          ("2"
           (skosimp*)
           (lemma "expt_plus" ("n0x" "-1" "i" "j!1" "j" "1"))
           (replace -1)
           (rewrite "abs_mult")
           (replace -2)
           (hide -1 -2)
           (grind))))))
      ("2"
       (assert)
       (case "n=0")
       (("1"
         (hide 1)
         (replace -1)
         (rewrite "expt_x1" 2)
         (expand "atanS" 2)
         (expand "harmonic_poly_real")
         (expand "sigma")
         (expand "sigma")
         (rewrite "C_0")
         (rewrite "expt_x1" 2)
         (rewrite "expt_x0" 2)
         (case "odd?(0)")
         (("1" (expand "odd?") (propax))
          ("2" (assert) (hide-all-but (3 -2)) (grind))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("n" "x"))
   (lemma "atan_nderiv" ("n" "2*n+1"))
   (case "even?(2*n+1)")
   (("1" (expand "even?") (propax))
    ("2"
     (assert)
     (lemma "div_cancel1" ("x" "n" "n0z" "2"))
     (replace -1)
     (replace -2 2)
     (hide -1 -2 1)
     (expand "/")
     (expand "atanD")
     (lemma "expt_pos" ("px" "1+x*x" "i" "1+2*n"))
     (rewrite "abs_div")
     (expand "abs" 1 2)
     (assert)
     (lemma "div_mult_pos_le1"
      ("z"
       "abs(atanN(n)(x))"
       "py"
       "(1 + x * x) ^ (1 + 2 * n)"
       "x"
       "factorial(2 * n)"))
     (lemma "atan_series_prep7" ("n" "n" "x" "x"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (label "xytp" (-1 -2))
   (expand "atan_series_n")
   (expand "atan_series_term")
   (expand "atan_series_coef")
   (name "aa"
         "LAMBDA (k:nat): IF odd?(k) THEN (LET nn: nat = (k-1)/2 IN (-1)^nn/k) ELSE 0 ENDIF")
   (("1"
     (case "NOT FORALL (mm:nat,xx:real): sigma(0, mm,
                                                                    LAMBDA (ii: nat):
                                                                      (xx ^ (1 + 2 * ii)) * (((-1) ^ ii) / (1 + 2 * ii))) = polynomial(aa,2*mm+1)(xx)")
     (("1"
       (hide 2)
       (induct "mm")
       (("1"
         (hide-all-but 1)
         (skeep)
         (expand "sigma")
         (expand "sigma")
         (expand "aa")
         (expand "polynomial")
         (expand "sigma")
         (expand "sigma")
         (expand "sigma")
         (case "not odd?(0)")
         (("1" (assert)) ("2" (hide 1) (expand "odd?") (propax))))
        ("2"
         (skeep)
         (skeep)
         (inst - "xx")
         (expand "sigma" +)
         (replace -1)
         (hide -1)
         (expand "polynomial")
         (expand "sigma" + 2)
         (expand "sigma" + 2)
         (expand "aa")
         (case "not odd?(2+2*j)")
         (("1" (assert))
          ("2" (hide-all-but -1) (expand "odd?") (propax))))))
      ("2"
       (inst-cp - "n" "x")
       (inst - "n" "y")
       (replaces -1)
       (replaces -1)
       (lemma "derivable_polynomial")
       (inst - "aa" "2*n+1")
       (lemma "connected_real")
       (lemma "mean_value[real]")
       (("1"
         (inst - "x" "y" "polynomial(aa,2*n+1)")
         (assert)
         (skeep -1)
         (case "deriv(polynomial(aa, 1 + 2 * n), c) >= 0")
         (("1" (mult-by -1 "y-x") (assert))
          ("2"
           (lemma "deriv_polynomial")
           (inst?)
           (assert)
           (decompose-equality -1)
           (expand "deriv" -1)
           (inst - "c")
           (replace -1)
           (hide-all-but (-2 -3 "xytp" 1))
           (name "bb" "LAMBDA (i: nat): aa(1 + i) + i * aa(1 + i)")
           (replace -1)
           (case "FORALL (kk:nat): polynomial(bb, 4 * kk+2)(c) >= 0")
           (("1"
             (case "FORALL (kk:nat): FORALL (tt:nat): tt<=kk IMPLIES polynomial(bb, 2*tt)(c) >= 0")
             (("1" (inst - "n") (inst - "n") (assert))
              ("2"
               (induct "kk")
               (("1"
                 (skeep)
                 (case "tt = 0")
                 (("1"
                   (replaces -1)
                   (hide-all-but 1)
                   (expand "bb")
                   (expand "aa")
                   (grind))
                  ("2" (assert))))
                ("2"
                 (skolem 1 "k")
                 (hide 2)
                 (flatten)
                 (skeep)
                 (case "NOT tt = k+1")
                 (("1" (inst - "tt") (assert))
                  ("2"
                   (replaces -1)
                   (hide -2)
                   (assert)
                   (lemma "even_or_odd")
                   (inst - "k+1")
                   (ground)
                   (("1"
                     (expand "even?" -1)
                     (skeep -1)
                     (case "j>=0")
                     (("1"
                       (assert)
                       (case "j = 0")
                       (("1" (replaces -1) (assert))
                        ("2"
                         (case "k = 2*j-1")
                         (("1"
                           (replaces -1)
                           (assert)
                           (inst - "2*j-1")
                           (assert)
                           (hide -4)
                           (expand "polynomial")
                           (assert)
                           (expand "sigma" +)
                           (expand "sigma" +)
                           (assert)
                           (invoke (case "%1 + %2>= 0") (! 3 1 2)
                            (! 3 1 3))
                           (("1" (assert))
                            ("2"
                             (hide 4)
                             (expand "bb" +)
                             (expand "aa" +)
                             (assert)
                             (case "NOT odd?(4*j)")
                             (("1"
                               (assert)
                               (case "FORALL (kn:nat): (-1)^(2*kn) = 1")
                               (("1"
                                 (inst - "j")
                                 (replaces -1)
                                 (assert)
                                 (expand "^" +)
                                 (lemma "nnreal_expt")
                                 (inst?)
                                 (assert)
                                 (mult-by -1 "1/(1+4*j)")
                                 (("1"
                                   (assert)
                                   (mult-by -1 "1+4*j")
                                   (assert))
                                  ("2" (cross-mult 1))))
                                ("2"
                                 (hide-all-but 1)
                                 (induct "kn")
                                 (("1" (grind))
                                  ("2"
                                   (skosimp*)
                                   (expand "^")
                                   (expand "expt" +)
                                   (expand "expt" +)
                                   (assert))))))
                              ("2" (hide-all-but -1) (grind))))))
                          ("2" (assert))))))
                      ("2" (assert))))
                    ("2"
                     (expand "odd?" -1)
                     (skeep -1)
                     (case "NOT j>=0")
                     (("1" (assert))
                      ("2"
                       (replaces -2)
                       (assert)
                       (inst -3 "j"))))))))))))
            ("2"
             (hide 2)
             (induct "kk")
             (("1"
               (assert)
               (expand "polynomial")
               (expand "sigma")
               (expand "sigma")
               (expand "sigma")
               (expand "sigma")
               (case "NOT bb(1) = 0")
               (("1" (hide (-1 2)) (expand "bb") (expand "aa") (grind))
                ("2"
                 (replaces -1)
                 (assert)
                 (hide -1)
                 (expand "bb")
                 (expand "aa")
                 (grind)
                 (case "c <= 1")
                 (("1" (mult-ineq -1 -1) (assert)) ("2" (assert))))))
              ("2"
               (assert)
               (skeep)
               (assert)
               (expand "polynomial")
               (expand "sigma" +)
               (expand "sigma" +)
               (assert)
               (expand "sigma" +)
               (expand "sigma" +)
               (invoke (case "%1 + %2 + %3 + %4>=0") (! 1 1 2) (! 1 1 3)
                (! 1 1 4) (! 1 1 5))
               (("1" (assert))
                ("2"
                 (hide (-1 2))
                 (case "NOT (bb(3+4*j) = 0 AND bb(5+4*j) = 0)")
                 (("1" (hide (-1 2)) (expand "bb") (expand "aa") (grind))
                  ("2"
                   (flatten)
                   (replaces -1)
                   (replaces -1)
                   (assert)
                   (expand "bb")
                   (expand "aa")
                   (case "FORALL (kr:nat): (-1)^(2*kr) = 1 AND (-1)^(2*kr+1) = -1")
                   (("1"
                     (inst - "j+1")
                     (assert)
                     (flatten)
                     (replaces -1)
                     (replaces -1)
                     (assert)
                     (case "c^(4+4*j) >= c^(6+4*j)")
                     (("1"
                       (lemma "one_times")
                       (inst-cp - "c^(4+4*j)")
                       (replaces -2 -3 :dir rl)
                       (case "FORALL (nn:posnat): nn/nn = 1")
                       (("1"
                         (inst-cp - "5+4*j")
                         (replace -2 -4 :dir rL)
                         (inst -3 "c^(6+4*j)")
                         (replaces -3 -4 :dir rl)
                         (inst - "7+4*j")
                         (hide -2)
                         (invoke (name "aaz" "%1") (! -2 1))
                         (replace -1)
                         (replace -2 -3 :dir rl)
                         (assert))
                        ("2" (hide-all-but 1) (assert))))
                      ("2"
                       (hide 2)
                       (lemma "both_sides_expt_lt1_le_aux")
                       (inst - "c" "3+4*j" "5+4*j")
                       (expand "^")
                       (assert))))
                    ("2"
                     (hide-all-but 1)
                     (induct "kr")
                     (("1" (grind)) ("2" (grind))
                      ("3"
                       (skosimp*)
                       (assert)
                       (expand "^")
                       (expand "expt" +)
                       (expand "expt" +)
                       (assert))))))))))))))))
        ("2" (propax))))))
    ("2" (hide-all-but 1) (grind)) ("3" (hide-all-but 1) (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "atan_series_n")
   (rewrite "sigma_restrict_eq_0")
   (hide 2)
   (skosimp*)
   (expand "atan_series_term")
   (expand "^")
   (expand "expt")
   (propax))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("_" "x"))
   (induct "n")
   (("1"
     (expand "atan_series_n")
     (expand "atan_series_term")
     (expand "atan_series_coef")
     (expand "sigma")
     (expand "sigma")
     (expand "sigma")
     (rewrite "atan_nderiv_0")
     (rewrite "atan_nderiv_0")
     (expand "factorial")
     (expand "factorial")
     (expand "factorial")
     (rewrite "expt_x0")
     (case "even?(1)")
     (("1" (expand "even?") (propax)) ("2" (assert))))
    ("2"
     (skolem 1 ("j"))
     (flatten)
     (expand "atan_series_n")
     (expand "sigma" 1)
     (expand "sigma" 1 2)
     (rewrite "atan_nderiv_0")
     (rewrite "atan_nderiv_0")
     (expand "atan_series_term")
     (assert)
     (replace -1 1)
     (simplify 1)
     (lemma "sigma_eq[nat]"
      ("low"
       "0"
       "high"
       "2+2*j"
       "F"
       "LAMBDA (nn: nat):
                     IF nn > 2 + 2 * j OR nn = 0 THEN 0
                     ELSE nderiv(nn, atan)(0) * x ^ nn / factorial(nn)
                     ENDIF"
       "G"
       "LAMBDA (nn: nat):
                      IF nn > 4 + 2 * j OR nn = 0 THEN 0
                      ELSE nderiv(nn, atan)(0) * x ^ nn / factorial(nn)
                      ENDIF"))
     (("1"
       (split -1)
       (("1"
         (replace -1)
         (simplify 1)
         (hide -1 -2)
         (expand "atan_series_coef")
         (lemma "div_cancel1" ("x" "1+j" "n0z" "2"))
         (replace -1)
         (case "even?(3+2*j)")
         (("1" (expand "even?") (propax))
          ("2"
           (assert)
           (hide -1 1)
           (lemma "div_cancel1"
            ("x"
             "x ^ (3 + 2 * j) * (-1) ^ (1 + j) / (3 + 2 * j)"
             "n0z"
             "factorial(2+2*j)"))
           (replace -1 1 rl)
           (expand "factorial" 1 5)
           (assert)
           (rewrite "zero_times1" 1)
           (rewrite "div_div2" 1)
           (assert))))
        ("2" (hide 2 -1) (skolem 1 ("i")) (typepred "i") (assert))))
      ("2"
       (hide -1 2)
       (skosimp*)
       (lemma "atan_n_times_derivable" ("n" "nn!1"))
       (propax))
      ("3"
       (skosimp*)
       (lemma "atan_n_times_derivable" ("n" "nn!1"))
       (propax))))
    ("3"
     (skosimp*)
     (lemma "atan_n_times_derivable" ("n" "nn!1"))
     (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("n" "x"))
   (rewrite "atan_series_eqv" 1)
   (lemma "Taylors" ("aa" "0" "f" "atan" "bb" "x" "n" "2*n+2"))
   (rewrite "atan_0")
   (lemma "atan_n_times_derivable" ("n" "2*n+3"))
   (assert)
   (skosimp*)
   (inst 1 "c!1")
   (lemma "extensionality"
    ("f"
     "LAMBDA (nn:nat):
                    IF nn > 2 + 2 * n THEN 0
                    ELSIF nn = 0 THEN 0
                    ELSE nderiv(nn, atan)(0) * x ^ nn / factorial(nn)
                    ENDIF"
     "g"
     "LAMBDA (nn: nat):
                    IF nn > 2 + 2 * n OR nn = 0 THEN 0
                    ELSE nderiv(nn, atan)(0) * x ^ nn / factorial(nn)
                    ENDIF"))
   (("1"
     (split -1)
     (("1" (replace -1) (propax))
      ("2"
       (hide -2 2 -1)
       (skolem 1 ("i"))
       (lift-if)
       (simplify 1)
       (propax))))
    ("2"
     (hide-all-but 1)
     (skosimp*)
     (lemma "atan_n_times_derivable" ("n" "nn!1"))
     (propax))
    ("3"
     (skosimp*)
     (lemma "atan_n_times_derivable" ("n" "nn!1"))
     (propax))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sq_pos" ("a" "x!1"))
   (expand "sq")
   (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "1+x!1*x!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x"))
   (lemma "one_over_one_plus_t_sq_cont")
   (lemma "continuous_Integrable?[real]"
    ("f" "atan_deriv_fn" "a" "0" "b" "x"))
   (("1"
     (expand "continuous?" -2)
     (split -1)
     (("1" (propax)) ("2" (hide 2) (skosimp*) (inst - "x!1"))))
    ("2" (expand "connected?") (propax))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "atan_value_strict_increasing")
   (expand "strict_increasing?")
   (expand "atan")
   (inst - "0" "1")
   (assert)
   (rewrite "atan_value_0")
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x"))
   (lemma "atan_value_strict_increasing")
   (expand "strict_increasing?")
   (case "FORALL (x:posreal): 0 < atan_value(x) AND atan_value(x) < 2*atan_value(1)")
   (("1"
     (lemma "trichotomy" ("x" "x"))
     (split -1)
     (("1"
       (inst -2 "x")
       (("1" (flatten -2) (assert) (assert) (expand "pi") (assert))
        ("2" (assert))))
      ("2"
       (replace -1)
       (inst -2 "1")
       (rewrite "atan_value_0")
       (flatten -2)
       (assert)
       (assert))
      ("3"
       (inst-cp -3 "x" "0")
       (inst -2 "-x")
       (("1"
         (rewrite "atan_value_0")
         (rewrite "atan_neg_value")
         (expand "pi")
         (assert)
         (assert))
        ("2" (assert))))))
    ("2"
     (hide 2)
     (skosimp*)
     (typepred "x!1")
     (inst-cp - "0" "x!1")
     (rewrite "atan_value_0")
     (assert)
     (assert)
     (lemma "trich_lt" ("x" "x!1" "y" "1"))
     (split -1)
     (("1" (inst - "x!1" "1") (assert)) ("2" (replace -1) (assert))
      ("3"
       (lemma "atan_value_minus" ("x" "x!1" "y" "1"))
       (assert)
       (inst -5 "(x!1-1)/(x!1+1)" "1")
       (lemma "div_mult_pos_lt1" ("z" "x!1-1" "py" "x!1+1" "x" "1"))
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("x"))
   (lemma "one_over_one_plus_t_sq_cont")
   (lemma "continuous_Integrable?[real]"
    ("f" "atan_deriv_fn" "a" "0" "b" "x"))
   (("1"
     (expand "continuous?" -2)
     (expand "atan_deriv_fn")
     (split -1)
     (("1" (propax)) ("2" (skosimp*) (inst - "x!1"))))
    ("2" (assert) (expand "connected?") (propax))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "even?(i!1)")
   (("1"
     (expand "even?")
     (skosimp*)
     (replace -1)
     (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
     (replace -1)
     (assert))
    ("2" (rewrite "even_or_odd"))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "atanF_TCC1" ("i" "i!1" "n" "n!1"))
   (assert)
   (typepred "i!1")
   (lemma "int_exp" ("x" "-1" "n" "i!1 / 2 + n!1"))
   (lemma "int_times_int_is_int"
    ("i" "factorial(2 * n!1)" "j" "C(1 + 2 * n!1, i!1)"))
   (lemma "int_times_int_is_int"
    ("i"
     "factorial(2 * n!1) *C(1 + 2 * n!1, i!1)"
     "j"
     "(-1) ^ (i!1 / 2 + n!1)"))
   (("1" (propax)) ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "atan_taylors_prep3" ("n" "n!1" "m" "1"))
   (expand "derivable_n_times?")
   (flatten))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "atan_taylors_prep3" ("n" "n!1" "m" "2"))
   (expand "derivable_n_times?")
   (expand "derivable_n_times?")
   (flatten))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "^")
   (typepred "g!1(x1!1)")
   (lemma "expt_nonzero" ("n0x" "g!1(x1!1)" "i" "pn!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "^" -4)
   (lemma "expt_nonzero" ("n0x" "g!1(x1!1)" "i" "pn!1+1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n" "x"))
   (expand "atanD")
   (lemma "expt_pos" ("px" "1+x*x" "i" "1+2*n"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "atan_taylors_prep3" ("n" "n" "m" "1"))
   (expand "derivable_n_times?")
   (expand "derivable_n_times?")
   (flatten)
   (lemma "atan_taylors_prep8_TCC1" ("n" "n"))
   (assert)
   (lemma "div_derivable_fun[real]" ("f" "atanN(n)" "g" "atanD(n)"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (lemma "atan_taylors_prep8_TCC1" ("n" "n"))
   (lemma "atan_taylors_prep8_TCC2" ("n" "n"))
   (lemma "atan_taylors_prep3" ("n" "n" "m" "2"))
   (expand "derivable_n_times?")
   (expand "derivable_n_times?")
   (expand "derivable_n_times?")
   (flatten -1)
   (lemma "deriv_div_fun[real]" ("ff" "atanN(n)" "gg" "atanD(n)"))
   (replace -1 1)
   (lemma "prod_derivable_fun[real]"
    ("f1" "deriv(atanN(n))" "f2" "atanD(n)"))
   (lemma "prod_derivable_fun[real]"
    ("f1" "deriv(atanD(n))" "f2" "atanN(n)"))
   (lemma "prod_derivable_fun[real]" ("f1" "atanD(n)" "f2" "atanD(n)"))
   (assert)
   (lemma "diff_derivable_fun[real]"
    ("f1"
     "deriv(atanN(n)) * atanD(n)"
     "f2"
     "deriv(atanD(n)) * atanN(n)"))
   (assert)
   (lemma "div_derivable_fun[real]"
    ("f"
     "deriv(atanN(n)) * atanD(n) - deriv(atanD(n)) * atanN(n)"
     "g"
     "atanD(n) * atanD(n)"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("m" "n" "x"))
   (expand "atanD")
   (lemma "expt_pos" ("px" "1+x*x" "i" "1+2*m+2*n"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (case "n=0")
   (("1" (expand "derivable_n_times?") (assert))
    ("2"
     (expand "derivable_n_times?")
     (assert)
     (lemma "deriv_atan_fun")
     (flatten)
     (replace -2 2)
     (assert)
     (hide -1 -2)
     (case "n=1")
     (("1" (replace -1) (expand "derivable_n_times?") (propax))
      ("2"
       (lemma "atan_series_prep6" ("n" "n"))
       (flatten)
       (hide -2)
       (lemma "derivable_n_times_lem"
        ("f" "(LAMBDA (x: real): 1 / (1 + x * x))" "m" "n-1" "n" "2*n"))
       (("1" (assert))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (lemma "sq_pos" ("a" "x!1"))
         (grind))))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (flatten)
   (expand "even?")
   (skosimp*)
   (typepred "n")
   (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
   (replace -3)
   (replace -1)
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "even?")
   (skosimp*)
   (typepred "n!1")
   (case "j!1>=1")
   (("1"
     (replace -3)
     (hide -3 1 -2)
     (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
     (replace -1)
     (lemma "atan_taylors_prep3" ("n" "j!1-1" "m" "1"))
     (("1" (flatten) (expand "derivable_n_times?") (flatten -1))
      ("2" (assert))))
    ("2"
     (hide 3)
     (expand ">=" -1)
     (expand "<=" -1)
     (split -1)
     (("1" (replace -2) (assert)) ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "even?")
   (skosimp*)
   (expand "atanD")
   (replace -1)
   (replace -1 * rl)
   (lemma "expt_pos" ("px" "1+x1!1*x1!1" "i" "n!1"))
   (expand "*" -3)
   (lemma "expt_plus" ("n0x" "1+x1!1*x1!1" "i" "1" "j" "n!1-1"))
   (("1" (rewrite "expt_x1") (assert))
    ("2" (lemma "sq_pos" ("a" "x1!1")) (hide-all-but (-1 1)) (grind))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (rewrite "even_or_odd")
   (flatten)
   (expand "odd?")
   (skosimp*)
   (replace -1)
   (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
   (replace -1)
   (assert)
   (typepred "n")
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (rewrite "even_or_odd")
   (flatten)
   (expand "odd?")
   (skosimp*)
   (replace -1)
   (lemma "div_cancel1" ("x" "j!1" "n0z" "2"))
   (replace -1)
   (expand "atanD")
   (lemma "expt_pos" ("px" "1+x1!1*x1!1" "i" "1+2*j!1"))
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("n"))
   (rewrite "even_or_odd")
   (flatten)
   (expand "odd?")
   (skolem -1 ("j"))
   (replace -1)
   (lemma "div_cancel1" ("x" "j" "n0z" "2"))
   (replace -1)
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "n!1")
   (rewrite "even_or_odd")
   (expand "odd?")
   (skosimp*)
   (replace -2)
   (assert))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: atan
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable_n_times?")
   (assert)
   (lemma "deriv_atan_fun")
   (flatten)
   (replace -2 3)
   (assert)
   (case "even?(nn!1-1)")
   (("1"
     (expand "even?")
     (skosimp*)
     (replace -1 3)
     (lemma "atan_series_prep6" ("n" "j!1"))
     (("1" (flatten)) ("2" (assert))))
    ("2"
     (rewrite "even_or_odd")
     (expand "odd?")
     (skosimp*)
     (replace -1 3)
     (lemma "atan_series_prep6" ("n" "j!1+1"))
     (("1"
       (flatten)
       (lemma "derivable_n_times_lem"
        ("f"
         "(LAMBDA (x: real): 1 / (1 + x * x))"
         "n"
         "2*j!1+2"
         "m"
         "1+2*j!1"))
       (("1" (assert)) ("2" (assert)) ("3" (assert))
        ("4"
         (skosimp*)
         (lemma "sq_pos" ("a" "x!1"))
         (hide-all-but (-1 -2))
         (grind))))
      ("2" (assert))))))


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


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("nx"))
   (typepred "nx")
   (expand "abs")
   (expand "<=")
   (expand "asin")
   (split -1)
   (("1"
     (assert)
     (lemma "both_sides_times_neg_lt1" ("nz" "-1" "x" "nx" "y" "-1"))
     (lemma "lt_times_lt_neg1" ("x" "-1" "ny" "nx" "z" "-1" "npw" "nx"))
     (assert)
     (lemma "sqrt_lt" ("nny" "0" "nnz" "1-nx*nx"))
     (rewrite "sqrt_0" -1)
     (lemma "atan_inv_neg_value" ("nx" "sqrt(1 - nx * nx) / nx"))
     (("1"
       (expand "pi" 1)
       (expand "atan" 1)
       (lemma "div_div1" ("x" "1" "n0y" "sqrt(1-nx*nx)" "n0z" "nx"))
       (replace -1 -2)
       (assert))
      ("2"
       (lemma "both_sides_div_neg_lt1"
        ("y" "0" "x" "sqrt(1-nx*nx)" "nz" "nx"))
       (assert))))
    ("2"
     (assert)
     (case "nx = -1")
     (("1" (replace -1) (rewrite "sqrt_0") (rewrite "atan_0") (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("px"))
   (typepred "px")
   (expand "<=" -2)
   (split -2)
   (("1"
     (hide -2)
     (expand "asin")
     (assert)
     (lemma "sq_nz_pos" ("nz" "px"))
     (expand "sq")
     (lemma "lt_times_lt_pos1" ("px" "px" "y" "1" "nnz" "px" "w" "1"))
     (assert)
     (lemma "sqrt_lt" ("nny" "0" "nnz" "1-px*px"))
     (rewrite "sqrt_0")
     (lemma "atan_inv_value" ("px" "sqrt(1 - px * px) / px"))
     (("1"
       (lemma "div_div1" ("x" "1" "n0y" "sqrt(1-px*px)" "n0z" "px"))
       (replace -1 -2)
       (expand "pi" 1)
       (expand "atan" 1)
       (assert))
      ("2"
       (lemma "posreal_div_posreal_is_posreal"
        ("px" "sqrt(1-px*px)" "py" "px"))
       (assert))))
    ("2"
     (expand "asin")
     (replace -1)
     (hide -1 -2)
     (rewrite "sqrt_0")
     (rewrite "atan_0")
     (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "atan_strict_increasing")
   (expand "strict_increasing?")
   (skolem 1 ("x" "y"))
   (flatten)
   (expand "asin")
   (case "abs(x) <= 1")
   (("1"
     (case "abs(y) <= 1")
     (("1"
       (case "FORALL (z:real): abs(z) < 1 => 0 < sqrt(1-z*z)")
       (("1"
         (expand "<=" (-2 -3))
         (split -3)
         (("1"
           (inst-cp -2 "x")
           (assert)
           (case "y = -1")
           (("1"
             (hide 1)
             (lemma "trichotomy" ("x" "x"))
             (split -1)
             (("1" (assert)) ("2" (assert))
              ("3" (expand "abs" -3) (assert))))
            ("2"
             (case "y < 1")
             (("1"
               (assert)
               (case "x= -1")
               (("1" (assert))
                ("2"
                 (inst -3 "y")
                 (split -5)
                 (("1"
                   (assert)
                   (inst - "x / sqrt(1 - x * x)" "y / sqrt(1 - y * y)")
                   (split -6)
                   (("1" (propax))
                    ("2"
                     (hide 4)
                     (lemma "div_mult_pos_lt1"
                      ("z"
                       "x"
                       "py"
                       "sqrt(1-x*x)"
                       "x"
                       "y / sqrt(1 - y * y)"))
                     (replace -1 1)
                     (lemma "div_mult_pos_lt2"
                      ("x" "x" "z" "y*sqrt(1-x*x)" "py" "sqrt(1-y*y)"))
                     (replace -1 1)
                     (hide -1 -2)
                     (lemma "trichotomy" ("x" "x"))
                     (split -1)
                     (("1"
                       (lemma "sq_lt"
                        ("nna"
                         "x * sqrt(1 - y * y)"
                         "nnb"
                         "y * sqrt(1 - x * x)"))
                       (("1"
                         (replace -1 1 rl)
                         (rewrite "sq_times" 1)
                         (rewrite "sq_times" 1)
                         (expand "sq" 1)
                         (lemma "sq_lt" ("nna" "x" "nnb" "y"))
                         (("1" (expand "sq" -1) (assert)) ("2" (assert))
                          ("3" (assert))))
                        ("2"
                         (lemma "posreal_times_posreal_is_posreal"
                          ("px" "y" "py" "sqrt(1-x*x)"))
                         (("1" (assert)) ("2" (assert))))
                        ("3"
                         (lemma "posreal_times_posreal_is_posreal"
                          ("px" "x" "py" "sqrt(1-y*y)"))
                         (("1" (assert)) ("2" (assert))))))
                      ("2" (replace -1) (rewrite "sqrt_1" 1) (assert))
                      ("3"
                       (case "y < 0")
                       (("1"
                         (lemma "both_sides_times_neg_lt1"
                          ("nz"
                           "-1"
                           "y"
                           "x * sqrt(1 - y * y)"
                           "x"
                           "y * sqrt(1 - x * x)"))
                         (replace -1 1 rl)
                         (lemma "sq_lt"
                          ("nna"
                           "(-1 *y) * sqrt(1 - x * x)"
                           "nnb"
                           "(-1*x) * sqrt(1 - y * y)"))
                         (("1"
                           (replace -1 1 rl)
                           (rewrite "sq_times" 1)
                           (expand "sq" 1 1)
                           (rewrite "sq_times" 1)
                           (rewrite "sq_times" 1)
                           (expand "sq" 1)
                           (hide -1 -2)
                           (assert)
                           (lemma "sq_lt" ("nna" "-1*y" "nnb" "-1*x"))
                           (expand "sq" -1)
                           (propax))
                          ("2"
                           (lemma "posreal_times_posreal_is_posreal"
                            ("px" "-1*x" "py" "sqrt(1-y*y)"))
                           (("1" (assert)) ("2" (assert))))
                          ("3"
                           (lemma "posreal_times_posreal_is_posreal"
                            ("px" "-1*y" "py" "sqrt(1-x*x)"))
                           (("1" (assert)) ("2" (assert))))))
                        ("2"
                         (lemma "nnreal_times_nnreal_is_nnreal"
                          ("nnx" "y" "nny" "sqrt(1 - x * x)"))
                         (("1"
                           (lemma "both_sides_times_pos_lt1"
                            ("x" "x" "y" "0" "pz" "sqrt(1 - y * y)"))
                           (assert))
                          ("2" (assert))))))))))
                  ("2"
                   (expand "abs" -1)
                   (lemma "trichotomy" ("x" "y"))
                   (split -1)
                   (("1" (assert)) ("2" (assert)) ("3" (assert))))))))
              ("2" (assert))))))
          ("2"
           (lemma "trichotomy" ("x" "x"))
           (expand "abs" -2)
           (split -1)
           (("1" (assert)) ("2" (assert))
            ("3"
             (assert)
             (case "y <1")
             (("1" (assert))
              ("2"
               (inst - "y")
               (split -4)
               (("1" (assert))
                ("2"
                 (typepred "atan(y / sqrt(1 - y * y))")
                 (("1" (assert)) ("2" (assert)) ("3" (assert))))))))))))
        ("2"
         (skosimp*)
         (assert)
         (hide 2)
         (hide -2 -3 -4 -5)
         (expand "abs")
         (lift-if)
         (ground)
         (("1" (mult-ineq -2 -2) (assert))
          ("2" (mult-ineq -1 -1) (assert))))
        ("3"
         (skosimp*)
         (assert)
         (assert)
         (hide 2)
         (hide -2 -3 -4 -5)
         (grind)
         (("1" (mult-ineq -2 -2) (assert))
          ("2" (mult-ineq -1 -1) (assert))))))
      ("2" (hide-all-but 1) (typepred "y") (grind))))
    ("2" (hide-all-but 1) (typepred "x") (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "bijective?")
   (split 1)
   (("1"
     (expand "injective?")
     (skolem 1 ("x" "y"))
     (flatten)
     (lemma "asin_strict_increasing")
     (expand "strict_increasing?")
     (lemma "trich_lt" ("x" "x" "y" "y"))
     (split -1)
     (("1" (inst - "x" "y") (assert)) ("2" (propax))
      ("3" (inst - "y" "x") (assert))))
    ("2"
     (lemma "atan_bij")
     (expand "bijective?")
     (flatten)
     (hide -1)
     (expand "surjective?")
     (skosimp*)
     (expand "asin")
     (case "abs(y!1) <= pi/2")
     (("1"
       (expand "<=" -1)
       (split -1)
       (("1"
         (inst - "y!1")
         (("1"
           (skosimp*)
           (inst + "x!1/sqrt(1+x!1*x!1)")
           (("1"
             (lemma "sq_pos" ("a" "x!1"))
             (expand "sq" -1)
             (lemma "sqrt_pos" ("px" "1+x!1*x!1"))
             (case "abs(x!1 / sqrt(1 + x!1 * x!1)) < 1")
             (("1"
               (case "x!1 / sqrt(1 + x!1 * x!1) /= -1")
               (("1"
                 (assert)
                 (case "x!1 / sqrt(1 + x!1 * x!1) * (x!1 / sqrt(1 + x!1 * x!1)) = sq(x!1)/(1+sq(x!1))")
                 (("1"
                   (replace -1 1)
                   (case "sqrt(1 - sq(x!1) / (1 + sq(x!1))) = 1/sqrt(1+x!1*x!1)")
                   (("1"
                     (replace -1 1)
                     (lemma "div_div2"
                      ("x"
                       "x!1"
                       "n0y"
                       "sqrt(1 + x!1 * x!1)"
                       "n0z"
                       "1 / sqrt(1 + x!1 * x!1)"))
                     (replace -1 1)
                     (lemma "sq_sqrt" ("x" "sqrt(1 + x!1 * x!1)"))
                     (assert))
                    ("2"
                     (hide 2)
                     (lemma "minus_div1"
                      ("x"
                       "1"
                       "n0x"
                       "1"
                       "y"
                       "sq(x!1)"
                       "n0y"
                       "1+sq(x!1)"))
                     (replace -1 1)
                     (simplify 1)
                     (rewrite "sqrt_div" 1)
                     (expand "sq" 1)
                     (propax))
                    ("3"
                     (hide 2)
                     (lemma "div_mult_pos_le1"
                      ("z" "sq(x!1)" "py" "1+sq(x!1)" "x" "1"))
                     (assert))))
                  ("2"
                   (hide 2)
                   (rewrite "sq_rew" 1)
                   (rewrite "sq_rew" 1)
                   (rewrite "sq_div" 1))))
                ("2" (assert))))
              ("2"
               (hide 2)
               (rewrite "abs_div" 1)
               (expand "abs" 1 2)
               (lemma "div_mult_pos_lt1"
                ("z" "abs(x!1)" "py" "sqrt(1 + x!1 * x!1)" "x" "			  1"))
               (("1"
                 (replace -1 1)
                 (lemma "sq_lt"
                  ("nna" "abs(x!1)" "nnb" "sqrt(1 + x!1 * x!1)"))
                 (replace -1 1 rl)
                 (rewrite "sq_sqrt" 1)
                 (expand "abs" 1)
                 (case "x!1<0")
                 (("1" (assert) (expand "sq" 1) (assert))
                  ("2" (assert) (expand "sq") (assert))))
                ("2" (propax))))
              ("3" (assert))))
            ("2"
             (hide -1 -2)
             (lemma "sq_pos" ("a" "x!1"))
             (expand "sq" -1)
             (lemma "sqrt_pos" ("px" "1+x!1*x!1"))
             (case "abs(x!1) / sqrt(1 + x!1 * x!1) < 1")
             (("1"
               (cross-mult -1)
               (prop)
               (("1" (cross-mult 1) (expand "abs") (lift-if) (ground))
                ("2" (cross-mult 1) (assert))))
              ("2"
               (hide 2)
               (lemma "div_mult_pos_lt1"
                ("z" "abs(x!1)" "py" "sqrt(1 + x!1 * x!1)" "x" "			  1"))
               (("1"
                 (replace -1 1)
                 (lemma "sq_lt"
                  ("nna" "abs(x!1)" "nnb" "sqrt(1 + x!1 * x!1)"))
                 (replace -1 1 rl)
                 (rewrite "sq_sqrt" 1)
                 (expand "abs" 1)
                 (case "x!1<0")
                 (("1" (assert) (expand "sq" 1) (assert))
                  ("2" (assert) (expand "sq") (assert))))
                ("2" (propax))))
              ("3" (assert))))
            ("3"
             (lemma "sq_pos" ("a" "x!1"))
             (expand "sq" -1)
             (lemma "sqrt_pos" ("px" "1+x!1*x!1"))
             (assert))))
          ("2" (expand "pi" -1) (hide 2) (assert) (grind))))
        ("2"
         (expand "abs" -1)
         (case "y!1<0")
         (("1" (assert) (inst + "-1") (assert))
          ("2" (assert) (inst + "1") (assert))))))
      ("2" (hide -1 2) (typepred "y!1") (grind))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("nnx" "nny"))
   (typepred "nnx")
   (typepred "nny")
   (expand ">=")
   (expand "<=" (-4 -1))
   (split -4)
   (("1"
     (expand "<=" -4)
     (split -4)
     (("1"
       (split -3)
       (("1"
         (expand "<=" -4)
         (split -4)
         (("1"
           (expand "asin")
           (lemma "sq_lt" ("nna" "nnx" "nnb" "1"))
           (lemma "sq_lt" ("nna" "nny" "nnb" "1"))
           (rewrite "sq_1")
           (lemma "sq_lt" ("nnb" "nnx" "nna" "0"))
           (lemma "sq_lt" ("nnb" "nny" "nna" "0"))
           (rewrite "sq_0")
           (assert)
           (rewrite "sq_rew" 1)
           (rewrite "sq_rew" 1)
           (rewrite "sq_rew" 1)
           (rewrite "sq_rew" 1)
           (rewrite "sq_sqrt" 1)
           (rewrite "sq_sqrt" 1)
           (simplify 1)
           (rewrite "sq_rew" 1)
           (rewrite "sq_rew" 1)
           (lemma "sqrt_pos" ("px" "1-sq(nnx)"))
           (lemma "sqrt_pos" ("px" "1-sq(nny)"))
           (lemma "sqrt_lt" ("nny" "1-sq(nnx)" "nnz" "1"))
           (lemma "sqrt_lt" ("nny" "1-sq(nny)" "nnz" "1"))
           (rewrite "sqrt_1")
           (assert)
           (lemma "lt_times_lt_pos1"
            ("px" "nny" "y" "1" "nnz" "(sqrt(1 - sq(nnx)))" "w" "1"))
           (assert)
           (lemma "lt_times_lt_pos1"
            ("px" "nnx" "y" "1" "nnz" "(sqrt(1 - sq(nny)))" "w" "1"))
           (assert)
           (lemma "atan_minus"
            ("x"
             "nnx / sqrt(1 - sq(nnx))"
             "y"
             "nny / sqrt(1 - sq(nny))"))
           (lemma "posreal_div_posreal_is_posreal"
            ("px" "nnx" "py" "sqrt(1-sq(nnx))"))
           (lemma "posreal_div_posreal_is_posreal"
            ("px" "nny" "py" "sqrt(1-sq(nny))"))
           (assert)
           (flatten -3)
           (lemma "posreal_times_posreal_is_posreal"
            ("px"
             "nnx / sqrt(1 - sq(nnx))"
             "py"
             "nny / sqrt(1 - sq(nny))"))
           (assert)
           (hide -5)
           (name-replace "SQX" "sqrt(1 - sq(nnx))")
           (name-replace "SQY" "sqrt(1 - sq(nny))")
           (lemma "minus_div1"
            ("x" "nnx" "n0x" "SQX" "y" "nny" "n0y" "SQY"))
           (("1"
             (replace -1 -5)
             (rewrite "div_div2" -5)
             (("1"
               (lemma "div_cancel1" ("n0z" "SQX*SQY" "x" "nnx*nny"))
               (("1"
                 (replace -1 -6)
                 (case "sq(SQX * SQY + nnx * nny) = 1 - sq(nnx) - sq(nny) + sq(nnx) * nny * nny +
                                          sq(nny) * nnx * nnx
                                          + 2 * (SQX * SQY * nnx * nny)")
                 (("1" (replace -1 1 rl) (rewrite "sqrt_sq" 1))
                  ("2"
                   (hide 2)
                   (expand "SQX" 1)
                   (expand "SQY" 1)
                   (expand "sq" 1)
                   (assert))))
                ("2"
                 (hide 2)
                 (lemma "posreal_times_posreal_is_posreal"
                  ("px" "SQX" "py" "SQY"))
                 (assert))))
              ("2"
               (hide 2)
               (lemma "posreal_times_posreal_is_posreal"
                ("px" "nnx / SQX" "py" "nny/SQY"))
               (lemma "lt_plus_lt1"
                ("x" "0" "y" "1" "z" "0" "w" "nnx / SQX * (nny / SQY)"))
               (name-replace "K1" "nnx / SQX * (nny / SQY)")
               (assert))
              ("3"
               (lemma "posreal_times_posreal_is_posreal"
                ("px" "SQX" "py" "SQY"))
               (assert))))
            ("2" (assert)) ("3" (assert))))
          ("2"
           (replace -1)
           (rewrite "asin_1")
           (rewrite "sq_1")
           (rewrite "sqrt_0")
           (simplify 1)
           (hide -1 -2)
           (lemma "asin_neg" ("x" "sqrt(1 - sq(nnx))"))
           (("1"
             (replace -1 1)
             (expand "asin")
             (hide -1)
             (lemma "sq_lt" ("nna" "0" "nnb" "nnx"))
             (lemma "sq_lt" ("nnb" "1" "nna" "nnx"))
             (rewrite "sq_0")
             (rewrite "sq_1")
             (assert)
             (rewrite "sq_rew" 1)
             (rewrite "sq_rew" 1)
             (rewrite "sq_sqrt")
             (simplify 1)
             (lemma "sqrt_lt" ("nny" "1-sq(nnx)" "nnz" "1"))
             (rewrite "sqrt_1")
             (assert)
             (expand "pi" 1)
             (expand "atan" 1)
             (rewrite "sqrt_sq" 1)
             (lemma "sq_lt" ("nna" "0" "nnb" "nnx"))
             (rewrite "sq_0")
             (lemma "sqrt_pos" ("px" "1-sq(nnx)"))
             (lemma "posreal_div_posreal_is_posreal"
              ("px" "sqrt(1-sq(nnx))" "py" "nnx"))
             (lemma "atan_inv_value" ("px" "sqrt(1 - sq(nnx)) / nnx"))
             (("1" (rewrite "div_div1" -1) (assert)) ("2" (assert))))
            ("2"
             (hide 2)
             (expand "abs")
             (lemma "sqrt_le")
             (inst - "1-sq(nnx)" "1")
             (rewrite "sqrt_1")
             (lemma "sq_le" ("nna" "0" "nnb" "nnx"))
             (rewrite "sq_0")
             (assert))))))
        ("2"
         (replace -1 * rl)
         (rewrite "asin_0")
         (rewrite "sq_0")
         (rewrite "sqrt_1")
         (simplify 1)
         (propax))))
      ("2"
       (replace -1 * rl)
       (rewrite "asin_0")
       (rewrite "sq_0")
       (rewrite "sqrt_1")
       (simplify 1)
       (lemma "asin_neg" ("x" "nny"))
       (("1" (assert)) ("2" (expand "abs" 1) (propax))))))
    ("2"
     (replace -1)
     (rewrite "sq_1")
     (rewrite "sqrt_0")
     (rewrite "asin_1")
     (lemma "sq_le" ("nna" "nny" "nnb" "1"))
     (expand "sq" -1 2)
     (expand "asin")
     (expand "<=" -4)
     (split -4)
     (("1"
       (assert)
       (typepred "sqrt(1 - sq(nny))")
       (assert)
       (split -6)
       (("1"
         (hide -5 -6 -7 -3 -2)
         (lemma "sq_lt" ("nna" "0" "nnb" "nny"))
         (lemma "sq_lt" ("nnb" "1" "nna" "nny"))
         (assert)
         (rewrite "sq_0")
         (rewrite "sq_1")
         (rewrite "sq_rew" 1)
         (rewrite "sq_rew" 1)
         (rewrite "sq_sqrt" 1)
         (simplify 1)
         (rewrite "sqrt_sq" 1)
         (lemma "sqrt_lt")
         (inst - "1-sq(nny)" "1")
         (rewrite "sqrt_1" -1)
         (assert)
         (expand "pi")
         (expand "atan")
         (lemma "atan_inv_value" ("px" "(sqrt(1 - sq(nny))) / nny"))
         (("1" (assert))
          ("2"
           (hide 2)
           (lemma "sqrt_lt")
           (inst - "0" "1-sq(nny)")
           (rewrite "sqrt_0" -1)
           (lemma "posreal_div_posreal_is_posreal"
            ("px" "sqrt(1 - sq(nny))" "py" "nny"))
           (assert))))
        ("2"
         (replace -1 * rl)
         (rewrite "sq_0" 1)
         (rewrite "sqrt_1")
         (rewrite "atan_0")
         (assert))))
      ("2"
       (replace -1)
       (rewrite "sq_1")
       (simplify 1)
       (rewrite "sqrt_0")
       (rewrite "sqrt_1")
       (rewrite "atan_0")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("z"))
   (expand "asin")
   (lemma "extensionality"
    ("f"
     "(LAMBDA (x: real_abs_lt1):
                               IF x = -1 THEN -pi / 2
                               ELSIF x < 1 THEN atan(x / sqrt(1 - x * x))
                               ELSE pi / 2
                               ENDIF)"
     "g"
     "LAMBDA (x:real_abs_lt1): atan(x / sqrt(1 - x * x))"))
   (("1"
     (split -1)
     (("1"
       (hide -1)
       (lemma "identity_derivable_fun[real_abs_lt1]")
       (lemma "const_derivable_fun[real_abs_lt1]" ("b" "1"))
       (expand "I")
       (lemma "prod_derivable_fun[real_abs_lt1]"
        ("f1"
         "LAMBDA (x: real_abs_lt1): x"
         "f2"
         "LAMBDA (x: real_abs_lt1): x"))
       (assert)
       (expand "*")
       (lemma "diff_derivable_fun[real_abs_lt1]"
        ("f1"
         "LAMBDA (x: real_abs_lt1): 1"
         "f2"
         "LAMBDA (x_1: real_abs_lt1): x_1 * x_1"))
       (assert)
       (expand "-")
       (lemma "sqrt_derivable_fun")
       (expand "restrict")
       (lemma "composition_derivable_fun[real_abs_lt1,posreal]"
        ("f"
         "LAMBDA (x_1: real_abs_lt1): 1 - x_1 * x_1"
         "g"
         "LAMBDA (s: posreal): sqrt(s)"))
       (("1"
         (assert)
         (expand "o")
         (lemma "div_derivable_fun[real_abs_lt1]"
          ("f"
           "LAMBDA (x:real_abs_lt1): x"
           "g"
           "LAMBDA (x: real_abs_lt1): sqrt(1 - x * x)"))
         (assert)
         (expand "/")
         (lemma "deriv_atan_fun")
         (flatten -1)
         (lemma "composition_derivable_fun[real_abs_lt1,real]"
          ("f"
           "LAMBDA (x_1: real_abs_lt1): x_1 / sqrt(1 - x_1 * x_1)"
           "g"
           "atan"))
         (("1"
           (assert)
           (expand "o" -1)
           (expand "derivable?" -1)
           (inst - "z"))
          ("2"
           (hide-all-but 1)
           (assert)
           (expand "not_one_element?")
           (skosimp*)
           (assert)
           (inst + "x!1+1")
           (assert))
          ("3" (lemma deriv_domain_real) (propax))))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!1")
         (mult-ineq -2 -2)
         (("1" (assert)) ("2" (grind))))
        ("3"
         (hide-all-but 1)
         (assert)
         (expand "not_one_element?")
         (skosimp*)
         (inst + "x!1+1")
         (assert))
        ("4" (hide-all-but 1) (lemma deriv_domain_posreal) (propax))))
      ("2"
       (hide-all-but 1)
       (skosimp*)
       (typepred "x!1")
       (case "x!1=-1")
       (("1" (replace -1) (assert))
        ("2" (case "x!1<1") (("1" (assert)) ("2" (propax))))))))
    ("2"
     (hide-all-but 1)
     (skosimp*)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (expand "sq" -1)
     (expand "abs" -1 2)
     (lemma "sqrt_pos" ("px" "1-x!1*x!1"))
     (("1" (mult-ineq -4 -4) (assert)) ("2" (assert) (grind))))
    ("3"
     (hide-all-but 1)
     (skosimp*)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (expand "sq")
     (expand "abs" -1 2)
     (assert)
     (hide-all-but 1)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (expand "sq")
     (assert)
     (hide-all-but 1)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (expand "abs" -1 2)
     (expand "sq")
     (grind))
    ("4"
     (hide-all-but 1)
     (skosimp*)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (expand "sq")
     (case-replace "abs(x!1) < 1")
     (("1" (assert)) ("2" (grind))))
    ("5"
     (hide-all-but 1)
     (skosimp*)
     (typepred "x!1")
     (mult-ineq -2 -2)
     (("1" (assert)) ("2" (grind))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "asin")
   (lemma "extensionality"
    ("f"
     "(LAMBDA (x: real_abs_lt1):
                        IF x = -1 THEN -pi / 2
                        ELSIF x < 1 THEN atan(x / sqrt(1 - x * x))
                        ELSE pi / 2
                        ENDIF)"
     "g"
     "LAMBDA (x: real_abs_lt1): atan(x / sqrt(1 - x * x))"))
   (("1"
     (split -1)
     (("1"
       (lemma "identity_derivable_fun[real_abs_lt1]")
       (lemma "deriv_id_fun[real_abs_lt1]")
       (lemma "const_derivable_fun[real_abs_lt1]" ("b" "1"))
       (lemma "deriv_const_fun[real_abs_lt1]" ("b" "1"))
       (expand "I")
       (lemma "prod_derivable_fun[real_abs_lt1]"
        ("f1"
         "LAMBDA (x: real_abs_lt1): x"
         "f2"
         "LAMBDA (x: real_abs_lt1): x"))
       (assert)
       (expand "*" -1)
       (lemma "deriv_prod_fun[real_abs_lt1]"
        ("ff1"
         "LAMBDA (x: real_abs_lt1): x"
         "ff2"
         "LAMBDA (x: real_abs_lt1): x"))
       (replace -5 -1)
       (expand "*" -1)
       (expand "+")
       (lemma "diff_derivable_fun[real_abs_lt1]"
        ("f1"
         "LAMBDA (x: real_abs_lt1): 1"
         "f2"
         "LAMBDA (x_1: real_abs_lt1): x_1 * x_1"))
       (assert)
       (expand "-" -1)
       (lemma "deriv_diff_fun[real_abs_lt1]"
        ("ff1"
         "LAMBDA (x: real_abs_lt1): 1"
         "ff2"
         "LAMBDA (x_1: real_abs_lt1): x_1 * x_1"))
       (replace -3 -1)
       (replace -5 -1)
       (expand "-" -1)
       (lemma "sqrt_derivable_fun")
       (lemma "deriv_sqrt_fun")
       (expand "restrict" (-1 -2))
       (lemma "composition_derivable_fun[real_abs_lt1,posreal]"
        ("g"
         "LAMBDA (x: posreal): sqrt(x)"
         "f"
         "LAMBDA (x_1: real_abs_lt1): 1 - x_1 * x_1"))
       (("1"
         (replace -3 -1)
         (replace -5 -1)
         (expand "o")
         (lemma "deriv_comp_fun[real_abs_lt1,posreal]"
          ("gg"
           "LAMBDA (x: posreal): sqrt(x)"
           "ff"
           "LAMBDA (x_1: real_abs_lt1): 1 - x_1 * x_1"))
         (("1"
           (expand "o" -1)
           (replace -3 -1)
           (replace -5 -1)
           (expand "*" -1)
           (lemma "div_derivable_fun[real_abs_lt1]"
            ("f"
             "LAMBDA (x: real_abs_lt1): x"
             "g"
             "LAMBDA (x_1: real_abs_lt1): sqrt(1 - x_1 * x_1)"))
           (assert)
           (expand "/" -1)
           (lemma "deriv_div_fun[real_abs_lt1]"
            ("ff"
             "LAMBDA (x: real_abs_lt1): x"
             "gg"
             "LAMBDA (x_1: real_abs_lt1): sqrt(1 - x_1 * x_1)"))
           (replace -13 -1)
           (replace -3 -1)
           (expand "/" -1)
           (expand "*" -1)
           (expand "-" -1)
           (lemma "deriv_atan_fun")
           (flatten -1)
           (lemma "composition_derivable_fun[real_abs_lt1,real]"
            ("f"
             "LAMBDA (x_1: real_abs_lt1): x_1 / sqrt(1 - x_1 * x_1)"
             "g"
             "atan"))
           (("1"
             (expand "o" -1)
             (assert)
             (lemma "deriv_comp_fun[real_abs_lt1,real]"
              ("ff"
               "LAMBDA (x_1: real_abs_lt1): x_1 / sqrt(1 - x_1 * x_1)"
               "gg"
               "atan"))
             (replace -4 -1)
             (replace -5 -1)
             (expand "o" -1)
             (expand "*" -1)
             (replace -1 1)
             (hide-all-but 1)
             (lemma "extensionality"
              ("f"
               "(LAMBDA (x: real_abs_lt1):
                                                  1 / (1 + x / sqrt(1 - x * x) * (x / sqrt(1 - x * x))) *
                                                   ((sqrt(1 - x * x) + 2 * (x * x * (1 / (2 * sqrt(1 - x * x))))) /
                                                     (sqrt(1 - x * x) * sqrt(1 - x * x))))"
               "g"
               "(LAMBDA (x: real_abs_lt1): 1 / sqrt(1 - sq(x)))"))
             (("1"
               (split -1)
               (("1" (propax))
                ("2"
                 (hide 2)
                 (skolem 1 ("z"))
                 (typepred "z")
                 (lemma "sq_lt_abs" ("a" "z" "b" "1"))
                 (expand "abs" -1 2)
                 (expand "sq")
                 (lemma "sqrt_pos" ("px" "1-z*z"))
                 (("1"
                   (lemma "sq_sqrt" ("x" "1-z*z"))
                   (expand "sq")
                   (assert))
                  ("2" (assert))))))
              ("2"
               (hide 2)
               (skolem 1 ("z"))
               (lemma "sq_lt_abs" ("a" "z" "b" "1"))
               (expand "sq")
               (typepred "z")
               (lemma "sqrt_pos" ("px" "1-z*z"))
               (("1" (assert)) ("2" (assert) (grind))))
              ("3"
               (hide 2)
               (skolem 1 ("z"))
               (typepred "z")
               (lemma "sq_lt_abs" ("a" "z" "b" "1"))
               (expand "abs" -1 2)
               (expand "sq")
               (assert)
               (grind))
              ("4"
               (hide 2)
               (skolem 1 ("z"))
               (typepred "z")
               (lemma "sq_lt_abs" ("a" "z" "b" "1"))
               (expand "abs" -1 2)
               (expand "sq")
               (lemma "sq_sqrt" ("x" "1-z*z"))
               (expand "sq")
               (assert)
               (grind))
              ("5"
               (hide 2)
               (skolem 1 ("z"))
               (typepred "z")
               (lemma "sq_lt_abs" ("a" "z" "b" "1"))
               (expand "abs" -1 2)
               (expand "sq")
               (lemma "sqrt_pos" ("px" "1-z*z"))
               (("1" (assert)) ("2" (assert) (grind))))
              ("6"
               (hide 2)
               (skolem 1 ("z"))
               (typepred "z")
               (lemma "sq_lt_abs" ("a" "z" "b" "1"))
               (expand "abs" -1 2)
               (expand "sq")
               (lemma "sqrt_pos" ("px" "1-z*z"))
               (("1"
                 (lemma "sq_sqrt" ("x" "1-z*z"))
                 (expand "sq" -1)
                 (lemma "div_times"
                  ("x"
                   "z"
                   "y"
                   "z"
                   "n0x"
                   "sqrt(1 - z * z)"
                   "n0y"
                   "sqrt(1 - z * z)"))
                 (("1"
                   (replace -1 1)
                   (split -2)
                   (("1"
                     (replace -1)
                     (lemma "div_mult_pos_lt2"
                      ("x" "-1" "z" "z*z" "py" "1-z*z"))
                     (assert))
                    ("2" (assert))))
                  ("2" (assert))))
                ("2" (assert))))))
            ("2"
             (hide-all-but 1)
             (expand "not_one_element?")
             (skosimp*)
             (inst + "x!1+1")
             (assert))
            ("3" (lemma deriv_domain_real) (propax))))
          ("2" (propax)) ("3" (propax))))
        ("2"
         (hide-all-but 1)
         (skosimp*)
         (typepred "x!1")
         (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
         (grind))
        ("3"
         (hide-all-but 1)
         (assert)
         (expand "not_one_element?")
         (skosimp*)
         (inst + "x!1+1")
         (assert))
        ("4" (hide-all-but 1) (lemma deriv_domain_posreal) (propax))))
      ("2"
       (hide 2)
       (skosimp*)
       (typepred "x!1")
       (case "x!1 = -1")
       (("1" (assert))
        ("2" (case "x!1<1") (("1" (assert)) ("2" (propax))))))))
    ("2"
     (hide 2)
     (skosimp*)
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (typepred "x!1")
     (expand "sq")
     (lemma "sqrt_pos" ("px" "1-x!1*x!1"))
     (("1" (assert)) ("2" (assert) (grind))))
    ("3"
     (hide 2)
     (skosimp*)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (grind))
    ("4"
     (hide 2)
     (skosimp*)
     (case "abs(x!1) < 1")
     (("1"
       (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
       (expand "abs" -1 2)
       (expand "sq" -1)
       (lemma "sqrt_pos" ("px" "1-x!1*x!1"))
       (("1" (assert)) ("2" (assert))))
      ("2" (typepred "x!1") (grind))))
    ("5"
     (hide 2)
     (skosimp*)
     (typepred "x!1")
     (lemma "sq_lt_abs" ("a" "x!1" "b" "1"))
     (expand "abs" -1 2)
     (expand "sq")
     (assert)
     (grind))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: asin
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (split)
   (("1"
     (lemma "asin_derivable_fun")
     (lemma "deriv_asin_fun")
     (lemma "identity_derivable_fun[real_abs_lt1]")
     (lemma "deriv_id_fun[real_abs_lt1]")
     (expand "I")
     (lemma "diff_derivable_fun[real_abs_lt1]"
      ("f1"
       "LAMBDA (x: real_abs_lt1): asin(x)"
       "f2"
       "LAMBDA (x: real_abs_lt1): x"))
     (assert)
     (expand "-")
     (lemma "deriv_diff_fun[real_abs_lt1]"
      ("ff1"
       "LAMBDA (x: real_abs_lt1): asin(x)"
       "ff2"
       "LAMBDA (x: real_abs_lt1): x"))
     (replace -5 -1)
     (replace -3 -1)
     (expand "-")
     (typepred "px!1")
     (hide -1)
     (expand "<=" -1)
     (split -1)
     (("1"
       (lemma "minimum_derivative[{x:nnreal| x < 1}]"
        ("g"
         "LAMBDA (x_1:{x:nnreal| x < 1} ): asin(x_1) - x_1"
         "x"
         "0"
         "y1"
         "px!1"))
       (("1"
         (split -1)
         (("1" (simplify -1) (rewrite "asin_0") (assert))
          ("2"
           (lemma "restrict2_deriv[{x: nnreal | x < 1},real_abs_lt1]"
            ("f" "LAMBDA (x_1: real_abs_lt1): asin(x_1) - x_1" "a" "0"))
           (("1"
             (replace -4 -1)
             (simplify -1)
             (expand "restrict2" -1)
             (replace -1 1 rl)
             (expand "sq" 1)
             (rewrite "sqrt_1")
             (assert))
            ("2" (propax)) ("3" (skosimp*) (inst + "x!1"))))
          ("3" (assert))
          ("4"
           (skosimp*)
           (typepred "y!1")
           (expand ">=" -1)
           (expand "<=" -1)
           (split -1)
           (("1"
             (lemma "restrict2_deriv[{x: nnreal | x < 1},real_abs_lt1]"
              ("f"
               "LAMBDA (x_1: real_abs_lt1): asin(x_1) - x_1"
               "a"
               "y!1"))
             (("1"
               (replace -6 -1)
               (simplify -1)
               (expand "restrict2" -1)
               (replace -1 2 rl)
               (hide -1 -6 3 1 -7 -8 -9 -10 -11)
               (lemma "sq_lt" ("nna" "0" "nnb" "y!1"))
               (lemma "sq_lt" ("nna" "y!1" "nnb" "1"))
               (expand "sq" -1 2)
               (expand "sq" -2 1)
               (assert)
               (lemma "sqrt_pos" ("px" "1-sq(y!1)"))
               (lemma "div_mult_pos_gt2"
                ("z" "1" "py" "sqrt(1-sq(y!1))" "x" "1"))
               (lemma "sqrt_lt" ("nny" "1-sq(y!1)" "nnz" "1"))
               (rewrite "sqrt_1")
               (assert)
               (lemma "posreal_times_posreal_is_posreal"
                ("px" "1 / sqrt(1 - sq(y!1))-1" "py" "y!1"))
               (assert))
              ("2" (propax)) ("3" (skosimp*) (inst + "x!1"))))
            ("2" (assert))))))
        ("2" (propax))
        ("3"
         (lemma "restrict2_derivable[{x: nnreal | x < 1},real_abs_lt1]"
          ("f" "LAMBDA (x_1: real_abs_lt1): asin(x_1) - x_1"))
         (("1" (expand "restrict2" -1) (propax)) ("2" (propax))
          ("3" (skosimp*) (typepred "x!1") (inst + "x!1"))))
        ("4"
         (hide-all-but 1)
         (expand "connected?")
         (skosimp*)
         (assert))))
      ("2"
       (replace -1)
       (rewrite "asin_1")
       (lemma "pi_bnds")
       (flatten)
       (assert))))
    ("2"
     (flatten)
     (case "px!1 < sqrt(6)")
     (("1"
       (typepred "px!1")
       (lemma "identity_derivable_fun[{x:nnreal| x <= 1}]")
       (("1"
         (lemma "deriv_id_fun[{x:nnreal| x <= 1}]")
         (expand "I")
         (lemma "const_derivable_fun[{x:nnreal| x <= 1}]" ("b" "1"))
         (lemma "deriv_const_fun[{x:nnreal| x <= 1}]" ("b" "1"))
         (lemma "prod_derivable_fun[{x:nnreal| x <= 1}]"
          ("f1"
           "LAMBDA (x: {x: nnreal | x <= 1}): x"
           "f2"
           "LAMBDA (x: {x: nnreal | x <= 1}): x"))
         (assert)
         (expand "*" -1)
         (lemma "deriv_prod_fun[{x:nnreal| x <= 1}]"
          ("ff1"
           "LAMBDA (x: {x: nnreal | x <= 1}): x"
           "ff2"
           "LAMBDA (x: {x: nnreal | x <= 1}): x"))
         (replace -5 -1)
         (expand "*")
         (expand "+")
         (lemma "scal_derivable_fun[{x:nnreal| x <= 1}]"
          ("f"
           "LAMBDA (x_1: {x: nnreal | x <= 1}): x_1 * x_1"
           "b"
           "1/6"))
         (assert)
         (expand "*")
         (lemma "deriv_scal_fun[{x:nnreal| x <= 1}]"
          ("ff"
           "LAMBDA (x_1: {x: nnreal | x <= 1}): x_1 * x_1"
           "b"
           "1/6"))
         (replace -3 -1)
         (expand "*" -1)
         (lemma "diff_derivable_fun[{x:nnreal| x <= 1}]"
          ("f1"
           "LAMBDA (x: {x: nnreal | x <= 1}): 1"
           "f2"
           "LAMBDA (x: {x: nnreal | x <= 1}): 1 / 6 * (x * x)"))
         (assert)
         (expand "-")
         (lemma "deriv_diff_fun[{x:nnreal| x <= 1}]"
          ("ff1"
           "LAMBDA (x: {x: nnreal | x <= 1}): 1"
           "ff2"
           "LAMBDA (x: {x: nnreal | x <= 1}): 1 / 6 * (x * x)"))
         (replace -7 -1)
         (replace -3 -1)
         (expand "-")
         (lemma "prod_derivable_fun[{x:nnreal| x <= 1}]"
          ("f1"
           "LAMBDA (x: {x: nnreal | x <= 1}): x"
           "f2"
           "LAMBDA (x_1: {x: nnreal | x <= 1}): 1 - 1 / 6 * (x_1 * x_1)"))
         (assert)
         (expand "*")
         (lemma "deriv_prod_fun[{x:nnreal| x <= 1}]"
          ("ff1"
           "LAMBDA (x: {x: nnreal | x <= 1}): x"
           "ff2"
           "LAMBDA (x_1: {x: nnreal | x <= 1}): 1 - 1 / 6 * (x_1 * x_1)"))
         (replace -3 -1)
         (replace -11 -1)
         (expand "*")
         (expand "+")
         (lemma "asin_derivable_fun")
         (lemma "deriv_asin_fun")
         (tccs-step
          (lemma
           "composition_derivable_fun[{x: nnreal | x <= 1},real_abs_lt1]"
           ("f"
            "LAMBDA (x_1: {x: nnreal | x <= 1}): x_1 - x_1 * x_1 * x_1 * (1 / 6)"
            "g"
            "LAMBDA (x: real_abs_lt1): asin(x)"))
          :label "TCC" :hide? t)
         (("1"
           (assert)
           (expand "o")
           (lemma "deriv_comp_fun[{x: nnreal | x <= 1},real_abs_lt1]"
            ("ff"
             "LAMBDA (x_1: {x: nnreal | x <= 1}): x_1 - x_1 * x_1 * x_1 * (1 / 6)"
             "gg"
             "LAMBDA (x: real_abs_lt1): asin(x)"))
           (("1"
             (replace -3 -1)
             (replace -5 -1)
             (expand "o")
             (expand "*")
             (lemma "diff_derivable_fun[{x:nnreal| x <= 1}]"
              ("f1"
               "LAMBDA (x: {x: nnreal | x <= 1}): x"
               "f2"
               "LAMBDA (x_1: {x: nnreal | x <= 1}): asin(x_1 - x_1 * x_1 * x_1 * (1 / 6))"))
             (("1"
               (expand "-")
               (assert)
               (lemma "deriv_diff_fun[{x:nnreal| x <= 1}]"
                ("ff1"
                 "LAMBDA (x: {x: nnreal | x <= 1}): x"
                 "ff2"
                 "LAMBDA (x_1: {x: nnreal | x <= 1}): asin(x_1 - x_1 * x_1 * x_1 * (1 / 6))"))
               (("1"
                 (replace -3 -1)
                 (replace -17 -1)
                 (expand "-")
                 (lemma "minimum_derivative[{x: nnreal | x <= 1}]"
                  ("g"
                   "LAMBDA (x_1: {x: nnreal | x <= 1}): x_1 - asin(x_1 - x_1 * x_1 * x_1 * (1 / 6))"
                   "x"
                   "0"
                   "y1"
                   "px!1"))
                 (("1"
                   (split -1)
                   (("1"
                     (simplify -1)
                     (assert)
                     (rewrite "asin_0")
                     (assert))
                    ("2"
                     (hide 2)
                     (replace -1 1)
                     (simplify 1)
                     (rewrite "sq_0")
                     (rewrite "sqrt_1")
                     (assert))
                    ("3" (assert))
                    ("4"
                     (replace -1 1)
                     (hide-all-but 1)
                     (skosimp*)
                     (typepred "y!1")
                     (expand ">=" -1)
                     (expand "<=" -1)
                     (split -1)
                     (("1"
                       (hide 1)
                       (name "AP" "y!1 - y!1 * y!1 * y!1 * (1 / 6)")
                       (replace -1)
                       (lemma "sq_le" ("nna" "y!1" "nnb" "1"))
                       (expand "sq" -1)
                       (lemma "posreal_times_posreal_is_posreal"
                        ("px" "y!1" "py" "1-y!1 * y!1 / 6"))
                       (("1"
                         (expand "<=" -5)
                         (split -5)
                         (("1"
                           (lemma "sq_lt" ("nna" "y!1" "nnb" "1"))
                           (rewrite "sq_rew")
                           (rewrite "sq_1")
                           (flatten -1)
                           (replace -3 -2)
                           (hide -1)
                           (hide -4)
                           (lemma "lt_times_lt_pos1"
                            ("px"
                             "y!1"
                             "y"
                             "1"
                             "nnz"
                             "1 - sq(y!1) / 6"
                             "w"
                             "1"))
                           (("1"
                             (split -1)
                             (("1"
                               (replace -5)
                               (lemma "sq_lt" ("nna" "AP" "nnb" "1"))
                               (("1"
                                 (expand "sq" -1)
                                 (assert)
                                 (rewrite "sq_rew" -1)
                                 (lemma "sq_lt" ("nna" "0" "nnb" "AP"))
                                 (rewrite "sq_0")
                                 (assert)
                                 (case "1-sq(AP) > 0")
                                 (("1"
                                   (lemma
                                    "sqrt_lt"
                                    ("nny" "0" "nnz" "1-sq(AP)"))
                                   (rewrite "sqrt_0")
                                   (flatten -1)
                                   (expand ">" -3)
                                   (replace -3 -2)
                                   (hide -1)
                                   (lemma
                                    "posreal_times_posreal_is_posreal"
                                    ("px"
                                     "(sq(y!1)/2-1)/sqrt(1 - sq(AP))+1"
                                     "py"
                                     "y!1"))
                                   (("1" (assert))
                                    ("2"
                                     (hide 2)
                                     (case "1-sq(y!1)/2 > 0")
                                     (("1"
                                       (lemma
                                        "div_mult_pos_lt1"
                                        ("x"
                                         "1"
                                         "z"
                                         "1 - sq(y!1) / 2"
                                         "py"
                                         "sqrt(1 - sq(AP))"))
                                       (lemma
                                        "sq_lt"
                                        ("nna"
                                         "1 - sq(y!1) / 2"
                                         "nnb"
                                         "sqrt(1 - sq(AP))"))
                                       (rewrite "sq_sqrt" -1)
                                       (case
                                        "sq(1 - sq(y!1) / 2) < 1 - sq(AP)")
                                       (("1" (assert))
                                        ("2"
                                         (hide 2 -1 -2)
                                         (expand "AP" 1)
                                         (expand "sq" 1 1)
                                         (simplify 1)
                                         (expand "sq" 1)
                                         (lemma
                                          "div_cancel1"
                                          ("x" "y!1*y!1" "n0z" "2"))
                                         (replace -1 1)
                                         (lemma
                                          "both_sides_minus_lt1"
                                          ("x"
                                           "1 + y!1 * y!1 / 2 * (y!1 * y!1 / 2) - y!1 * y!1"
                                           "y"
                                           "1 - (1 / 6) * (1 / 6) * y!1 * y!1 * y!1 * y!1 * y!1 * y!1 -
                                                                                                                                                                                                                                                                                                                y!1 * y!1
                                                                                                                                                                                                                                                                                                                + (1 / 3) * y!1 * y!1 * y!1 * y!1"
                                           "z"
                                           "1-y!1*y!1"))
                                         (replace -1 1 rl)
                                         (simplify 1)
                                         (hide -1)
                                         (lemma
                                          "both_sides_times_pos_lt1"
                                          ("x"
                                           "1/4"
                                           "y"
                                           "1/3-y!1*y!1/36"
                                           "pz"
                                           "y!1 * y!1 * y!1 * y!1"))
                                         (("1"
                                           (replace -1 1)
                                           (hide -1 -2)
                                           (case "y!1 * y!1 / 36 < 1/12")
                                           (("1" (assert))
                                            ("2"
                                             (hide 2)
                                             (expand "sq" -7)
                                             (assert))))
                                          ("2"
                                           (hide 2)
                                           (lemma
                                            "sq_lt"
                                            ("nna" "0" "nnb" "sq(y!1)"))
                                           (rewrite "sq_0")
                                           (assert)
                                           (expand "sq" -1)
                                           (assert))))))
                                      ("2" (hide 2) (assert))))))
                                  ("2" (assert))))
                                ("2" (assert))))
                              ("2" (assert))
                              ("3"
                               (hide 2)
                               (assert)
                               (lemma "sq_lt" ("nna" "0" "nnb" "y!1"))
                               (rewrite "sq_0")
                               (assert))))
                            ("2"
                             (lemma "sq_lt" ("nna" "0" "nnb" "y!1"))
                             (rewrite "sq_0")
                             (assert))))
                          ("2"
                           (replace -1)
                           (replace -4 1 rl)
                           (simplify 1)
                           (hide-all-but 1)
                           (expand "sq")
                           (assert)
                           (name-replace "K1"
                            "2 * (1 / 6) - (1 / 6) * (1 / 6)")
                           (lemma "div_mult_pos_gt1"
                            ("x" "1" "z" "1/2" "py" "sqrt(K1)"))
                           (("1"
                             (rewrite "div_div2" -1)
                             (assert)
                             (lemma "sq_gt"
                              ("nna" "sqrt(K1)" "nnb" "1/2"))
                             (rewrite "sq_sqrt" -1)
                             (expand "sq" -1)
                             (expand "K1")
                             (assert))
                            ("2"
                             (lemma "sqrt_lt"
                              ("nny"
                               "0"
                               "nnz"
                               "2 * (1 / 6) - (1 / 6) * (1 / 6)"))
                             (rewrite "sqrt_0")
                             (expand "K1")
                             (hide 2)
                             (assert))
                            ("3" (hide 2) (expand "K1") (assert))))))
                        ("2"
                         (hide 2)
                         (lemma "posreal_times_posreal_is_posreal"
                          ("px" "y!1" "py" "y!1"))
                         (("1" (assert)) ("2" (assert))))
                        ("3" (assert))))
                      ("2" (assert))))))
                  ("2"
                   (hide-all-but 1)
                   (reveal "TCC")
                   (skeep)
                   (inst?)
                   (flatten)
                   (assert))
                  ("3"
                   (hide-all-but 1)
                   (assert)
                   (expand "connected?")
                   (skosimp*)
                   (assert))))
                ("2"
                 (hide-all-but 1)
                 (reveal "TCC")
                 (skeep)
                 (inst? -1)
                 (flatten)
                 (assert))))
              ("2"
               (hide-all-but 1)
               (reveal "TCC")
               (skeep)
               (inst? -1)
               (flatten)
               (assert))))
            ("2"
             (hide-all-but 1)
             (reveal "TCC")
             (skeep)
             (inst? -1)
             (flatten)
             (assert))))
          ("2"
           (hide-all-but 1)
           (skosimp*)
           (typepred "x!1")
           (expand ">=")
           (expand "<=" -1)
           (split -1)
           (("1"
             (lemma "posreal_times_posreal_is_posreal"
              ("px" "x!1" "py" "x!1"))
             (("1"
               (lemma "posreal_times_posreal_is_posreal"
                ("px" "x!1" "py" "x!1*x!1"))
               (("1"
                 (lemma "posreal_div_posreal_is_posreal"
                  ("px" "x!1*x!1*x!1" "py" "6"))
                 (("1"
                   (lemma "lt_minus_lt1"
                    ("x"
                     "x!1"
                     "y"
                     "1"
                     "w"
                     "0"
                     "z"
                     "x!1 * x!1 * x!1 / 6"))
                   (split -1)
                   (("1"
                     (lemma "sq_le" ("nna" "x!1" "nnb" "1"))
                     (expand "sq")
                     (lemma "posreal_times_posreal_is_posreal"
                      ("px" "1-x!1*x!1/6" "py" "x!1"))
                     (("1" (assert)) ("2" (hide 2) (assert))))
                    ("2" (propax)) ("3" (assert))))
                  ("2" (assert))))
                ("2" (propax))))
              ("2" (assert))))
            ("2" (assert))))))
        ("2"
         (expand "not_one_element?")
         (skosimp*)
         (inst-cp + "1/2")
         (inst-cp + "1/4")
         (assert))
        ("3"
         (lemma "deriv_domain_closed")
         (inst - "0" "1")
         (assert)
         (expand "deriv_domain?")
         (skosimp*)
         (inst - "e!1" "x!1")
         (skosimp*)
         (inst + "y!1"))))
      ("2"
       (hide 2)
       (lemma "sq_le" ("nnb" "px!1" "nna" "sqrt(6)"))
       (flatten)
       (rewrite "sq_sqrt")
       (assert)
       (hide -1)
       (typepred "px!1")
       (assert)
       (lemma "sq_le" ("nna" "px!1" "nnb" "1"))
       (rewrite "sq_1")
       (assert))))))


