# Proofs

proof_type: f_proof
decl_type: formula
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "both_sides_div_pos_lt2" ("pz" "1" "py" "lt1x!1" "px" "1"))
   (rewrite "div_simp")
   (assert)
   (lemma "nnreal_bijective1" ("gt1x" "1/lt1x!1"))
   (expand "bijective?")
   (flatten)
   (split)
   (("1"
     (expand "injective?")
     (skosimp*)
     (inst - "x1!1" "x2!1")
     (rewrite "inv_nnreal_expt")
     (rewrite "inv_nnreal_expt")
     (assert))
    ("2"
     (expand "surjective?")
     (skosimp)
     (typepred "y!1")
     (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "y!1"))
     (lemma "both_sides_div_pos_lt2" ("pz" "1" "py" "y!1" "px" "1"))
     (rewrite "div_simp")
     (assert)
     (inst - "1/y!1")
     (("1" (skosimp) (rewrite "inv_nnreal_expt") (inst + "x!1") (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "nnreal_expt")
   (typepred
    "lub(extend[real, nnreal, bool, FALSE]
                  ({z |
                      EXISTS q:
                        q <= py!1 AND z = nn_rational_expt(gt1x!1, q)}))")
   (name-replace "LE"
    "lub(extend[real, nnreal, bool, FALSE]
                  ({z |
                      EXISTS q:
                        q <= py!1 AND z = nn_rational_expt(gt1x!1, q)}))")
   (typepred
    "lub(extend[real, nnreal, bool, FALSE]
                   ({z |
                       EXISTS q: q < py!1 AND z = nn_rational_expt(gt1x!1, q)}))")
   (name-replace "LT"
    "lub(extend[real, nnreal, bool, FALSE]
                   ({z |
                       EXISTS q: q < py!1 AND z = nn_rational_expt(gt1x!1, q)}))")
   (expand "extend")
   (expand "least_upper_bound?")
   (expand "upper_bound?")
   (flatten)
   (inst-cp -2 "LE")
   (split -3)
   (("1"
     (expand "<=" -1)
     (split -1)
     (("1"
       (hide 1)
       (inst-cp -5 "LT")
       (split -6)
       (("1" (assert))
        ("2"
         (skosimp)
         (typepred "s!1")
         (replace -2 -1)
         (skosimp)
         (expand "<=" -1)
         (split -1)
         (("1" (inst -5 "s!1") (inst + "q!1") (assert))
          ("2"
           (case "s!1=LE")
           (("1"
             (replace -1)
             (assert)
             (name "EPS" "(LE-LT)/2")
             (case "LT>1")
             (("1"
               (lemma "nn_rational_expt_approx_gt1"
                ("x" "gt1x!1" "y" "LT+EPS" "epsilon" "EPS"))
               (("1"
                 (assert)
                 (skosimp)
                 (case "LT<nn_rational_expt(gt1x!1, q!2)& nn_rational_expt(gt1x!1, q!2)<LE")
                 (("1"
                   (flatten)
                   (hide -3)
                   (case "q!2<q!1")
                   (("1"
                     (inst -11 "nn_rational_expt(gt1x!1, q!2)")
                     (("1" (assert))
                      ("2"
                       (typepred "nn_rational_expt(gt1x!1, q!2)")
                       (assert)
                       (inst + "q!2")
                       (assert))))
                    ("2"
                     (replace -7)
                     (hide-all-but (-2 -3 -6 1))
                     (case-replace "q!2=q!1")
                     (("1" (assert))
                      ("2"
                       (lemma "nn_rational_expt_increasing"
                        ("q" "q!1" "r" "q!2" "x" "gt1x!1"))
                       (assert))))))
                  ("2"
                   (name-replace "DRL" "nn_rational_expt(gt1x!1, q!2)")
                   (hide-all-but (-1 -2 -3 1))
                   (grind))))
                ("2" (assert)) ("3" (assert))))
              ("2"
               (lemma "density_positive" ("x" "0" "y" "py!1"))
               (assert)
               (skosimp)
               (inst -9 "nn_rational_expt(gt1x!1, r!1)")
               (("1"
                 (lemma "nn_rational_expt_gt1" ("x" "gt1x!1" "pq" "r!1"))
                 (("1" (assert)) ("2" (assert))))
                ("2"
                 (typepred "nn_rational_expt(gt1x!1, r!1)")
                 (("1" (assert) (inst + "r!1")) ("2" (assert))))
                ("3" (assert))))))
            ("2"
             (hide 2)
             (inst -7 "s!1")
             (inst -8 "s!1")
             (split -8)
             (("1" (assert))
              ("2"
               (skosimp)
               (typepred "s!2")
               (assert)
               (skosimp)
               (lemma "nn_rational_expt_increasing"
                ("q" "q!2" "r" "q!1" "x" "gt1x!1"))
               (assert))))))))))
      ("2" (assert))))
    ("2"
     (skosimp)
     (typepred "s!1")
     (assert)
     (skosimp)
     (inst -6 "s!1")
     (inst + "q!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (a, b:nnreal, x: posreal): x>1 =>
                 nnreal_expt(x, a + b) = nnreal_expt(x, a) * nnreal_expt(x, b)")
   (("1"
     (skosimp)
     (case-replace "x!1=0")
     (("1"
       (hide -2 -1)
       (rewrite "nnreal_expt_0a")
       (rewrite "nnreal_expt_0a")
       (rewrite "nnreal_expt_0a")
       (grind))
      ("2"
       (case-replace "x!1=1")
       (("1"
         (rewrite "nnreal_expt_1a")
         (rewrite "nnreal_expt_1a")
         (rewrite "nnreal_expt_1a"))
        ("2"
         (case "0<x!1&x!1<1")
         (("1"
           (flatten)
           (inst - "a!1" "b!1" "1/x!1")
           (("1"
             (assert)
             (rewrite "inv_nnreal_expt")
             (rewrite "inv_nnreal_expt")
             (rewrite "inv_nnreal_expt")
             (rewrite "div_times")
             (("1"
               (rewrite "cross_mult")
               (("1" (rewrite "div_mult_pos_gt1"))
                ("2"
                 (expand "/=")
                 (rewrite "zero_times3")
                 (split)
                 (("1" (rewrite "nnreal_expt_is_0"))
                  ("2" (rewrite "nnreal_expt_is_0"))))
                ("3" (expand "/=") (rewrite "nnreal_expt_is_0"))))
              ("2" (expand "/=") (rewrite "nnreal_expt_is_0"))
              ("3" (expand "/=") (rewrite "nnreal_expt_is_0"))))
            ("2"
             (assert)
             (lemma "posreal_div_posreal_is_posreal"
              ("px" "1" "py" "x!1"))
             (assert))
            ("3" (assert))))
          ("2" (assert) (inst - "a!1" "b!1" "x!1") (assert))))))))
    ("2"
     (hide 2)
     (skosimp)
     (lemma "nnreal_expt_def_gt1" ("gt1x" "x!1"))
     (("1"
       (case-replace "a!1=0")
       (("1"
         (assert)
         (lemma "nnreal_expt_rat_rew" ("x" "x!1" "q" "0"))
         (rewrite "nn_rational_expt_nat_rew")
         (rewrite "expt_x0")
         (assert))
        ("2"
         (case-replace "b!1=0")
         (("1"
           (lemma "nnreal_expt_rat_rew" ("x" "x!1" "q" "0"))
           (rewrite "nn_rational_expt_nat_rew")
           (rewrite "expt_x0")
           (assert))
          ("2"
           (case "a!1>0")
           (("1"
             (case "b!1>0")
             (("1"
               (hide 1 2)
               (inst-cp - "a!1")
               (inst-cp - "b!1")
               (inst - "a!1+b!1")
               (("1"
                 (name-replace "XAB" "nnreal_expt(x!1, a!1 + b!1)")
                 (name-replace "XA" "nnreal_expt(x!1, a!1)")
                 (name-replace "XB" "nnreal_expt(x!1, b!1)")
                 (typepred
                  "lub(extend[real, nnreal, bool, FALSE]
                                 ({z |
                                     EXISTS q:
                                       q < a!1 + b!1 AND z = nn_rational_expt(x!1, q)}))")
                 (replace -4)
                 (typepred
                  "lub(extend[real, nnreal, bool, FALSE]
                                 ({z | EXISTS q: q < b!1 AND z = nn_rational_expt(x!1, q)}))")
                 (replace -5 * rl)
                 (replace -6 * rl)
                 (typepred
                  "lub(extend[real, nnreal, bool, FALSE]
                                 ({z | EXISTS q: q < a!1 AND z = nn_rational_expt(x!1, q)}))")
                 (replace -8 * rl)
                 (hide -6 -7 -8)
                 (expand "least_upper_bound?")
                 (expand "extend")
                 (expand "upper_bound?")
                 (flatten)
                 (inst -6 "XA*XB")
                 (split -6)
                 (("1"
                   (case "XAB>1")
                   (("1"
                     (case "XA>1")
                     (("1"
                       (inst -5 "XAB/XB")
                       (("1"
                         (split -5)
                         (("1" (rewrite "div_mult_pos_le2" -1) (assert))
                          ("2"
                           (expand "<=" -3)
                           (split -3)
                           (("1"
                             (hide 2)
                             (skosimp)
                             (typepred "s!1")
                             (replace -2 -1)
                             (skosimp)
                             (replace -2)
                             (rewrite "div_mult_pos_le2" 1)
                             (hide -2)
                             (expand ">=" -2)
                             (expand "<=" -2)
                             (split -2)
                             (("1"
                               (inst -8 "XAB/nn_rational_expt(x!1, q!1)")
                               (("1"
                                 (split -8)
                                 (("1"
                                   (rewrite "div_mult_pos_le2" -1)
                                   (assert))
                                  ("2"
                                   (skosimp)
                                   (typepred "s!2")
                                   (replace -2)
                                   (skosimp)
                                   (replace -2)
                                   (hide -2)
                                   (rewrite "div_mult_pos_le2" 1)
                                   (rewrite
                                    "nn_rational_expt_plus"
                                    1
                                    :dir
                                    rl)
                                   (inst
                                    -10
                                    "nn_rational_expt(x!1, q!1 + q!2)")
                                   (inst + "q!1+q!2")
                                   (assert))))
                                ("2" (assert))))
                              ("2"
                               (lemma "nn_rational_expt_is_0"
                                ("x" "x!1" "q" "q!1"))
                               (assert))))
                            ("2" (propax))))))
                        ("2" (assert))))
                      ("2"
                       (hide-all-but (-3 -9 1 -10))
                       (lemma "density_positive" ("x" "0" "y" "a!1"))
                       (assert)
                       (skosimp)
                       (inst - "nn_rational_expt(x!1, r!1)")
                       (("1"
                         (lemma "nn_rational_expt_gt1"
                          ("x" "x!1" "pq" "r!1"))
                         (("1" (assert)) ("2" (assert))))
                        ("2"
                         (typepred "nn_rational_expt(x!1, r!1)")
                         (("1" (assert) (inst + "r!1")) ("2" (assert))))
                        ("3" (assert))))))
                    ("2"
                     (hide -1 2 -2 -3 -4 -5)
                     (lemma "density_positive" ("x" "0" "y" "a!1+b!1"))
                     (assert)
                     (skosimp)
                     (inst - "nn_rational_expt(x!1,r!1)")
                     (("1"
                       (lemma "nn_rational_expt_gt1"
                        ("x" "x!1" "pq" "r!1"))
                       (("1" (assert)) ("2" (assert))))
                      ("2"
                       (typepred "nn_rational_expt(x!1, r!1)")
                       (("1" (assert) (inst + "r!1")) ("2" (assert))))
                      ("3" (assert))))))
                  ("2"
                   (skosimp)
                   (hide 2)
                   (typepred "s!1")
                   (assert)
                   (skosimp)
                   (replace -2)
                   (hide -2)
                   (hide -4 -6 -7)
                   (name "EPS" "min((a!1+b!1-q!1)/2,min(a!1,b!1))")
                   (case "EPS>0&a!1>=EPS&b!1>=EPS&(a!1 + b!1 - q!1) / 2>=EPS")
                   (("1"
                     (flatten)
                     (lemma "density_positive" ("x" "a!1-EPS" "y" "a!1"))
                     (assert)
                     (skosimp)
                     (lemma "density_positive" ("x" "b!1-EPS" "y" "b!1"))
                     (assert)
                     (skosimp)
                     (inst -12 "nn_rational_expt(x!1, r!1)")
                     (("1"
                       (inst -13 "nn_rational_expt(x!1, r!2)")
                       (("1"
                         (lemma "nn_rational_expt_gt1"
                          ("x" "x!1" "pq" "r!1"))
                         (lemma "nn_rational_expt_gt1"
                          ("x" "x!1" "pq" "r!2"))
                         (("1"
                           (assert)
                           (lemma "le_times_le_pos"
                            ("nnx"
                             "nn_rational_expt(x!1, r!1)"
                             "y"
                             "XA"
                             "nnz"
                             "nn_rational_expt(x!1, r!2)"
                             "w"
                             "XB"))
                           (assert)
                           (lemma "nn_rational_expt_plus"
                            ("x" "x!1" "q" "r!1" "r" "r!2"))
                           (case "q!1<=r!1+r!2")
                           (("1"
                             (replace -2 * rl)
                             (case "nn_rational_expt(x!1, q!1) <= nn_rational_expt(x!1, r!1 + r!2)")
                             (("1" (assert))
                              ("2"
                               (hide-all-but (-1 1 -21))
                               (case-replace "q!1=r!1+r!2")
                               (("1" (assert))
                                ("2"
                                 (lemma
                                  "nn_rational_expt_increasing"
                                  ("q" "q!1" "r" "r!1+r!2" "x" "x!1"))
                                 (assert))))))
                            ("2" (assert))))
                          ("2" (assert))))
                        ("2"
                         (typepred "nn_rational_expt(x!1, r!2)")
                         (("1" (assert) (inst + "r!2")) ("2" (assert))))
                        ("3" (assert))))
                      ("2"
                       (typepred "nn_rational_expt(x!1, r!1)")
                       (assert)
                       (inst + "r!1"))))
                    ("2" (hide-all-but (-1 -2 -6 -7 1)) (grind))))))
                ("2" (assert))))
              ("2" (assert))))
            ("2" (assert))))))))
      ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (a, b, x: posreal): x>1 =>
                 nnreal_expt(x, a * b) = nnreal_expt(nnreal_expt(x, a), b)")
   (("1"
     (skosimp)
     (case-replace "a!1=0")
     (("1"
       (rewrite "nnreal_expt_rat_rew")
       (rewrite "nn_rational_expt_nat_rew")
       (rewrite "expt_x0")
       (rewrite "nnreal_expt_1a"))
      ("2"
       (case-replace "b!1=0")
       (("1"
         (rewrite "nnreal_expt_rat_rew")
         (rewrite "nn_rational_expt_nat_rew")
         (rewrite "expt_x0")
         (lemma "nnreal_expt_rat_rew"
          ("x" "nnreal_expt(x!1, a!1)" "q" "0"))
         (replace -1)
         (hide -1)
         (rewrite "nn_rational_expt_nat_rew")
         (rewrite "expt_x0"))
        ("2"
         (case "a!1>0")
         (("1"
           (case "b!1>0")
           (("1"
             (case-replace "x!1=1")
             (("1"
               (rewrite "nnreal_expt_1a")
               (rewrite "nnreal_expt_1a")
               (rewrite "nnreal_expt_1a"))
              ("2"
               (case-replace "x!1=0")
               (("1"
                 (rewrite "nnreal_expt_0a")
                 (lemma "posreal_times_posreal_is_posreal"
                  ("px" "a!1" "py" "b!1"))
                 (("1"
                   (assert)
                   (rewrite "nnreal_expt_0a")
                   (rewrite "nnreal_expt_0a"))
                  ("2" (propax)) ("3" (propax))))
                ("2"
                 (case "0<x!1&x!1<1")
                 (("1"
                   (flatten)
                   (inst - "a!1" "b!1" "1/x!1")
                   (("1"
                     (assert)
                     (rewrite "inv_nnreal_expt")
                     (rewrite "inv_nnreal_expt")
                     (rewrite "inv_nnreal_expt")
                     (("1"
                       (rewrite "cross_mult")
                       (("1" (rewrite "div_mult_pos_gt1"))
                        ("2"
                         (expand "/=")
                         (rewrite "nnreal_expt_is_0")
                         (rewrite "nnreal_expt_is_0"))
                        ("3"
                         (expand "/=")
                         (rewrite "nnreal_expt_is_0"))))
                      ("2"
                       (lemma "nnreal_expt_pos" ("px" "x!1" "a" "a!1"))
                       (propax))))
                    ("2"
                     (assert)
                     (lemma "posreal_div_posreal_is_posreal"
                      ("px" "1" "py" "x!1"))
                     (assert))
                    ("3" (assert))))
                  ("2"
                   (assert)
                   (inst - "a!1" "b!1" "x!1")
                   (assert))))))))
            ("2" (assert))))
          ("2" (assert))))))))
    ("2"
     (hide 2)
     (skosimp)
     (lemma "nnreal_expt_def_gt1" ("gt1x" "x!1"))
     (("1"
       (inst-cp - "a!1*b!1")
       (inst - "a!1")
       (lemma "nnreal_expt_gt1" ("x" "x!1" "pa" "a!1"))
       (lemma "nnreal_expt_def_gt1"
        ("gt1x" "nnreal_expt(x!1, a!1)" "py" "b!1"))
       (("1"
         (name-replace "XA" "nnreal_expt(x!1, a!1)")
         (assert)
         (typepred
          "lub(extend[real, nnreal, bool, FALSE]
                         ({z | EXISTS q: q < a!1 AND z = nn_rational_expt(x!1, q)}))")
         (replace -4 * rl)
         (hide -4)
         (typepred
          "lub(extend[real, nnreal, bool, FALSE]
                         ({z | EXISTS q: q < b!1 AND z = nn_rational_expt(XA, q)}))")
         (name-replace "XB"
          "lub(extend[real, nnreal, bool, FALSE]
                         ({z | EXISTS q: q < b!1 AND z = nn_rational_expt(XA, q)}))")
         (replace -3)
         (hide -3)
         (name-replace "XAB" "nnreal_expt(x!1, a!1 * b!1)")
         (typepred
          "lub(extend[real, nnreal, bool, FALSE]
                         ({z |
                             EXISTS q:
                               q < a!1 * b!1 AND z = nn_rational_expt(x!1, q)}))")
         (replace -5 * rl)
         (hide -5)
         (expand "extend")
         (expand "least_upper_bound?")
         (flatten)
         (expand "upper_bound?")
         (inst -2 "XB")
         (split -2)
         (("1"
           (expand "<=" -1)
           (split -1)
           (("1"
             (hide 1)
             (inst -4 "XAB")
             (assert)
             (skosimp)
             (typepred "s!1")
             (replace -2)
             (skosimp)
             (replace -2)
             (hide -2)
             (case-replace "q!1=0")
             (("1"
               (rewrite "nn_rational_expt_nat_rew")
               (rewrite "expt_x0")
               (hide -6 -7 -8)
               (inst - "nn_rational_expt(x!1,0)")
               (("1"
                 (rewrite "nn_rational_expt_nat_rew")
                 (rewrite "expt_x0"))
                ("2"
                 (typepred "nn_rational_expt(x!1, 0)")
                 (assert)
                 (inst + "0")
                 (assert))))
              ("2"
               (case "q!1>0")
               (("1"
                 (hide 1)
                 (case "exists (r:posrat): a!1 < r & r*q!1<a!1*b!1")
                 (("1"
                   (skosimp)
                   (inst -10 "nn_rational_expt(x!1, r!1)")
                   (split -10)
                   (("1"
                     (expand "<=" -1)
                     (split -1)
                     (("1"
                       (lemma "nn_rational_expt_strict_increasing"
                        ("x"
                         "XA"
                         "y"
                         "nn_rational_expt(x!1, r!1)"
                         "pq"
                         "q!1"))
                       (("1"
                         (assert)
                         (rewrite "nn_rational_expt_times" -1 :dir rl)
                         (inst -9 "nn_rational_expt(x!1, r!1 * q!1)")
                         (("1" (assert)) ("2" (inst + "r!1*q!1"))))
                        ("2" (propax))))
                      ("2"
                       (replace -1)
                       (rewrite "nn_rational_expt_times" 1 :dir rl)
                       (inst -8 "nn_rational_expt(x!1, r!1 * q!1)")
                       (inst + "r!1*q!1"))))
                    ("2"
                     (skosimp)
                     (typepred "s!2")
                     (assert)
                     (skosimp)
                     (replace -2)
                     (expand "<=" 1)
                     (flatten)
                     (lemma "nn_rational_expt_increasing"
                      ("q" "q!2" "r" "r!1" "x" "x!1"))
                     (assert))))
                  ("2"
                   (hide-all-but (-1 -2 1))
                   (lemma "posreal_times_posreal_is_posreal"
                    ("px" "a!1" "py" "b!1"))
                   (lemma "density_positive"
                    ("x" "a!1" "y" "a!1*b!1/q!1"))
                   (("1"
                     (assert)
                     (rewrite "div_mult_pos_lt2" -1)
                     (lemma "both_sides_times_pos_lt1"
                      ("pz" "a!1" "x" "q!1" "y" "b!1"))
                     (assert)
                     (skosimp)
                     (inst + "r!1")
                     (("1" (assert) (rewrite "div_mult_pos_lt2" -3))
                      ("2" (assert))))
                    ("2" (assert))))))
                ("2" (assert))))))
            ("2" (propax))))
          ("2"
           (hide 2)
           (skosimp)
           (assert)
           (typepred "s!1")
           (replace -2)
           (skosimp)
           (replace -2)
           (hide -2)
           (lemma "density_positive" ("x" "q!1/a!1" "y" "b!1"))
           (assert)
           (rewrite "div_mult_pos_le2" -1)
           (rewrite "div_mult_pos_lt1" -1)
           (skosimp)
           (lemma "div_mult_pos_lt1" ("py" "a!1" "z" "q!1" "x" "r!1"))
           (assert)
           (hide -8 -10)
           (inst -7 "nn_rational_expt(XA, r!1)")
           (("1"
             (case "nn_rational_expt(x!1, q!1)<=nn_rational_expt(XA, r!1)")
             (("1" (assert))
              ("2"
               (hide 2 -7)
               (inst -7 "nn_rational_expt(x!1, q!1/r!1)")
               (("1"
                 (expand "<=" -7)
                 (split -7)
                 (("1"
                   (lemma "nn_rational_expt_strict_increasing"
                    ("x"
                     "nn_rational_expt(x!1, q!1 / r!1)"
                     "y"
                     "XA"
                     "pq"
                     "r!1"))
                   (("1"
                     (assert)
                     (rewrite "nn_rational_expt_times" -1 :dir rl)
                     (assert))
                    ("2" (rewrite "div_mult_pos_ge1" 1))))
                  ("2"
                   (replace -1 * rl)
                   (rewrite "nn_rational_expt_times" 1 :dir rl)
                   (("1" (assert))
                    ("2" (rewrite "div_mult_pos_ge1" 1))))))
                ("2"
                 (typepred "nn_rational_expt(x!1, q!1 / r!1)")
                 (("1"
                   (assert)
                   (inst + "q!1/r!1")
                   (("1" (assert) (rewrite "div_mult_pos_lt1" 1))
                    ("2" (rewrite "div_mult_pos_ge1" 1))))
                  ("2" (assert) (rewrite "div_mult_pos_ge1" 1))))
                ("3" (rewrite "div_mult_pos_ge1" 1))))))
            ("2"
             (typepred "nn_rational_expt(XA, r!1)")
             (assert)
             (inst + "r!1"))))))
        ("2" (assert) (replace -1 1) (assert))))
      ("2" (propax))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "y!1>0")
   (("1"
     (hide 1 2)
     (split)
     (("1"
       (expand "nonempty?")
       (expand "empty?")
       (expand "extend")
       (expand "member")
       (lemma "density_positive" ("x" "0" "y" "y!1"))
       (assert)
       (skosimp)
       (inst - "nn_rational_expt(x!1, r!1)")
       (("1"
         (typepred "nn_rational_expt(x!1, r!1)")
         (("1" (assert) (inst + "r!1") (assert)) ("2" (assert))))
        ("2" (assert))))
      ("2"
       (expand "bounded_below?")
       (inst + "0")
       (expand "lower_bound?")
       (skosimp)
       (typepred "s!1")
       (expand "extend")
       (assert))))
    ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred
    "glb(extend[real, nnreal, bool, FALSE]
                  ({z | EXISTS q: q <= y!1 AND z = nn_rational_expt(x!1, q)}))")
   (name-replace "GLB"
    "glb(extend[real, nnreal, bool, FALSE]
                  ({z | EXISTS q: q <= y!1 AND z = nn_rational_expt(x!1, q)}))")
   (expand "greatest_lower_bound?")
   (flatten)
   (inst - "0")
   (assert)
   (hide -1 4)
   (expand "lower_bound?")
   (skosimp)
   (typepred "s!1")
   (assert)
   (expand "extend")
   (propax))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (split)
   (("1"
     (expand "nonempty?")
     (expand "empty?")
     (expand "extend")
     (expand "member")
     (lemma "density_positive" ("x" "0" "y" "y!1"))
     (assert)
     (skosimp)
     (inst - "nn_rational_expt(x!1, r!1)")
     (("1"
       (typepred "nn_rational_expt(x!1, r!1)")
       (("1" (assert) (inst + "r!1") (assert)) ("2" (assert))))
      ("2" (assert))))
    ("2"
     (expand "bounded_above?")
     (expand "extend")
     (expand "upper_bound?")
     (lemma "density_positive" ("x" "y!1" "y" "y!1+1"))
     (assert)
     (skosimp)
     (inst + "nn_rational_expt(x!1, r!1)")
     (("1"
       (skosimp)
       (typepred "s!1")
       (assert)
       (skosimp)
       (replace -2)
       (lemma "nn_rational_expt_increasing"
        ("q" "q!1" "r" "r!1" "x" "x!1"))
       (assert))
      ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred
    "lub(extend[real, nnreal, bool, FALSE]
                  ({z | EXISTS q: q <= y!1 AND z = nn_rational_expt(x!1, q)}))")
   (name-replace "LUB"
    "lub(extend[real, nnreal, bool, FALSE]
                  ({z | EXISTS q: q <= y!1 AND z = nn_rational_expt(x!1, q)}))")
   (expand "least_upper_bound?")
   (flatten)
   (hide -2)
   (expand "upper_bound?")
   (inst - "nn_rational_expt(x!1, 0)")
   (("1" (typepred "nn_rational_expt(x!1, 0)") (assert))
    ("2"
     (expand "extend")
     (typepred "nn_rational_expt(x!1, 0)")
     (assert)
     (inst + "0")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case-replace "y!1=0")
   (("1"
     (rewrite "nnreal_expt_rat_rew")
     (rewrite "nn_rational_expt_nat_rew")
     (rewrite "expt_x0")
     (assert))
    ("2"
     (lemma "nnreal_expt_gt1" ("x" "gt1x!1" "pa" "y!1"))
     (("1" (assert)) ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case-replace "y!1=0")
   (("1"
     (rewrite "nnreal_expt_rat_rew")
     (rewrite "nn_rational_expt_nat_rew")
     (rewrite "expt_x0")
     (assert))
    ("2"
     (lemma "nnreal_expt_lt1" ("x" "lt1x!1" "pa" "y!1"))
     (("1"
       (assert)
       (lemma "nnreal_expt_pos" ("px" "lt1x!1" "a" "y!1"))
       (propax))
      ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nnreal_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (expand "extend")
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "nn_rational_expt(gt1x!1, 0)")
     (typepred "nn_rational_expt(gt1x!1, 0)")
     (assert)
     (inst + "0")
     (assert))
    ("2"
     (expand "extend")
     (expand "bounded_above?")
     (expand "upper_bound?")
     (lemma "density_positive" ("x" "py!1" "y" "py!1+1"))
     (assert)
     (skosimp)
     (inst + "nn_rational_expt(gt1x!1, r!1)")
     (("1"
       (skosimp)
       (typepred "s!1")
       (assert)
       (skosimp)
       (lemma "nn_rational_expt_increasing"
        ("q" "q!1" "r" "r!1" "x" "gt1x!1"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "x!1=0")
   (("1" (rewrite "nnreal_expt_0a") (postpone)) ("2" (postpone))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "i!1")
   (expand "^" 1 1)
   (split)
   (("1"
     (expand "^")
     (case-replace "i!1>=0")
     (("1" (rewrite "nnreal_expt_nat_rew") (expand "^") (assert))
      ("2"
       (assert)
       (rewrite "inv_nnreal_expt")
       (rewrite "cross_mult" 2)
       (assert)
       (rewrite "nnreal_expt_nat_rew")
       (expand "^")
       (assert))))
    ("2"
     (assert)
     (expand "^")
     (rewrite "nnreal_expt_nat_rew")
     (expand "^")
     (propax))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "real_expt_nnreal_rew")
   (rewrite "nnreal_expt_root_rew")
   (expand "root")
   (expand "abs")
   (expand "sign")
   (case-replace "x!1=0")
   (("1" (rewrite "nn_root_0n") (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1" (rewrite "nnreal_expt_1a"))
    ("2" (assert) (rewrite "nnreal_expt_1a"))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1" (rewrite "nnreal_expt_pos"))
    ("2" (assert) (rewrite "nnreal_expt_pos"))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1"
     (rewrite "nnreal_expt_is_0")
     (assert)
     (case-replace "x!1=0")
     (("1" (assert) (grind)) ("2" (grind))))
    ("2"
     (assert)
     (rewrite "nnreal_expt_is_0")
     (typepred "a!1")
     (assert)
     (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "x!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1"
     (assert)
     (expand ">=" -1)
     (expand "<=" -1)
     (split -1)
     (("1" (assert) (rewrite "nnreal_expt_gt1"))
      ("2"
       (replace -1 * rl)
       (assert)
       (rewrite "nnreal_expt_nat_rew")
       (rewrite "expt_x0")
       (assert))))
    ("2"
     (assert)
     (typepred "a!1")
     (assert)
     (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "x!1"))
     (rewrite "nnreal_expt_gt1")
     (assert)
     (grind)
     (("1" (rewrite "div_mult_pos_gt1") (rewrite "div_mult_pos_gt1"))
      ("2" (rewrite "div_mult_pos_gt1" 2))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1"
     (expand ">=" -1)
     (expand "<=" -1)
     (split -1)
     (("1" (assert) (rewrite "nnreal_expt_lt1"))
      ("2"
       (replace -1 * rl)
       (assert)
       (rewrite "nnreal_expt_nat_rew")
       (rewrite "expt_x0")
       (assert))))
    ("2"
     (assert)
     (rewrite "nnreal_expt_lt1")
     (("1"
       (rewrite "div_mult_pos_lt1" 2)
       (("1" (grind)) ("2" (grind) (typepred "a!1") (assert))))
      ("2"
       (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "x!1"))
       (("1" (assert)) ("2" (typepred "a!1") (assert))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1" (rewrite "inv_nnreal_expt"))
    ("2"
     (assert)
     (rewrite "div_div1")
     (rewrite "inv_nnreal_expt")
     (rewrite "div_div1"))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1>=0")
   (("1" (rewrite "mult_nnreal_expt"))
    ("2"
     (assert)
     (typepred "a!1")
     (split)
     (("1" (propax))
      ("2"
       (flatten)
       (rewrite "inv_nnreal_expt")
       (("1"
         (rewrite "inv_nnreal_expt")
         (rewrite "inv_nnreal_expt")
         (rewrite "mult_nnreal_expt")
         (assert))
        ("2" (rewrite "posreal_times_posreal_is_posreal"))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "inv_real_expt" ("px" "py!1" "a" "a!1"))
   (lemma "mult_real_expt" ("x" "x!1" "y" "1/py!1" "a" "a!1"))
   (("1" (assert))
    ("2"
     (hide -1 2)
     (typepred "a!1")
     (flatten)
     (split)
     (("1" (propax))
      ("2" (assert) (rewrite "posreal_div_posreal_is_posreal"))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "a!1=0")
   (("1"
     (assert)
     (rewrite "nnreal_expt_nat_rew")
     (rewrite "nnreal_expt_nat_rew")
     (rewrite "expt_x0")
     (rewrite "expt_x0"))
    ("2" (case "a!1>0") (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (x: posreal, a, b: real):
                 x ^ (a + b) = x ^ a * x ^ b")
   (("1"
     (skosimp)
     (case-replace "x!1=0")
     (("1"
       (hide -2)
       (typepred "a!1")
       (assert)
       (typepred "b!1")
       (assert)
       (expand "^")
       (rewrite "nnreal_expt_0a")
       (rewrite "nnreal_expt_0a")
       (rewrite "nnreal_expt_0a")
       (grind))
      ("2" (inst - "x!1" "a!1" "b!1") (assert))))
    ("2"
     (hide 2)
     (case "FORALL (x,a: posreal, b: real): x ^ (a + b) = x ^ a * x ^ b")
     (("1"
       (skosimp)
       (lemma "trich_lt" ("x" "a!1" "y" "0"))
       (split -1)
       (("1"
         (lemma "trich_lt" ("x" "b!1" "y" "0"))
         (split -1)
         (("1"
           (hide -3)
           (expand "^")
           (assert)
           (lemma "nnreal_expt_plus" ("x" "1/x!1" "a" "-a!1" "b" "-b!1"))
           (assert))
          ("2" (replace -1) (rewrite "real_expt_x0") (assert))
          ("3"
           (inst - "x!1" "b!1" "a!1")
           (("1" (assert)) ("2" (assert))))))
        ("2" (replace -1) (rewrite "real_expt_x0") (assert))
        ("3" (inst - "x!1" "a!1" "b!1") (assert))))
      ("2"
       (hide 2)
       (case "FORALL (x, a,b: posreal): x ^ (a + b) = x ^ a * x ^ b")
       (("1"
         (skosimp)
         (lemma "trich_lt" ("x" "b!1" "y" "0"))
         (split -1)
         (("1"
           (lemma "trich_lt" ("x" "a!1+b!1" "y" "0"))
           (split -1)
           (("1"
             (typepred "a!1")
             (hide -1)
             (inst - "x!1" "a!1" "-b!1-a!1")
             (("1"
               (case-replace "a!1 + (-b!1 - a!1)=-b!1")
               (("1"
                 (hide -1)
                 (rewrite "real_expt_neg" -4)
                 (lemma "real_expt_neg" ("px" "x!1" "a" "a!1+b!1"))
                 (replace -1)
                 (hide -1)
                 (rewrite "inv_real_expt")
                 (rewrite "inv_real_expt")
                 (assert))
                ("2" (assert))))
              ("2" (assert))))
            ("2"
             (replace -1)
             (rewrite "real_expt_x0")
             (case-replace "b!1=-a!1")
             (("1"
               (rewrite "real_expt_neg" +)
               (rewrite "inv_real_expt" +)
               (assert))
              ("2" (assert))))
            ("3"
             (inst - "x!1" "a!1+b!1" "-b!1")
             (("1"
               (case-replace "a!1 + b!1 + -b!1=a!1")
               (("1"
                 (hide -1)
                 (rewrite "real_expt_neg")
                 (rewrite "inv_real_expt")
                 (assert))
                ("2" (assert))))
              ("2" (assert)) ("3" (assert))))))
          ("2" (replace -1) (rewrite "real_expt_x0") (assert))
          ("3" (inst - "x!1" "a!1" "b!1") (assert))))
        ("2"
         (hide 2)
         (skosimp)
         (expand "^")
         (rewrite "nnreal_expt_plus"))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "real_expt_neg" ("px" "px!1" "a" "b!1"))
   (lemma "real_expt_plus" ("x" "px!1" "a" "a!1" "b" "-b!1"))
   (assert)
   (replace -2 -1)
   (replace -1 1)
   (rewrite "inv_real_expt")
   (assert))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "a!1>=0")
   (("1"
     (case "b!1>=0")
     (("1"
       (expand "^")
       (lemma "le_times_le_pos"
        ("nnx" "0" "y" "a!1" "nnz" "0" "w" "b!1"))
       (assert)
       (rewrite "nnreal_expt_times"))
      ("2"
       (typepred "b!1")
       (split -1)
       (("1" (propax))
        ("2"
         (case-replace "x!1=0")
         (("1"
           (rewrite "real_expt_0x" -2)
           (lift-if -2)
           (assert)
           (prop)
           (replace -1)
           (rewrite "real_expt_1a")
           (rewrite "real_expt_0x"))
          ("2"
           (case "x!1>0")
           (("1"
             (expand ">=" -3)
             (expand "<=" -3)
             (split -3)
             (("1"
               (lemma "both_sides_times_neg_lt1"
                ("nz" "b!1" "y" "0" "x" "a!1"))
               (("1"
                 (assert)
                 (expand "^")
                 (rewrite "inv_nnreal_expt")
                 (rewrite "inv_nnreal_expt")
                 (rewrite "nnreal_expt_times" 3 :dir rl)
                 (assert))
                ("2" (assert))))
              ("2"
               (replace -1 * rl)
               (rewrite "real_expt_x0")
               (rewrite "real_expt_1a"))))
            ("2" (assert))))))))))
    ("2"
     (typepred "a!1")
     (assert)
     (case "b!1>=0")
     (("1"
       (expand ">=" -1)
       (expand "<=" -1)
       (split -1)
       (("1"
         (lemma "both_sides_times_pos_lt1"
          ("pz" "b!1" "x" "a!1" "y" "0"))
         (("1"
           (assert)
           (expand "^")
           (rewrite "inv_nnreal_expt")
           (rewrite "inv_nnreal_expt")
           (rewrite "inv_nnreal_expt")
           (("1" (rewrite "nnreal_expt_times" 2 :dir rl) (assert))
            ("2" (rewrite "nnreal_expt_pos" 1))))
          ("2" (assert))))
        ("2"
         (replace -1 * rl)
         (rewrite "real_expt_x0")
         (rewrite "real_expt_x0"))))
      ("2"
       (typepred "b!1")
       (assert)
       (expand "^")
       (lemma "negreal_times_negreal_is_posreal" ("nx" "a!1" "ny" "b!1"))
       (assert)
       (rewrite "inv_nnreal_expt")
       (rewrite "div_div1")
       (lemma "nnreal_expt_times" ("x" "x!1" "a" "-a!1" "b" "-b!1"))
       (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "trich_lt" ("x" "a!1" "y" "0"))
   (split -1)
   (("1"
     (typepred "lt1x!1")
     (case "1<1/lt1x!1")
     (("1"
       (hide -2)
       (lemma "trich_lt" ("x" "b!1" "y" "0"))
       (split -1)
       (("1"
         (expand "^")
         (assert)
         (lemma "nnreal_expt_increasing"
          ("a" "-b!1" "b" "-a!1" "x" "1/lt1x!1"))
         (assert))
        ("2"
         (replace -1)
         (rewrite "real_expt_x0")
         (rewrite "real_expt_gt1"))
        ("3"
         (lemma "real_expt_lt1" ("x" "lt1x!1" "a" "b!1"))
         (assert)
         (lemma "real_expt_gt1" ("x" "lt1x!1" "a" "a!1"))
         (assert))))
      ("2" (rewrite "div_mult_pos_lt2" 1))))
    ("2"
     (replace -1)
     (rewrite "real_expt_x0")
     (lemma "real_expt_lt1" ("x" "lt1x!1" "a" "b!1"))
     (assert))
    ("3"
     (expand "^")
     (assert)
     (lemma "nnreal_expt_decreasing" ("a" "a!1" "b" "b!1" "x" "lt1x!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "gt1x!1")
   (case "0<1/gt1x!1&1/gt1x!1<1")
   (("1"
     (flatten)
     (lemma "real_expt_decreasing"
      ("lt1x" "1/gt1x!1" "a" "-b!1" "b" "-a!1"))
     (("1"
       (rewrite "real_expt_neg")
       (rewrite "real_expt_neg")
       (rewrite "div_div1")
       (assert))
      ("2" (propax))))
    ("2"
     (hide 2)
     (rewrite "div_mult_pos_lt1" +)
     (rewrite "div_mult_pos_lt2" +))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "nnreal_expt_strict_increasing"
    ("x" "x!1" "y" "y!1" "pa" "pa!1"))
   (expand "^")
   (assert))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "px!1")
   (lemma "nnreal_expt_strict_increasing"
    ("x" "1/y!1" "y" "1/px!1" "pa" "-na!1"))
   (("1"
     (split -1)
     (("1" (expand "^") (assert))
      ("2"
       (hide 2)
       (rewrite "div_mult_pos_lt1" 1)
       (lemma "div_mult_pos_lt2" ("py" "px!1" "z" "y!1" "x" "1"))
       (assert))))
    ("2"
     (assert)
     (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "y!1"))
     (assert))
    ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (case-replace "x!1=y!1")
     (("1" (assert))
      ("2"
       (lemma "real_expt_strict_increasing"
        ("x" "y!1" "y" "x!1" "pa" "pa!1"))
       (assert))))
    ("2"
     (flatten)
     (lemma "real_expt_strict_increasing"
      ("y" "y!1" "x" "x!1" "pa" "pa!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (split)
   (("1"
     (flatten)
     (lemma "real_expt_strict_increasing"
      ("x" "y!1" "y" "x!1" "pa" "pa!1"))
     (assert))
    ("2"
     (flatten)
     (split)
     (("1"
       (lemma "real_expt_strict_increasing"
        ("y" "y!1" "x" "x!1" "pa" "pa!1"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "both_sides_real_expt_le" ("x" "x!1" "y" "y!1" "pa" "pa!1"))
   (lemma "both_sides_real_expt_ge" ("x" "x!1" "y" "y!1" "pa" "pa!1"))
   (split 1)
   (("1" (flatten) (assert)) ("2" (flatten) (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (case-replace "b!1=a!1")
     (("1" (assert))
      ("2"
       (lemma "real_expt_decreasing"
        ("a" "a!1" "b" "b!1" "lt1x" "lt1x!1"))
       (assert))))
    ("2"
     (flatten)
     (lemma "real_expt_decreasing" ("b" "a!1" "a" "b!1" "lt1x" "lt1x!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (split)
   (("1"
     (flatten)
     (lemma "real_expt_decreasing" ("a" "a!1" "b" "b!1" "lt1x" "lt1x!1"))
     (assert))
    ("2"
     (flatten)
     (split)
     (("1"
       (lemma "real_expt_decreasing"
        ("b" "a!1" "a" "b!1" "lt1x" "lt1x!1"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "both_sides_real_expt_lt1_lt"
    ("lt1x" "lt1x!1" "b" "a!1" "a" "b!1"))
   (flatten)
   (split 1)
   (("1" (flatten) (assert)) ("2" (assert) (flatten) (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "both_sides_real_expt_lt1_le"
    ("lt1x" "lt1x!1" "b" "a!1" "a" "b!1"))
   (flatten)
   (split 1)
   (("1" (flatten) (assert)) ("2" (assert) (flatten) (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (lemma "real_expt_increasing" ("a" "b!1" "b" "a!1" "gt1x" "gt1x!1"))
     (assert))
    ("2"
     (flatten)
     (lemma "real_expt_increasing" ("a" "a!1" "b" "b!1" "gt1x" "gt1x!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (split)
   (("1"
     (flatten)
     (lemma "real_expt_increasing" ("a" "b!1" "b" "a!1" "gt1x" "gt1x!1"))
     (assert))
    ("2"
     (flatten)
     (split)
     (("1"
       (lemma "real_expt_increasing"
        ("a" "a!1" "b" "b!1" "gt1x" "gt1x!1"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (case "x!1<1")
     (("1"
       (lemma "both_sides_real_expt_lt1_le"
        ("lt1x" "x!1" "a" "pa!1" "b" "pb!1"))
       (("1"
         (lemma "both_sides_real_expt_lt1_ge"
          ("lt1x" "x!1" "a" "pa!1" "b" "pb!1"))
         (assert))
        ("2" (assert))))
      ("2"
       (lemma "both_sides_real_expt_gt1_le"
        ("gt1x" "x!1" "a" "pa!1" "b" "pb!1"))
       (("1"
         (lemma "both_sides_real_expt_gt1_ge"
          ("gt1x" "x!1" "a" "pa!1" "b" "pb!1"))
         (assert))
        ("2" (assert))))))
    ("2"
     (flatten)
     (split)
     (("1"
       (replace -1)
       (rewrite "real_expt_0x")
       (rewrite "real_expt_0x"))
      ("2"
       (replace -1)
       (rewrite "real_expt_1a")
       (rewrite "real_expt_1a"))
      ("3" (assert))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "a!1")
   (split)
   (("1" (propax))
    ("2"
     (lemma "posreal_div_posreal_is_posreal" ("px" "1" "py" "x!1"))
     (("1" (assert)) ("2" (propax))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "a!1")
   (split)
   (("1" (propax))
    ("2" (flatten) (rewrite "posreal_times_posreal_is_posreal"))))


proof_type: t_proof
decl_type: tcc
library: power
theory: real_expt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "a!1")
   (assert)
   (typepred "b!1")
   (lemma "real_expt_is_0" ("x" "x!1" "a" "a!1"))
   (assert)
   (lemma "le_times_le_pos" ("nnx" "0" "y" "a!1" "nnz" "0" "w" "b!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "nn_log")
   (case-replace "ne1x!1>1")
   (("1"
     (expand "log_gt1")
     (lemma "inverse_injective[nnreal, {r | r >= 1}]"
      ("f" "LAMBDA x: nnreal_expt(ne1x!1, x)" "x" "y!1"))
     (("1" (assert))
      ("2"
       (lemma "nnreal_bijective1" ("gt1x" "ne1x!1"))
       (("1" (expand "bijective?") (flatten)) ("2" (propax))))
      ("3"
       (skosimp)
       (hide 2)
       (case-replace "x!1=0")
       (("1"
         (rewrite "nnreal_expt_rat_rew")
         (rewrite "nn_rational_expt_nat_rew")
         (rewrite "expt_x0")
         (assert))
        ("2"
         (lemma "nnreal_expt_gt1" ("x" "ne1x!1" "pa" "x!1"))
         (("1" (assert)) ("2" (assert))))))))
    ("2"
     (assert)
     (case "ne1x!1<1")
     (("1"
       (hide 1)
       (expand "log_lt1")
       (lemma "inverse_injective[nnreal, {r | r <= 1}]"
        ("f" "LAMBDA x: nnreal_expt(ne1x!1, x)" "x" "y!1"))
       (("1" (assert))
        ("2"
         (lemma "nnreal_bijective2" ("lt1x" "ne1x!1"))
         (expand "bijective?")
         (flatten))
        ("3"
         (hide 2)
         (skosimp)
         (case-replace "x!1=0")
         (("1"
           (rewrite "nnreal_expt_rat_rew")
           (rewrite "nn_rational_expt_nat_rew")
           (rewrite "expt_x0")
           (assert))
          ("2"
           (lemma "nnreal_expt_lt1" ("x" "ne1x!1" "pa" "x!1"))
           (("1"
             (assert)
             (lemma "nnreal_expt_pos" ("px" "ne1x!1" "a" "x!1"))
             (propax))
            ("2" (assert))))))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "y!1")
   (expand "nn_log")
   (split)
   (("1"
     (flatten)
     (assert)
     (expand "log_gt1")
     (lemma "nnreal_bijective1" ("gt1x" "ne1x!1"))
     (expand "bijective?")
     (flatten)
     (lemma "inverse_surjective[nnreal, {r | r >= 1}]"
      ("f" "LAMBDA x: nnreal_expt(ne1x!1, x)" "y" "y!1"))
     (("1" (assert)) ("2" (propax))
      ("3"
       (skosimp)
       (hide 2 -1 -2)
       (rewrite "nnreal_expt_pos")
       (case-replace "x!1=0")
       (("1"
         (rewrite "nnreal_expt_rat_rew")
         (rewrite "nn_rational_expt_nat_rew")
         (rewrite "expt_x0")
         (assert))
        ("2"
         (lemma "nnreal_expt_gt1" ("x" "ne1x!1" "pa" "x!1"))
         (("1" (assert)) ("2" (assert))))))))
    ("2"
     (flatten)
     (assert)
     (expand "log_lt1")
     (lemma "nnreal_bijective2" ("lt1x" "ne1x!1"))
     (expand "bijective?")
     (flatten)
     (lemma "inverse_surjective[nnreal, {r | r <= 1}]"
      ("f" "LAMBDA x: nnreal_expt(ne1x!1, x)" "y" "y!1"))
     (("1" (assert)) ("2" (propax))
      ("3"
       (skosimp)
       (hide -1 -2 2)
       (case-replace "x!1=0")
       (("1"
         (rewrite "nnreal_expt_rat_rew")
         (rewrite "nn_rational_expt_nat_rew")
         (rewrite "expt_x0")
         (assert))
        ("2"
         (lemma "nnreal_expt_pos" ("px" "ne1x!1" "a" "x!1"))
         (lemma "nnreal_expt_lt1" ("x" "ne1x!1" "pa" "x!1"))
         (("1" (assert)) ("2" (assert))))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "trich_lt"
    ("x"
     "nn_log(ne1x!1)(x!1 * y!1)"
     "y"
     "nn_log(ne1x!1)(x!1) + nn_log(ne1x!1)(y!1)"))
   (split)
   (("1"
     (case "ne1x!1>1")
     (("1"
       (lemma "nnreal_expt_increasing"
        ("x"
         "ne1x!1"
         "b"
         "nn_log(ne1x!1)(x!1) + nn_log(ne1x!1)(y!1)"
         "a"
         "nn_log(ne1x!1)(x!1 * y!1)"))
       (assert)
       (rewrite "nnreal_expt_plus")
       (rewrite "nn_expt_log")
       (rewrite "nn_expt_log")
       (rewrite "nn_expt_log")
       (assert))
      ("2"
       (lemma "nnreal_expt_decreasing"
        ("x"
         "ne1x!1"
         "b"
         "nn_log(ne1x!1)(x!1) + nn_log(ne1x!1)(y!1)"
         "a"
         "nn_log(ne1x!1)(x!1 * y!1)"))
       (assert)
       (rewrite "nnreal_expt_plus")
       (rewrite "nn_expt_log")
       (rewrite "nn_expt_log")
       (rewrite "nn_expt_log")
       (assert))))
    ("2" (propax))
    ("3"
     (typepred "ne1x!1")
     (case "ne1x!1>1")
     (("1"
       (lemma "nnreal_expt_increasing"
        ("x"
         "ne1x!1"
         "a"
         "nn_log(ne1x!1)(x!1) + nn_log(ne1x!1)(y!1)"
         "b"
         "nn_log(ne1x!1)(x!1 * y!1)"))
       (assert)
       (rewrite "nn_expt_log")
       (rewrite "nnreal_expt_plus")
       (rewrite "nn_expt_log")
       (rewrite "nn_expt_log")
       (assert))
      ("2"
       (case "ne1x!1<1")
       (("1"
         (hide 1)
         (lemma "nnreal_expt_decreasing"
          ("x"
           "ne1x!1"
           "a"
           "nn_log(ne1x!1)(x!1) + nn_log(ne1x!1)(y!1)"
           "b"
           "nn_log(ne1x!1)(x!1 * y!1)"))
         (assert)
         (rewrite "nn_expt_log")
         (rewrite "nnreal_expt_plus")
         (rewrite "nn_expt_log")
         (rewrite "nn_expt_log")
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "nn_log_expt" ("ne1x" "ne1x!1" "y" "0"))
   (rewrite "nnreal_expt_nat_rew")
   (rewrite "expt_x0"))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "nn_log_ne1x" ("ne1x" "gt1x!1"))
   (replace -1 * rl)
   (hide -1)
   (split)
   (("1"
     (flatten)
     (lemma "nnreal_expt_increasing"
      ("a"
       "nn_log(gt1x!1)(gt1x!1)"
       "b"
       "nn_log(gt1x!1)(gt1y!1)"
       "x"
       "gt1x!1"))
     (assert)
     (rewrite "nn_expt_log")
     (rewrite "nn_expt_log")
     (assert))
    ("2"
     (flatten)
     (case-replace "nn_log(gt1x!1)(gt1y!1)=nn_log(gt1x!1)(gt1x!1)")
     (("1"
       (rewrite "nn_log_ne1x")
       (hide 1)
       (expand "nn_log")
       (expand "log_gt1")
       (lemma "nnreal_bijective1" ("gt1x" "gt1x!1"))
       (lemma "bijective_inverse[nnreal, {r | r >= 1}]"
        ("f"
         "LAMBDA (y:nnreal): nnreal_expt(gt1x!1, y)"
         "y"
         "gt1y!1"
         "x"
         "1"))
       (("1" (replace -1) (assert) (rewrite "nnreal_expt_x1") (assert))
        ("2" (propax))
        ("3"
         (skosimp)
         (case-replace "y!1=0")
         (("1"
           (rewrite "nnreal_expt_nat_rew" 1)
           (rewrite "expt_x0")
           (assert))
          ("2"
           (lemma "nnreal_expt_gt1" ("x" "gt1x!1" "pa" "y!1"))
           (("1" (assert)) ("2" (assert))))))))
      ("2"
       (lemma "nnreal_expt_increasing"
        ("a"
         "nn_log(gt1x!1)(gt1y!1)"
         "b"
         "nn_log(gt1x!1)(gt1x!1)"
         "x"
         "gt1x!1"))
       (rewrite "nn_expt_log")
       (rewrite "nn_expt_log")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "trich_lt"
    ("x" "nn_log(1 / ne1x!1)(y!1)" "y" "nn_log(ne1x!1)(1 / y!1)"))
   (split -1)
   (("1"
     (hide 1)
     (typepred "y!1")
     (split)
     (("1"
       (flatten)
       (lemma "nnreal_expt_increasing"
        ("x"
         "ne1x!1"
         "a"
         "nn_log(1 / ne1x!1)(y!1)"
         "b"
         "nn_log(ne1x!1)(1 / y!1)"))
       (assert)
       (rewrite "nn_expt_log" -1)
       (lemma "inv_nnreal_expt"
        ("px" "ne1x!1" "a" "nn_log(1 / ne1x!1)(y!1)"))
       (rewrite "nn_expt_log" -1)
       (assert))
      ("2"
       (flatten)
       (lemma "nnreal_expt_decreasing"
        ("a"
         "nn_log(1 / ne1x!1)(y!1)"
         "b"
         "nn_log(ne1x!1)(1 / y!1)"
         "x"
         "ne1x!1"))
       (assert)
       (rewrite "nn_expt_log")
       (lemma "inv_nnreal_expt"
        ("px" "1/ne1x!1" "a" "nn_log(1 / ne1x!1)(y!1)"))
       (rewrite "nn_expt_log")
       (case-replace "1 / (1 / ne1x!1)=ne1x!1")
       (("1" (assert) (replace -2 -3) (assert)) ("2" (assert))))))
    ("2" (propax))
    ("3"
     (case "ne1x!1>1")
     (("1"
       (lemma "nnreal_expt_increasing"
        ("a"
         "nn_log(ne1x!1)(1 / y!1)"
         "b"
         "nn_log(1 / ne1x!1)(y!1)"
         "x"
         "ne1x!1"))
       (rewrite "nn_expt_log")
       (assert)
       (lemma "inv_nnreal_expt"
        ("px" "ne1x!1" "a" "nn_log(1 / ne1x!1)(y!1)"))
       (rewrite "nn_expt_log" -1)
       (assert))
      ("2"
       (case "ne1x!1<1")
       (("1"
         (hide 1)
         (lemma "nnreal_expt_decreasing"
          ("a"
           "nn_log(ne1x!1)(1 / y!1)"
           "b"
           "nn_log(1 / ne1x!1)(y!1)"
           "x"
           "ne1x!1"))
         (rewrite "nn_expt_log" -1)
         (assert)
         (lemma "inv_nnreal_expt"
          ("px" "ne1x!1" "a" "nn_log(1 / ne1x!1)(y!1)"))
         (rewrite "nn_expt_log")
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case-replace "nn_log(gt1x!1)(y!1)=nn_log(gt1x!1)(x!1)")
   (("1"
     (hide 1)
     (lemma "nn_expt_log" ("ne1x" "gt1x!1" "y" "y!1"))
     (lemma "nn_expt_log" ("ne1x" "gt1x!1" "y" "x!1"))
     (replace -1 -5 rl)
     (replace -2 -5 rl)
     (hide -1 -2)
     (replace -1)
     (assert))
    ("2"
     (lemma "nnreal_expt_increasing"
      ("a" "nn_log(gt1x!1)(y!1)" "b" "nn_log(gt1x!1)(x!1)" "x" "gt1x!1"))
     (assert)
     (rewrite "nn_expt_log")
     (rewrite "nn_expt_log")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "gt1x!1")
   (typepred "x!1")
   (expand ">=" -1)
   (expand "<=" -1)
   (rewrite "nnreal_expt_pos")
   (split)
   (("1"
     (lemma "nnreal_expt_gt1" ("x" "gt1x!1" "pa" "x!1"))
     (("1" (assert)) ("2" (assert))))
    ("2"
     (replace -1 * rl)
     (rewrite "nnreal_expt_nat_rew")
     (rewrite "expt_x0")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "nnreal_expt_pos")
   (typepred "x!1")
   (expand ">=")
   (expand "<=" -1)
   (split)
   (("1"
     (lemma "nnreal_expt_lt1" ("x" "lt1x!1" "pa" "x!1"))
     (("1" (assert)) ("2" (assert))))
    ("2"
     (replace -1 * rl)
     (rewrite "nnreal_expt_nat_rew")
     (rewrite "expt_x0")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "nnreal_expt_pos" ("px" "ne1x!1" "a" "y!1"))
   (assert)
   (flatten)
   (lemma "trich_lt" ("x" "ne1x!1" "y" "1"))
   (split -1)
   (("1"
     (assert)
     (hide 1)
     (case-replace "y!1=0")
     (("1"
       (rewrite "nnreal_expt_rat_rew")
       (rewrite "nn_rational_expt_nat_rew")
       (rewrite "expt_x0")
       (assert))
      ("2"
       (case "y!1>0")
       (("1"
         (hide 1)
         (lemma "nnreal_expt_lt1" ("x" "ne1x!1" "pa" "y!1"))
         (("1" (assert)) ("2" (propax))))
        ("2" (assert))))))
    ("2" (assert))
    ("3"
     (assert)
     (hide 2)
     (case-replace "y!1=0")
     (("1"
       (rewrite "nnreal_expt_rat_rew")
       (rewrite "nn_rational_expt_nat_rew")
       (rewrite "expt_x0")
       (assert))
      ("2"
       (lemma "nnreal_expt_gt1" ("x" "ne1x!1" "pa" "y!1"))
       (("1" (assert)) ("2" (assert))))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (subtype-tcc)
   (("1"
     (lemma "le_times_le_pos" ("nnx" "1" "y" "x!1" "nnz" "1" "w" "y!1"))
     (assert))
    ("2"
     (lemma "le_times_le_pos" ("nnx" "x!1" "y" "1" "nnz" "y!1" "w" "1"))
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "y!1")
   (split)
   (("1" (flatten) (assert) (rewrite "div_mult_pos_lt1" 2))
    ("2" (flatten) (assert) (rewrite "div_mult_pos_gt1" 1))))


proof_type: t_proof
decl_type: tcc
library: power
theory: nn_log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "y!1")
   (split)
   (("1" (flatten) (assert) (rewrite "div_mult_pos_ge1" 1))
    ("2" (flatten) (assert) (rewrite "div_mult_pos_le1" 2))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "trich_lt" ("x" "z!1" "y" "0"))
   (split -1)
   (("1"
     (expand "log")
     (case-replace "ne1x!1>1")
     (("1"
       (assert)
       (lemma "real_expt_lt1" ("x" "ne1x!1" "a" "z!1"))
       (assert)
       (rewrite "inv_real_expt" + :dir rl)
       (rewrite "real_expt_neg" + :dir rl)
       (expand "^")
       (rewrite "nn_log_expt")
       (assert))
      ("2"
       (assert)
       (lemma "real_expt_gt1" ("x" "ne1x!1" "a" "z!1"))
       (assert)
       (rewrite "inv_real_expt" + :dir rl)
       (rewrite "real_expt_neg" + :dir rl)
       (expand "^")
       (rewrite "nn_log_expt")
       (assert))))
    ("2"
     (replace -1)
     (rewrite "real_expt_x0")
     (expand "log")
     (rewrite "nn_log_1")
     (lift-if)
     (assert))
    ("3"
     (expand "log")
     (case-replace "ne1x!1 > 1")
     (("1"
       (assert)
       (lemma "real_expt_gt1" ("x" "ne1x!1" "a" "z!1"))
       (assert)
       (expand "^")
       (rewrite "nn_log_expt"))
      ("2"
       (lemma "real_expt_lt1" ("x" "ne1x!1" "a" "z!1"))
       (assert)
       (expand "^")
       (rewrite "nn_log_expt"))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "ne1x!1>1")
   (("1"
     (case "y!1>=1")
     (("1" (expand "log") (assert) (expand "^") (rewrite "nn_expt_log"))
      ("2"
       (case "y!1<1")
       (("1"
         (hide 1)
         (lemma "real_expt_neg" ("px" "ne1x!1" "a" "-log(ne1x!1)(y!1)"))
         (replace -1)
         (hide -1)
         (rewrite "inv_real_expt")
         (case "ne1x!1 ^ -log(ne1x!1)(y!1) = 1/y!1")
         (("1" (replace -1) (rewrite "div_div1"))
          ("2"
           (hide 2)
           (expand "log")
           (assert)
           (expand "^")
           (lemma "nn_expt_log" ("ne1x" "ne1x!1" "y" "1/y!1"))
           (assert))))
        ("2" (assert))))))
    ("2"
     (case "ne1x!1<1")
     (("1"
       (case "y!1<=1")
       (("1"
         (hide 1)
         (expand "log")
         (assert)
         (expand "^")
         (rewrite "nn_expt_log"))
        ("2"
         (case "y!1>1")
         (("1"
           (hide 1 2)
           (lemma "real_expt_neg"
            ("px" "ne1x!1" "a" "nn_log(ne1x!1)(1 / y!1)"))
           (("1"
             (rewrite "inv_real_expt")
             (expand "^")
             (expand "log")
             (assert)
             (typepred "nn_log(ne1x!1)(1 / y!1)")
             (expand ">=" -1)
             (expand "<=" -1)
             (split -1)
             (("1"
               (assert)
               (replace -2)
               (hide -2)
               (rewrite "nn_expt_log")
               (rewrite "div_div1"))
              ("2"
               (replace -1 * rl)
               (assert)
               (rewrite "nnreal_expt_nat_rew")
               (rewrite "expt_x0")
               (hide -2)
               (expand "nn_log")
               (expand "log_lt1")
               (lemma "nnreal_bijective2" ("lt1x" "ne1x!1"))
               (lemma "bijective_inverse[nnreal, {r | r <= 1}]"
                ("f"
                 "LAMBDA (y:nnreal): nnreal_expt(ne1x!1, y)"
                 "y"
                 "1/y!1"
                 "x"
                 "0"))
               (("1"
                 (assert)
                 (rewrite "nnreal_expt_nat_rew" -1)
                 (rewrite "expt_x0")
                 (assert))
                ("2" (propax))
                ("3"
                 (skosimp)
                 (case-replace "y!2=0")
                 (("1"
                   (rewrite "nnreal_expt_nat_rew" 1)
                   (rewrite "expt_x0")
                   (assert))
                  ("2"
                   (lemma "nnreal_expt_lt1" ("x" "ne1x!1" "pa" "y!2"))
                   (("1" (assert) (rewrite "nnreal_expt_pos" 2))
                    ("2" (assert))))))))))
            ("2" (assert) (assert) (rewrite "div_mult_pos_le1"))))
          ("2" (assert))))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "log")
   (case-replace "ne1x!1 >1")
   (("1" (assert) (rewrite "nn_log_ne1x"))
    ("2" (assert) (rewrite "nn_log_ne1x"))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (x: {r | r > 1}, y: posreal):
                 log(1/x)(y) = log(x)(1 / y)")
   (("1"
     (skosimp)
     (case "ne1x!1>1")
     (("1" (inst - "ne1x!1" "y!1"))
      ("2"
       (inst - "1/ne1x!1" "1/y!1")
       (("1"
         (rewrite "div_div1")
         (rewrite "div_div1")
         (rewrite "div_div1")
         (rewrite "div_div1")
         (assert))
        ("2" (assert) (rewrite "div_mult_pos_gt1" 1))))))
    ("2"
     (hide 2)
     (skosimp)
     (expand "log")
     (typepred "x!1")
     (rewrite "div_mult_pos_lt1" 1)
     (rewrite "div_mult_pos_ge1" 1)
     (case-replace "y!1=1")
     (("1" (assert) (rewrite "nn_log_1") (rewrite "nn_log_1"))
      ("2"
       (case "y!1<1")
       (("1"
         (assert)
         (hide 1)
         (lemma "nn_inv_base_log" ("ne1x" "x!1" "y" "y!1"))
         (propax))
        ("2"
         (assert)
         (case "y!1>1")
         (("1"
           (hide 1 2)
           (lemma "nn_inv_base_log" ("ne1x" "x!1" "y" "1/y!1"))
           (("1" (replace -1) (lift-if 1) (rewrite "div_mult_pos_gt1" 1))
            ("2" (assert) (rewrite "div_mult_pos_le1" 1))))
          ("2" (assert))))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "log")
   (case-replace "ne1x!1>1")
   (("1"
     (lemma "trich_lt" ("x" "y!1" "y" "1"))
     (split -1)
     (("1" (assert) (rewrite "div_mult_pos_ge1" 1) (assert))
      ("2" (replace -1) (assert) (rewrite "nn_log_1") (assert))
      ("3" (assert) (rewrite "div_mult_pos_ge1" 1) (assert))))
    ("2"
     (assert)
     (lemma "trich_lt" ("x" "y!1" "y" "1"))
     (split -1)
     (("1" (assert) (rewrite "div_mult_pos_le1" 2) (rewrite "div_div1"))
      ("2" (replace -1) (assert) (rewrite "nn_log_1") (assert))
      ("3" (assert) (rewrite "div_mult_pos_le1" 2) (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "ne1x!1>1")
   (("1"
     (case "x!1>=1")
     (("1"
       (case "y!1>=1")
       (("1"
         (lemma "le_times_le_pos"
          ("nnx" "1" "y" "x!1" "nnz" "1" "w" "y!1"))
         (expand "log")
         (assert)
         (rewrite "nn_log_plus"))
        ("2"
         (case "y!1<1")
         (("1"
           (hide 1)
           (case "x!1*y!1>=1")
           (("1"
             (expand "log")
             (assert)
             (lemma "nn_log_plus"
              ("ne1x" "ne1x!1" "x" "x!1 * y!1" "y" "1/y!1"))
             (assert))
            ("2"
             (case "x!1*y!1<1")
             (("1"
               (hide 1)
               (expand "log")
               (assert)
               (lemma "nn_log_plus"
                ("ne1x" "ne1x!1" "x" "x!1" "y" "1 / (x!1 * y!1)"))
               (case-replace "x!1 * (1 / (x!1 * y!1))=1/y!1")
               (("1" (assert)) ("2" (assert))))
              ("2" (assert))))))
          ("2" (assert))))))
      ("2"
       (case "x!1<1")
       (("1"
         (hide 1)
         (case "y!1>=1")
         (("1"
           (case "x!1 * y!1>=1")
           (("1"
             (expand "log")
             (assert)
             (lemma "nn_log_plus"
              ("ne1x" "ne1x!1" "x" "x!1*y!1" "y" "1/x!1"))
             (assert))
            ("2"
             (expand "log")
             (assert)
             (lemma "nn_log_plus"
              ("ne1x" "ne1x!1" "x" "y!1" "y" "1 / (x!1 * y!1)"))
             (case-replace "y!1 * (1 / (x!1 * y!1))=1/x!1")
             (("1" (assert)) ("2" (assert))))))
          ("2"
           (lemma "lt_times_lt_pos1"
            ("px" "x!1" "y" "1" "nnz" "y!1" "w" "1"))
           (expand "log")
           (assert)
           (lemma "nn_log_plus"
            ("ne1x" "ne1x!1" "x" "1/x!1" "y" "1/y!1"))
           (assert))))
        ("2" (assert))))))
    ("2"
     (case "ne1x!1<1")
     (("1"
       (hide 1)
       (case "x!1<=1")
       (("1"
         (case "y!1<=1")
         (("1"
           (lemma "le_times_le_pos"
            ("nnx" "x!1" "y" "1" "nnz" "y!1" "w" "1"))
           (expand "log")
           (assert)
           (rewrite "nn_log_plus"))
          ("2"
           (case "y!1>1")
           (("1"
             (hide 1)
             (case "x!1 * y!1<=1")
             (("1"
               (expand "log")
               (assert)
               (lemma "nn_log_plus"
                ("ne1x" "ne1x!1" "x" "x!1 * y!1" "y" "1/y!1"))
               (case-replace "x!1 * y!1 * (1 / y!1)=x!1")
               (("1" (assert)) ("2" (assert))))
              ("2"
               (expand "log")
               (assert)
               (lemma "nn_log_plus"
                ("ne1x" "ne1x!1" "y" "1/(x!1*y!1)" "x" "x!1"))
               (case-replace "x!1 * (1 / (x!1 * y!1))=1/y!1")
               (("1" (assert)) ("2" (assert))))))
            ("2" (assert))))))
        ("2"
         (case "x!1>1")
         (("1"
           (hide 1)
           (case "y!1<=1")
           (("1"
             (case "x!1*y!1<=1")
             (("1"
               (expand "log")
               (assert)
               (lemma "nn_log_plus"
                ("ne1x" "ne1x!1" "x" "x!1 * y!1" "y" "1/x!1"))
               (assert))
              ("2"
               (expand "log")
               (assert)
               (lemma "nn_log_plus"
                ("ne1x" "ne1x!1" "x" "y!1" "y" "1/(x!1*y!1)"))
               (assert))))
            ("2"
             (lemma "lt_times_lt_pos1"
              ("px" "1" "y" "x!1" "nnz" "1" "w" "y!1"))
             (expand "log")
             (assert)
             (lemma "nn_log_plus"
              ("ne1x" "ne1x!1" "x" "1/x!1" "y" "1/y!1"))
             (assert))))
          ("2" (assert))))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "log_inv" ("ne1x" "ne1x!1" "y" "y!1"))
   (lemma "log_mult" ("ne1x" "ne1x!1" "x" "x!1" "y" "1/y!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case-replace "x!1 ^ z!1=ne1x!1^(z!1*log(ne1x!1)(x!1))")
   (("1" (rewrite "log_expt"))
    ("2"
     (hide 2)
     (lemma "real_expt_times"
      ("x" "ne1x!1" "a" "log(ne1x!1)(x!1)" "b" "z!1"))
     (("1" (rewrite "expt_log" -1) (assert))
      ("2" (rewrite "expt_log" 1) (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "log(gt1x!1)(x!1) = log(gt1x!1)(y!1)")
   (("1"
     (lemma "expt_log" ("ne1x" "gt1x!1" "y" "x!1"))
     (lemma "expt_log" ("ne1x" "gt1x!1" "y" "y!1"))
     (assert))
    ("2"
     (lemma "real_expt_increasing"
      ("gt1x" "gt1x!1" "a" "log(gt1x!1)(y!1)" "b" "log(gt1x!1)(x!1)"))
     (rewrite "expt_log")
     (rewrite "expt_log")
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "log(lt1x!1)(x!1) = log(lt1x!1)(y!1)")
   (("1"
     (lemma "expt_log" ("ne1x" "lt1x!1" "y" "x!1"))
     (replace -1 -3 rl)
     (lemma "expt_log" ("ne1x" "lt1x!1" "y" "y!1"))
     (replace -1 -4 rl)
     (replace -3)
     (assert))
    ("2"
     (lemma "real_expt_decreasing"
      ("lt1x" "lt1x!1" "a" "log(lt1x!1)(x!1)" "b" "log(lt1x!1)(y!1)"))
     (rewrite "expt_log")
     (rewrite "expt_log")
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (lemma "trich_lt" ("x" "y!1" "y" "1"))
     (split)
     (("1"
       (case "ne1x!1>1")
       (("1"
         (lemma "log_increasing" ("x" "y!1" "y" "1" "gt1x" "ne1x!1"))
         (("1" (rewrite "log_1") (assert)) ("2" (propax))))
        ("2"
         (lemma "log_decreasing" ("x" "y!1" "y" "1" "lt1x" "ne1x!1"))
         (("1" (rewrite "log_1") (assert)) ("2" (assert))))))
      ("2" (propax))
      ("3"
       (case "ne1x!1>1")
       (("1"
         (lemma "log_increasing" ("y" "y!1" "x" "1" "gt1x" "ne1x!1"))
         (("1" (rewrite "log_1") (assert)) ("2" (propax))))
        ("2"
         (lemma "log_decreasing" ("y" "y!1" "x" "1" "lt1x" "ne1x!1"))
         (("1" (rewrite "log_1") (assert)) ("2" (assert))))))))
    ("2" (flatten) (replace -1) (rewrite "log_1"))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (case-replace "ne1x!1>1")
     (("1"
       (hide 2)
       (lemma "log_increasing" ("gt1x" "ne1x!1" "x" "y!1" "y" "1"))
       (("1"
         (rewrite "log_1")
         (case-replace "y!1=1")
         (("1" (rewrite "log_1") (assert)) ("2" (assert))))
        ("2" (propax))))
      ("2"
       (assert)
       (hide 2)
       (case-replace "y!1=1")
       (("1" (rewrite "log_1") (assert))
        ("2"
         (lemma "log_decreasing" ("lt1x" "ne1x!1" "x" "1" "y" "y!1"))
         (rewrite "log_1")
         (assert))))))
    ("2"
     (flatten)
     (split)
     (("1"
       (flatten)
       (lemma "log_increasing" ("gt1x" "ne1x!1" "x" "1" "y" "y!1"))
       (("1" (rewrite "log_1") (assert)) ("2" (propax))))
      ("2"
       (flatten)
       (lemma "log_decreasing" ("lt1x" "ne1x!1" "y" "1" "x" "y!1"))
       (("1" (rewrite "log_1") (assert)) ("2" (propax))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "log_pos" ("ne1x" "ne1x!1" "y" "y!1"))
   (lemma "log_is_0" ("ne1x" "ne1x!1" "y" "y!1"))
   (lemma "trich_lt" ("x" "log(ne1x!1)(y!1)" "y" "0"))
   (split -1)
   (("1"
     (assert)
     (flatten)
     (case-replace "ne1x!1 > 1")
     (("1" (assert)) ("2" (assert))))
    ("2" (assert))
    ("3"
     (assert)
     (split)
     (("1" (split) (("1" (flatten) (assert)) ("2" (flatten) (assert))))
      ("2"
       (split)
       (("1" (flatten) (assert)) ("2" (flatten) (assert))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem + ("x!1" "y!1" "z!1"))
   (flatten)
   (case "log(x!1)(z!1) = log(y!1)(z!1)")
   (("1"
     (hide 1)
     (lemma "expt_log" ("ne1x" "x!1" "y" "z!1"))
     (lemma "expt_log" ("ne1x" "y!1" "y" "z!1"))
     (replace -3 -1 rl)
     (lemma "trich_lt" ("x" "log(x!1)(z!1)" "y" "0"))
     (split -1)
     (("1"
       (lemma "real_expt_strict_decreasing"
        ("px" "x!1" "y" "y!1" "na" "log(x!1)(z!1)"))
       (("1" (assert)) ("2" (assert))))
      ("2" (assert) (rewrite "log_is_0" -1))
      ("3"
       (lemma "real_expt_strict_increasing"
        ("x" "x!1" "y" "y!1" "pa" "log(x!1)(z!1)"))
       (("1" (assert)) ("2" (assert))))))
    ("2"
     (case "log(x!1)(z!1) > log(y!1)(z!1)")
     (("1"
       (hide 1 2)
       (split)
       (("1"
         (flatten)
         (split)
         (("1"
           (lemma "log_neg" ("ne1x" "x!1" "y" "z!1"))
           (assert)
           (lemma "real_expt_strict_decreasing"
            ("px" "x!1" "y" "y!1" "na" "log(x!1)(z!1)"))
           (lemma "real_expt_increasing"
            ("a" "log(y!1)(z!1)" "b" "log(x!1)(z!1)" "gt1x" "y!1"))
           (rewrite "expt_log")
           (rewrite "expt_log")
           (assert))
          ("2"
           (lemma "log_pos" ("ne1x" "y!1" "y" "z!1"))
           (assert)
           (lemma "real_expt_strict_increasing"
            ("x" "x!1" "y" "y!1" "pa" "log(y!1)(z!1)"))
           (lemma "real_expt_decreasing"
            ("a" "log(y!1)(z!1)" "b" "log(x!1)(z!1)" "lt1x" "x!1"))
           (rewrite "expt_log")
           (rewrite "expt_log")
           (assert))))
        ("2"
         (flatten)
         (lemma "log_neg" ("ne1x" "x!1" "y" "z!1"))
         (assert)
         (lemma "log_pos" ("ne1x" "y!1" "y" "z!1"))
         (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem + ("x!1" "y!1" "z!1"))
   (flatten)
   (lemma "log_increasing1"
    ("ne1x" "1/y!1" "ne1y" "1/x!1" "ne1z" "1/z!1"))
   (rewrite "inv_base_log")
   (rewrite "inv_base_log")
   (case-replace "1 / (1 / z!1)=z!1")
   (("1"
     (hide -1)
     (case-replace "1 / y!1 < 1 / x!1")
     (("1"
       (hide -1)
       (split -1)
       (("1" (assert))
        ("2"
         (hide 2)
         (flatten)
         (split -1)
         (("1"
           (flatten)
           (hide 1)
           (assert)
           (rewrite "div_mult_pos_lt1" 1)
           (rewrite "div_mult_pos_gt1" 1)
           (rewrite "div_mult_pos_gt1" 1))
          ("2"
           (flatten)
           (rewrite "div_mult_pos_lt1" 1)
           (hide 2)
           (assert)
           (flatten)
           (rewrite "div_mult_pos_lt1" 2)
           (split)
           (("1" (assert))
            ("2" (assert) (rewrite "div_mult_pos_gt1" 1))))))))
      ("2"
       (hide -1 -2 2)
       (rewrite "div_mult_pos_lt1")
       (lemma "div_mult_pos_lt2" ("py" "x!1" "z" "y!1" "x" "1"))
       (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (case-replace "x!1=y!1")
     (("1" (assert))
      ("2"
       (lemma "log_increasing" ("gt1x" "gt1x!1" "x" "y!1" "y" "x!1"))
       (assert))))
    ("2"
     (flatten)
     (lemma "log_increasing" ("gt1x" "gt1x!1" "x" "x!1" "y" "y!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (split)
   (("1"
     (flatten)
     (split)
     (("1"
       (lemma "log_increasing" ("gt1x" "gt1x!1" "x" "y!1" "y" "x!1"))
       (assert))
      ("2"
       (lemma "log_increasing" ("gt1x" "gt1x!1" "x" "y!1" "y" "x!1"))
       (assert))))
    ("2"
     (flatten)
     (split)
     (("1"
       (lemma "log_increasing" ("gt1x" "gt1x!1" "x" "x!1" "y" "y!1"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (lemma "log_decreasing" ("lt1x" "lt1x!1" "x" "x!1" "y" "y!1"))
     (assert))
    ("2"
     (flatten)
     (lemma "log_decreasing" ("lt1x" "lt1x!1" "x" "y!1" "y" "x!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (expand "<=")
     (expand ">=")
     (expand "<=")
     (flatten)
     (lemma "log_decreasing" ("lt1x" "lt1x!1" "x" "x!1" "y" "y!1"))
     (assert))
    ("2"
     (flatten)
     (expand ">=")
     (expand "<=")
     (flatten)
     (split)
     (("1"
       (lemma "log_decreasing" ("lt1x" "lt1x!1" "x" "y!1" "y" "x!1"))
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "ne1x!1<1")
   (("1"
     (split)
     (("1"
       (flatten)
       (lemma "both_sides_log_lt1_le"
        ("lt1x" "ne1x!1" "x" "x!1" "y" "y!1"))
       (("1"
         (lemma "both_sides_log_lt1_ge"
          ("lt1x" "ne1x!1" "x" "x!1" "y" "y!1"))
         (assert))
        ("2" (propax))))
      ("2" (flatten) (assert))))
    ("2"
     (split)
     (("1"
       (flatten)
       (lemma "both_sides_log_gt1_le"
        ("gt1x" "ne1x!1" "x" "x!1" "y" "y!1"))
       (("1"
         (lemma "both_sides_log_gt1_ge"
          ("gt1x" "ne1x!1" "x" "x!1" "y" "y!1"))
         (assert))
        ("2" (assert))))
      ("2" (flatten) (assert))))))


proof_type: t_proof
decl_type: tcc
library: power
theory: log
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case-replace "ne1x!1>1")
   (("1"
     (case "y!1<1")
     (("1" (hide 1 2 4) (rewrite "div_mult_pos_ge1" 1) (assert))
      ("2" (assert))))
    ("2" (assert) (rewrite "div_mult_pos_le1" 5))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (case-replace "z!1=0")
   (("1" (rewrite "nn_root_0n"))
    ("2"
     (assert)
     (lemma "expt_nn_root" ("x" "z!1" "pn" "pn!1"))
     (lemma "expt_alt_def" ("x" "exp(ln(z!1) / pn!1)" "i" "pn!1"))
     (assert)
     (rewrite "ln_exp")
     (lemma "div_cancel1")
     (inst - "pn!1" "ln(z!1)")
     (replace -1)
     (rewrite "exp_ln")
     (hide -1)
     (lemma "both_sides_nn_root"
      ("x" "z!1" "y" "exp(ln(z!1) / pn!1)^pn!1" "pn" "pn!1"))
     (lemma "nn_root_expt" ("x" "exp(ln(z!1) / pn!1)" "pn" "pn!1"))
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "nn_rational_expt")
   (rewrite "expt_exp")
   (("1"
     (rewrite "nn_root_def")
     (rewrite "ln_exp")
     (lemma "rational_def" ("r" "q!1"))
     (assert))
    ("2"
     (hide 2)
     (typepred "q!1")
     (expand ">=" -1)
     (expand "<=" -1)
     (split)
     (("1" (lemma "numerator_pos" ("r" "q!1")) (assert))
      ("2" (lemma "numerator_is_zero" ("r" "q!1")) (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "nnreal_expt")
   (assert)
   (case-replace "z!1=0")
   (("1" (rewrite "exp_0"))
    ("2"
     (assert)
     (case "z!1>0")
     (("1"
       (hide 1)
       (lemma "trich_lt" ("x" "y!1" "y" "1"))
       (split)
       (("1"
         (assert)
         (typepred
          "glb(extend[real, nnreal, bool, FALSE]
                                        ({z | EXISTS q: q <= z!1 AND z = nn_rational_expt(y!1, q)}))")
         (name-replace "GLB"
          "glb(extend[real, nnreal, bool, FALSE]
                                        ({z | EXISTS q: q <= z!1 AND z = nn_rational_expt(y!1, q)}))")
         (expand "extend")
         (expand "greatest_lower_bound?")
         (flatten)
         (expand "lower_bound?")
         (lemma "trich_lt" ("x" "GLB" "y" "exp(z!1 * ln(y!1))"))
         (split -1)
         (("1"
           (hide 1)
           (lemma "exp_continuous")
           (expand "continuous?")
           (inst - "z!1 * ln(y!1)")
           (expand "continuous?")
           (name "EPS" "exp(z!1 * ln(y!1))-GLB")
           (inst - "EPS")
           (("1"
             (skosimp)
             (lemma "ln_strict_increasing")
             (expand "strict_increasing?")
             (inst - "y!1" "1")
             (rewrite "ln_1")
             (assert)
             (lemma "posreal_div_posreal_is_posreal"
              ("px" "delta!1" "py" "abs(ln(y!1))"))
             (("1"
               (inst -7 "exp(z!1 * ln(y!1))")
               (split -7)
               (("1" (assert))
                ("2"
                 (skosimp)
                 (typepred "s!1")
                 (assert)
                 (skosimp)
                 (lemma "both_sides_times_neg_le1"
                  ("nz" "ln(y!1)" "y" "q!1" "x" "z!1"))
                 (assert)
                 (lemma "exp_increasing")
                 (expand "increasing?")
                 (inst - "z!1 * ln(y!1)" "q!1 * ln(y!1)")
                 (assert)
                 (rewrite "nn_rational_expt_def")
                 (assert))))
              ("2" (assert))))
            ("2" (assert))))
          ("2" (propax))
          ("3"
           (hide -3)
           (name "EPS" "GLB-exp(z!1 * ln(y!1))")
           (case "EPS>0")
           (("1"
             (lemma "exp_continuous")
             (expand "continuous?")
             (inst - "z!1 * ln(y!1)")
             (expand "continuous?")
             (inst - "EPS")
             (("1"
               (skosimp)
               (lemma "ln_strict_increasing")
               (expand "strict_increasing?")
               (inst - "y!1" "1")
               (rewrite "ln_1")
               (assert)
               (lemma "posreal_div_posreal_is_posreal"
                ("px" "delta!1" "py" "abs(ln(y!1))"))
               (("1"
                 (lemma "density_positive"
                  ("x" "max(0,z!1-delta!1 / abs(ln(y!1)))" "y" "z!1"))
                 (assert)
                 (split)
                 (("1"
                   (skosimp)
                   (inst - "r!1*ln(y!1)")
                   (lemma "abs_mult" ("x" "r!1-z!1" "y" "ln(y!1)"))
                   (replace -1)
                   (lemma "div_mult_pos_lt2"
                    ("x"
                     "abs(r!1 - z!1)"
                     "py"
                     "abs(ln(y!1))"
                     "z"
                     "delta!1"))
                   (replace -1 * rl)
                   (hide -1 -2)
                   (name-replace "DELTA" "delta!1 / abs(ln(y!1))")
                   (expand "abs" -5)
                   (assert)
                   (lemma "both_sides_times_neg_lt1"
                    ("nz" "ln(y!1)" "y" "r!1" "x" "z!1"))
                   (assert)
                   (lemma "exp_strict_increasing")
                   (expand "strict_increasing?")
                   (inst - "z!1 * ln(y!1)" "r!1 * ln(y!1)")
                   (assert)
                   (inst - "exp(r!1 * ln(y!1))")
                   (("1" (assert))
                    ("2"
                     (inst + "r!1")
                     (assert)
                     (rewrite "nn_rational_expt_def"))))
                  ("2"
                   (name-replace "DELTA" "delta!1 / abs(ln(y!1))")
                   (hide-all-but (-1 -9 1))
                   (grind))
                  ("3"
                   (name-replace "DELTA" "delta!1 / abs(ln(y!1))")
                   (hide-all-but (-1 -9 1))
                   (grind))))
                ("2" (assert))))
              ("2" (assert))))
            ("2" (assert))))))
        ("2" (assert) (replace -1) (assert))
        ("3"
         (assert)
         (typepred
          "lub(extend[real, nnreal, bool, FALSE]
                                        ({z | EXISTS q: q <= z!1 AND z = nn_rational_expt(y!1, q)}))")
         (name-replace "LUB"
          "lub(extend[real, nnreal, bool, FALSE]
                                        ({z | EXISTS q: q <= z!1 AND z = nn_rational_expt(y!1, q)}))")
         (expand "least_upper_bound?")
         (expand "extend")
         (expand "upper_bound?")
         (flatten)
         (lemma "ln_strict_increasing")
         (expand "strict_increasing?")
         (inst - "1" "y!1")
         (rewrite "ln_1")
         (assert)
         (lemma "trich_lt" ("x" "LUB" "y" "exp(z!1 * ln(y!1))"))
         (split)
         (("1"
           (hide -4 1)
           (name "EPS" "exp(z!1 * ln(y!1))-LUB")
           (lemma "exp_continuous")
           (expand "continuous?")
           (inst - "z!1*ln(y!1)")
           (expand "continuous?")
           (inst - "EPS")
           (("1"
             (skosimp)
             (lemma "posreal_div_posreal_is_posreal"
              ("px" "delta!1" "py" "ln(y!1)"))
             (lemma "density_positive"
              ("x" "max(0,z!1-delta!1 / ln(y!1))" "y" "z!1"))
             (assert)
             (split)
             (("1"
               (skosimp)
               (inst -4 "r!1*ln(y!1)")
               (lemma "abs_mult" ("x" "r!1-z!1" "y" "ln(y!1)"))
               (replace -1)
               (lemma "div_mult_pos_lt2"
                ("x"
                 " abs(r!1 - z!1)"
                 "py"
                 "abs(ln(y!1))"
                 "z"
                 "delta!1"))
               (("1"
                 (replace -1 * rl)
                 (expand "abs")
                 (assert)
                 (hide -1 -2)
                 (lemma "both_sides_times_pos_lt1"
                  ("pz" "ln(y!1)" "x" "r!1" "y" "z!1"))
                 (assert)
                 (lemma "exp_strict_increasing")
                 (expand "strict_increasing?")
                 (inst - "r!1 * ln(y!1)" "z!1 * ln(y!1)")
                 (assert)
                 (inst - "exp(r!1*ln(y!1))")
                 (("1" (assert))
                  ("2"
                   (inst + "r!1")
                   (assert)
                   (rewrite "nn_rational_expt_def"))))
                ("2" (expand "abs") (assert))))
              ("2"
               (name-replace "DELTA" "delta!1 / ln(y!1)")
               (hide-all-but (-1 -8 1))
               (grind))
              ("3"
               (name-replace "DELTA" "delta!1 / ln(y!1)")
               (hide-all-but (-1 -8 1))
               (grind))))
            ("2" (assert))))
          ("2" (propax))
          ("3"
           (inst -4 "exp(z!1 * ln(y!1))")
           (split)
           (("1" (assert))
            ("2"
             (skosimp)
             (hide 2)
             (typepred "s!1")
             (assert)
             (skosimp)
             (lemma "both_sides_times_pos_le1"
              ("pz" "ln(y!1)" "x" "q!1" "y" "z!1"))
             (assert)
             (lemma "exp_increasing")
             (expand "increasing?")
             (inst - "q!1 * ln(y!1)" "z!1 * ln(y!1)")
             (assert)
             (rewrite "nn_rational_expt_def")
             (assert))))))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "^")
   (case-replace "x!1>=0")
   (("1" (rewrite "nnreal_expt_def"))
    ("2"
     (assert)
     (rewrite "nnreal_expt_def")
     (rewrite "ln_div")
     (assert))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "nn_expt_log" ("y" "y!1" "ne1x" "r!1"))
   (rewrite "nnreal_expt_def")
   (lemma "ln_exp" ("x" "nn_log(r!1)(y!1) * ln(r!1)"))
   (replace -2)
   (assert))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "ne1x!1")
   (lemma "trich_lt" ("x" "ne1x!1" "y" "1"))
   (split -1)
   (("1"
     (expand "log")
     (expand "log")
     (assert)
     (case-replace "y!1<=1")
     (("1" (rewrite "nn_log_def"))
      ("2"
       (assert)
       (rewrite "nn_log_def")
       (("1" (rewrite "ln_div") (assert))
        ("2" (rewrite "div_mult_pos_le1" 1))))))
    ("2" (replace -1) (rewrite "ln_1") (assert))
    ("3"
     (expand "log")
     (expand "log")
     (assert)
     (case-replace "y!1>=1")
     (("1" (rewrite "nn_log_def"))
      ("2"
       (assert)
       (rewrite "nn_log_def")
       (("1" (rewrite "ln_div") (assert))
        ("2" (rewrite "div_mult_pos_ge1" 1))))))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "continuous")
   (skosimp)
   (case-replace "log(ne1x!1)=lambda (y:posreal): ln(y)/ln(ne1x!1)")
   (("1"
     (hide -1)
     (lemma "ln_continuous")
     (lemma "scal_cont_fun[posreal]" ("f" "ln" "u" "1/ln(ne1x!1)"))
     (("1"
       (assert)
       (hide -2)
       (expand "continuous" -1)
       (inst - "x0!1")
       (expand "*")
       (case-replace
        "(LAMBDA (x: posreal): 1 / ln(ne1x!1) * ln(x))=(LAMBDA (y: posreal): ln(y) / ln(ne1x!1))")
       (hide -1 2)
       (apply-extensionality :hide? t))
      ("2"
       (hide-all-but 1)
       (expand "/=")
       (lemma "ln_strict_increasing")
       (expand "strict_increasing?")
       (case "ne1x!1<1")
       (("1" (inst - "ne1x!1" "1") (rewrite "ln_1") (assert))
        ("2" (inst - "1" "ne1x!1") (rewrite "ln_1") (assert))))))
    ("2"
     (hide 2)
     (apply-extensionality :hide? t)
     (("1"
       (lemma "log_def" ("ne1x" "ne1x!1" "y" "x!1"))
       (expand "log" -1)
       (propax))
      ("2"
       (lemma "ln_strict_increasing")
       (expand "strict_increasing?")
       (case "ne1x!1<1")
       (("1" (inst - "ne1x!1" "1") (rewrite "ln_1") (assert))
        ("2" (inst - "1" "ne1x!1") (rewrite "ln_1") (assert))))))
    ("3"
     (assert)
     (expand "/=")
     (lemma "ln_strict_increasing")
     (expand "strict_increasing?")
     (case "ne1x!1<1")
     (("1" (inst - "ne1x!1" "1") (rewrite "ln_1") (assert))
      ("2" (inst - "1" "ne1x!1") (rewrite "ln_1") (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "ln_derivable")
   (flatten)
   (case "ln(ne1x!1)=0")
   (("1" (lemma "ln_eq_0" ("px" "ne1x!1")) (assert))
    ("2"
     (lemma "scal_derivable_fun[posreal]" ("f" "ln" "b" "1/ln(ne1x!1)"))
     (("1"
       (assert)
       (lemma "deriv_scal_fun[posreal]" ("b" "1 / ln(ne1x!1)" "ff" "ln"))
       (replace -4)
       (expand "*" -1 2)
       (case-replace "(1 / ln(ne1x!1) * ln)=log(ne1x!1)")
       (("1" (assert))
        ("2"
         (apply-extensionality :hide? t)
         (hide-all-but (1 2))
         (lemma "log_def" ("ne1x" "ne1x!1" "y" "x!1"))
         (expand "log" -1)
         (expand "*")
         (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem + ("a!1"))
   (case-replace "(LAMBDA y: y ^ a!1)=lambda y: exp(a!1*ln(y))")
   (("1"
     (hide -1)
     (lemma "ln_continuous")
     (lemma "exp_continuous")
     (lemma "scal_fun_continuous[posreal]" ("u" "a!1" "h" "ln"))
     (("1"
       (lemma "composition_cont_fun[posreal,real]"
        ("f" "*[posreal](a!1, ln)" "g" "exp"))
       (assert)
       (expand "o")
       (expand "*")
       (propax))
      ("2" (propax))))
    ("2"
     (hide 2)
     (apply-extensionality :hide? t)
     (rewrite "real_expt_def"))))


proof_type: f_proof
decl_type: formula
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (case "FORALL x: (LAMBDA y: y ^ x) = (LAMBDA y: exp(x * ln(y)))")
   (("1"
     (inst-cp - "x!1")
     (inst - "x!1-1")
     (replace -2)
     (hide -2)
     (lemma "ln_derivable")
     (lemma "exp_deriv")
     (flatten)
     (lemma "derivable_scal[posreal]" ("b" "x!1" "ff" "ln"))
     (lemma "deriv_scal_fun[posreal]" ("b" "x!1" "ff" "ln"))
     (replace -6)
     (expand "*" -1 2)
     (lemma "composition_derivable_fun[posreal,real]"
      ("f" "x!1*ln" "g" "exp"))
     (("1"
       (assert)
       (lemma "deriv_comp_fun[posreal,real]" ("ff" "x!1*ln" "gg" "exp"))
       (replace -3)
       (replace -6)
       (expand "o")
       (expand "*")
       (replace -1)
       (replace -2)
       (apply-extensionality :hide? t)
       (hide-all-but (-9 1))
       (hide -1)
       (lemma "real_expt_def" ("y" "x!2" "x" "x!1-1"))
       (replace -1)
       (assert)
       (rewrite "exp_diff")
       (rewrite "exp_ln")
       (assert))
      ("2"
       (hide-all-but 1)
       (assert)
       (expand "not_one_element?")
       (skosimp*)
       (inst + "x!2+1")
       (assert))
      ("3"
       (hide-all-but 1)
       (assert)
       (expand "deriv_domain?")
       (skosimp*)
       (inst + e!1/2)
       (grind))
      ("4"
       (hide-all-but 1)
       (assert)
       (expand "not_one_element?")
       (skosimp*)
       (inst + "x!2+1")
       (assert))
      ("5"
       (hide-all-but 1)
       (expand "deriv_domain?")
       (skosimp*)
       (inst + e!1/2)
       (grind))))
    ("2"
     (hide 2)
     (skosimp)
     (apply-extensionality :hide? t)
     (rewrite "real_expt_def"))))


proof_type: t_proof
decl_type: tcc
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (lemma "ln_strict_increasing")
     (expand "strict_increasing?")
     (inst - "1" "r!1")
     (rewrite "ln_1")
     (assert))
    ("2"
     (flatten)
     (lemma "ln_strict_increasing")
     (expand "strict_increasing?")
     (inst - "r!1" "1")
     (rewrite "ln_1")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "ne1x!1")
   (lemma "trich_lt" ("x" "ne1x!1" "y" "1"))
   (split)
   (("1"
     (lemma "ln_strict_increasing")
     (expand "strict_increasing?")
     (inst - "ne1x!1" "1")
     (rewrite "ln_1")
     (assert))
    ("2" (assert))
    ("3"
     (lemma "ln_strict_increasing")
     (expand "strict_increasing?")
     (inst - "1" "ne1x!1")
     (rewrite "ln_1")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: power
theory: ln_exp_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (hide -1)
   (skosimp)
   (typepred "y!1")
   (rewrite "zero_times3")
   (hide -1 -2)
   (lemma "ln_strict_increasing")
   (expand "strict_increasing?")
   (case "ne1x!1<1")
   (("1" (inst - "ne1x!1" "1") (rewrite "ln_1") (assert))
    ("2" (inst - "1" "ne1x!1") (rewrite "ln_1") (assert))))


proof_type: f_proof
decl_type: formula
library: probability
theory: continuous_functions_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "right_continuous?")
   (expand "left_continuous?")
   (expand "right_continuous?")
   (expand "left_continuous?")
   (case-replace
    "continuous?(f!1) IFF forall x0: FORALL epsilon : EXISTS delta : FORALL x :
                      abs(x - x0) < delta IMPLIES abs(f!1(x) - f!1(x0)) < epsilon")
   (("1"
     (hide -1)
     (split)
     (("1"
       (skosimp*)
       (split 1)
       (("1"
         (skosimp*)
         (inst - "x0!1" "epsilon!1")
         (skosimp)
         (inst + "delta!1")
         (skosimp)
         (inst - "x!1")
         (expand "abs" -3 1)
         (assert))
        ("2"
         (skosimp*)
         (inst - "x0!1" "epsilon!1")
         (skosimp)
         (inst + "delta!1")
         (skosimp)
         (inst - "x!1")
         (expand "abs" -3 1)
         (expand "<=" -1)
         (split -1)
         (("1" (split -3) (("1" (propax)) ("2" (assert))))
          ("2" (split -3) (("1" (propax)) ("2" (assert))))))))
      ("2"
       (skosimp*)
       (inst - "x0!1")
       (inst - "epsilon!1")
       (inst - "x0!1")
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "min(delta!1,delta!2)")
       (skosimp*)
       (expand "abs" -3)
       (case-replace "x!1-x0!1<0")
       (("1"
         (inst -3 "x!1")
         (split -3)
         (("1" (propax)) ("2" (assert))
          ("3"
           (expand "min")
           (case-replace "delta!1 > delta!2")
           (("1" (assert)) ("2" (assert))))))
        ("2" (assert) (hide -2) (inst - "x!1") (assert))))))
    ("2"
     (hide 2)
     (expand "continuous?")
     (split)
     (("1"
       (skosimp*)
       (inst - "x0!1")
       (expand "continuous?")
       (inst - "epsilon!1"))
      ("2" (skosimp*) (expand "continuous?") (inst - "x0!1"))))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "P!1")
   (expand "probability_measure?")
   (expand "probability_measure_full?")
   (flatten))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "P!1")
   (expand "probability_measure?")
   (expand "finite_measure?")
   (flatten)
   (typepred "SS!1")
   (inst - "SS!1")
   (("1" (assert) (expand "o ") (propax))
    ("2"
     (hide-all-but (-1 1))
     (expand "disjoint_indexed_measurable?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "P!1")
   (expand "probability_measure?")
   (expand "finite_measure?")
   (flatten))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (typepred "P!1")
   (expand "probability_measure?")
   (flatten)
   (lemma "fm_disjointunion[T,S,P!1]" ("A" "A!1" "B" "B!1"))
   (("1" (assert)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P_disjointunion" ("P" "P!1" "A" "A!1" "B" "complement(A!1)"))
   (case-replace "union(A!1, complement(A!1))=fullset[T]")
   (("1"
     (rewrite "P_fullset")
     (split -2)
     (("1" (assert)) ("2" (hide-all-but 1) (grind))))
    ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P_disjointunion"
    ("A" "A!1" "B" "difference(B!1,A!1)" "P" "P!1"))
   (lemma "P_disjointunion"
    ("A" "B!1" "B" "difference(A!1,B!1)" "P" "P!1"))
   (rewrite "difference_disjoint")
   (rewrite "difference_disjoint")
   (case-replace "union(B!1, difference(A!1, B!1))=union(A!1,B!1)")
   (("1"
     (hide -1)
     (replace -1)
     (assert)
     (hide -1)
     (hide -1)
     (rewrite "difference_intersection")
     (lemma "P_disjointunion"
      ("P"
       "P!1"
       "A"
       "intersection(A!1, complement(B!1))"
       "B"
       "intersection(A!1, B!1)"))
     (case-replace
      "union(intersection(A!1, complement(B!1)),
                       intersection(A!1, B!1))=A!1")
     (("1" (split -2) (("1" (assert)) ("2" (hide-all-but 1) (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: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "fm_difference[T,S,P!1]" ("A" "A!1" "B" "B!1"))
   (("1" (propax)) ("2" (postpone))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P_difference" ("P" "P!1" "A" "A!1" "B" "B!1"))
   (lemma "difference_subset2" ("a" "A!1" "b" "B!1"))
   (assert)
   (replace -1)
   (rewrite "P_emptyset")
   (assert))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P_subset" ("A" "A!1" "B" "B!1" "P" "P!1"))
   (assert)
   (typepred "P!1(difference(B!1, A!1))")
   (assert))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "fm_IUnion[T,S,P!1]" ("X" "X!1"))
   (assert)
   (expand "convergence")
   (expand "o ")
   (propax))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P_subset_le"
    ("P" "P!1" "A" "intersection(A!1,B!1)" "B" "A!1"))
   (rewrite "intersection_subset1")
   (assert))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "P_union")
   (lemma "P0_intersection" ("P" "P!1" "A" "A!1" "B" "B!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P_disjointunion"
    ("P"
     "P!1"
     "A"
     "intersection(B!1, A!1)"
     "B"
     "intersection(B!1, complement(A!1))"))
   (split -1)
   (("1"
     (case-replace
      "union(intersection(B!1, A!1),
                      intersection(B!1, complement(A!1)))=B!1")
     (("1"
       (hide -1)
       (lemma "P0_intersection"
        ("P" "P!1" "B" "B!1" "A" "complement(A!1)"))
       (rewrite "P_complement")
       (replace -3)
       (assert)
       (rewrite "intersection_commutative")
       (replace -1)
       (hide -1 -3)
       (rewrite "intersection_commutative")
       (assert))
      ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))
    ("2" (hide-all-but 1) (grind))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "P1_intersection" ("P" "P!1" "A" "A!1" "B" "B!1"))
   (assert)
   (rewrite "P_union")
   (assert))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "nonempty?")
   (expand "empty?")
   (expand "member")
   (expand "fullset")
   (propax))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "probability_measure?")
   (expand "finite_measure?")
   (split)
   (("1"
     (expand "probability_measure_full?")
     (expand "trivial_probability_measure")
     (lift-if)
     (assert))
    ("2"
     (expand "trivial_probability_measure")
     (expand "emptyset")
     (expand "member")
     (propax))
    ("3"
     (skosimp*)
     (expand "trivial_probability_measure")
     (expand "o ")
     (expand "member")
     (typepred "X!1")
     (case-replace "IUnion(X!1)(choose(fullset[T]))")
     (("1"
       (name-replace "CC" "choose(fullset[T])")
       (expand "IUnion")
       (skosimp)
       (expand "disjoint_indexed_measurable?")
       (expand "disjoint?")
       (inst - "i!1" "_")
       (lemma "single_nz_series"
        ("a"
         "LAMBDA (x: nat):
                                    IF X!1(x)(CC) THEN 1 ELSE 0 ENDIF"
         "n"
         "i!1"))
       (assert)
       (hide 2)
       (skosimp)
       (inst - "m!1")
       (assert)
       (expand "disjoint?")
       (expand "empty?")
       (expand "intersection")
       (expand "member")
       (inst - "CC")
       (assert)
       (assert))
      ("2"
       (replace 1 2)
       (case-replace
        "(LAMBDA (x: nat):
                                   IF X!1(x)(choose(fullset[T])) THEN 1
                                   ELSE 0
                                   ENDIF)=(lambda (x:nat): 0)")
       (("1"
         (hide-all-but 2)
         (expand "convergence")
         (skosimp)
         (inst + "0")
         (skosimp)
         (expand "series")
         (lemma "sigma_zero[nat]" ("low" "0" "high" "i!1"))
         (replace -1)
         (expand "abs")
         (assert))
        ("2"
         (hide 3)
         (apply-extensionality :hide? t)
         (lift-if)
         (assert)
         (prop)
         (expand "IUnion")
         (inst + "x!1"))))
      ("3"
       (hide-all-but 1)
       (expand "fullset")
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (propax))))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_measure
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "constant_is_measurable")
   (inst - "(LAMBDA (x: T): 0)")
   (hide 2)
   (expand "constant?")
   (inst + "0")
   (apply-extensionality :hide? t)
   (expand "const_fun")
   (propax))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (expand "<")
   (expand "complement")
   (expand "member")
   (apply-extensionality 1 :hide? t))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (expand "<")
   (expand "complement")
   (expand "member")
   (apply-extensionality :hide? t))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "=")
   (expand "/=")
   (expand "complement")
   (expand "member")
   (apply-extensionality :hide? t))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "<")
   (expand "<=")
   (expand "complement")
   (expand "member")
   (apply-extensionality :hide? t))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "<=")
   (expand "<")
   (expand "complement")
   (apply-extensionality :hide? t)
   (expand "member")
   (assert))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "X!1")
   (typepred "Y!1")
   (typepred "g!1")
   (typepred "h!1")
   (expand "independent?")
   (skosimp)
   (expand "borel_function?")
   (expand "measurable_function?")
   (inst -3 "B2!1")
   (inst -4 "B1!1")
   (inst -1 "B2!1")
   (inst -2 "B1!1")
   (inst -5 "inverse_image(g!1, B1!1)" "inverse_image(h!1, B2!1)")
   (case-replace
    "inverse_image(X!1, inverse_image(g!1, B1!1))=inverse_image(g!1 o X!1, B1!1)")
   (("1"
     (case-replace
      "inverse_image(Y!1, inverse_image(h!1, B2!1))=inverse_image(h!1 o Y!1, B2!1)")
     (hide-all-but 1)
     (apply-extensionality :hide? t)
     (expand "inverse_image")
     (expand "o ")
     (expand "member")
     (propax))
    ("2"
     (hide-all-but 1)
     (apply-extensionality :hide? t)
     (expand "o ")
     (expand "inverse_image")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (induct "n1")
   (("1"
     (expand "sigma")
     (skosimp)
     (typepred "XS!1(0)")
     (expand "random_variable?")
     (expand "sigma")
     (case-replace "(LAMBDA t: XS!1(0)(t))=XS!1(0)")
     (apply-extensionality :hide? t))
    ("2"
     (skosimp*)
     (inst - "XS!1")
     (expand "sigma" 1)
     (typepred "XS!1(1 + j!1)")
     (expand "random_variable?")
     (lemma "sum_measurable"
      ("g1"
       "XS!1(1 + j!1)"
       "g2"
       "LAMBDA t:
                                     sigma(0, j!1, LAMBDA n: XS!1(n)(t))"))
     (("1" (expand "+") (propax)) ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "<")
   (expand "distribution_function")
   (expand "<=")
   (lemma "P_complement" ("A" "{t | X!1(t) > x!1}"))
   (("1"
     (inst - "P")
     (expand ">")
     (lemma "complement_lt1" ("x" "x!1" "X" "X!1"))
     (expand "<" -1)
     (expand ">" -1)
     (replace -1 -2)
     (expand "<=" -2)
     (assert))
    ("2" (assert) (typepred "x!1<X!1") (expand "<") (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "distribution_function")
   (skosimp)
   (lemma "P_intersection" ("A" "x!1 < X!1" "B" "X!1 <= y!1"))
   (inst - "P")
   (replace -1 1)
   (hide -1)
   (assert)
   (case-replace "union(x!1 < X!1, X!1 <= y!1) = fullset[T]")
   (("1"
     (hide -1)
     (lemma "P_fullset")
     (inst - "P")
     (replace -1)
     (lemma "P_complement" ("A" "x!1 < X!1"))
     (inst - "P")
     (rewrite "complement_lt1" -1)
     (replace -1)
     (assert))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (expand "fullset")
     (expand "union")
     (expand "member")
     (expand "<")
     (expand "<=" 1)
     (expand ">" 1)
     (flatten)
     (assert))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "distribution_function")
   (case-replace "P(X!1 <= x!1)=P(X!1 = x!1)+P(X!1 < x!1)")
   (("1"
     (hide -1)
     (assert)
     (lemma "P_IUnion")
     (inst - "P" "LAMBDA (n:nat): X!1 <= x!1 - 1 / (1 + n)")
     (split -1)
     (("1"
       (case-replace
        "IUnion(LAMBDA (n: nat): X!1 <= x!1 - 1 / (1 + n))=X!1<x!1")
       (("1"
         (hide -1)
         (expand "o" -1)
         (rewrite "convergence_sequences.limit_def" - :dir rl)
         (expand "convergent?")
         (inst + "P(X!1<x!1)"))
        ("2"
         (hide-all-but 1)
         (apply-extensionality :hide? t)
         (expand "<" 1)
         (expand "IUnion")
         (case-replace "X!1(x!2) < x!1")
         (("1"
           (expand "<=" +)
           (lemma "archimedean" ("px" "x!1-X!1(x!2)"))
           (("1" (skosimp) (inst + "n!1-1") (assert)) ("2" (assert))))
          ("2" (assert) (skosimp) (expand "<=" -1) (assert))))))
      ("2"
       (hide 2)
       (expand "increasing?")
       (skolem + ("i!1" "j!1"))
       (flatten)
       (expand "subset?")
       (expand "member")
       (skosimp)
       (expand "<=" (-2 1))
       (assert)
       (lemma "both_sides_div_pos_le2")
       (inst - "1+j!1" "1+i!1" "1")
       (assert))))
    ("2"
     (hide 2)
     (lemma "P_disjointunion" ("A" "X!1 = x!1" "B" "X!1 < x!1" "P" "P"))
     (case-replace "union(X!1 = x!1, X!1 < x!1)=X!1 <= x!1")
     (("1"
       (split)
       (("1" (propax))
        ("2"
         (hide-all-but 1)
         (expand "=")
         (expand "<")
         (expand "disjoint?")
         (expand "intersection")
         (expand "empty?")
         (expand "member")
         (skosimp)
         (assert))))
      ("2"
       (hide-all-but 1)
       (expand "<=")
       (expand "<")
       (expand "=")
       (expand "union")
       (expand "member")
       (apply-extensionality :hide? t)
       (expand "<=")
       (grind))))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "F!1")
   (expand "distribution_function?")
   (skosimp)
   (expand "<=")
   (name "BB" "lambda (n:nat): {t:T | X!1(t) <= -n}")
   (lemma "P_IIntersection" ("X" "BB" "P" "P"))
   (("1"
     (split -1)
     (("1"
       (case-replace "IIntersection(BB) = emptyset[T]")
       (("1"
         (rewrite "P_emptyset")
         (expand "o")
         (expand "BB")
         (lemma "extensionality"
          ("f" "F!1" "g" "lambda x: P({t | X!1(t) <= x})"))
         (("1"
           (split -1)
           (("1" (replace -1) (assert)) ("2" (skosimp) (inst - "x!1"))))
          ("2"
           (skosimp)
           (typepred "X!1")
           (inst - "x!1")
           (rewrite "measurable_le" -1)
           (inst - "x!1"))))
        ("2"
         (hide -1 2 -2)
         (expand "IIntersection")
         (expand "BB")
         (apply-extensionality 1 :hide? t)
         (expand "emptyset")
         (hide -2)
         (case-replace "X!1(x!1)<= -1")
         (("1"
           (name "II" "floor(X!1(x!1))")
           (typepred "floor(X!1(x!1))")
           (replace -3)
           (expand "<=" -1)
           (split -1)
           (("1" (inst - "-II") (("1" (assert)) ("2" (assert))))
            ("2" (inst - "1-II") (("1" (assert)) ("2" (assert))))))
          ("2" (inst - "1"))))))
      ("2"
       (hide -1 2)
       (expand "BB")
       (expand "decreasing?")
       (skosimp*)
       (expand "subset?")
       (expand "member")
       (skosimp*)
       (assert))))
    ("2"
     (skosimp)
     (expand "BB")
     (typepred "X!1")
     (inst - "-x1!1")
     (rewrite "measurable_le" -1)
     (inst - "-x1!1"))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "F!1")
   (expand "distribution_function?")
   (skosimp)
   (name "BB" "lambda (n:nat): {t:T | X!1(t) <= n}")
   (lemma "P_IUnion" ("X" "BB" "P" "P"))
   (("1"
     (case-replace "IUnion(BB)= fullset[T]")
     (("1"
       (rewrite "P_fullset")
       (expand "o")
       (expand "BB")
       (expand "restrict")
       (split -2)
       (("1"
         (lemma "extensionality"
          ("f"
           "lambda (s:nat): F!1(s)"
           "g"
           "LAMBDA (x: nat): P({t: T | X!1(t) <= x})"))
         (("1"
           (split -1)
           (("1" (replace -1 1) (propax))
            ("2" (skosimp) (inst - "x!1") (expand "<=" -4) (propax))))
          ("2"
           (skosimp)
           (typepred "X!1")
           (inst - "x!1")
           (rewrite "measurable_le" -1)
           (inst - "x!1"))))
        ("2"
         (hide -1 2 -2)
         (expand "increasing?")
         (expand "subset?")
         (expand "member")
         (skosimp*)
         (assert))))
      ("2"
       (hide-all-but 1)
       (expand "BB")
       (expand "IUnion")
       (expand "fullset")
       (assert)
       (apply-extensionality :hide? t)
       (case-replace "X!1(x!1)<=0")
       (("1" (inst + "0"))
        ("2"
         (inst + "ceiling(X!1(x!1))")
         (("1" (assert)) ("2" (assert))))))))
    ("2"
     (expand "BB")
     (skosimp*)
     (typepred "X!1")
     (inst - "x1!1")
     (rewrite "measurable_le" -1)
     (inst - "x1!1"))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "F!1")
   (expand "distribution_function?")
   (expand "increasing?")
   (skosimp*)
   (lemma "P_subset_le" ("A" "X!1 <= x!1" "B" "X!1 <= y!1" "P" "P"))
   (expand "subset?")
   (expand "member")
   (inst-cp - "x!1")
   (inst - "y!1")
   (split -1)
   (("1" (assert) (expand "restrict") (assert))
    ("2" (expand "<=" 1) (skosimp) (assert))))


proof_type: f_proof
decl_type: formula
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "right_continuous?")
   (skolem + ("x!1"))
   (expand "right_continuous?")
   (skosimp)
   (typepred "F!1")
   (expand "distribution_function?")
   (skosimp)
   (typepred "X!1")
   (case "EXISTS (delta:posreal):
                        FORALL (y: real):
                          x!1 <= y AND y - x!1 < delta IMPLIES
                           P(X!1<=y) - P(X!1<=x!1) < epsilon!1")
   (("1"
     (skosimp)
     (inst + "delta!1")
     (skosimp)
     (inst - "x!2")
     (inst-cp - "x!2")
     (inst - "x!1")
     (lemma "distribution_increasing" ("F" "F!1"))
     (expand "increasing?")
     (inst - "x!1" "x!2")
     (expand "abs")
     (assert))
    ("2"
     (hide 2)
     (lemma "m_decreasing_convergence"
      ("E" "lambda (n:nat): X!1<=x!1+1/(1+n)"))
     (("1"
       (split -1)
       (("1"
         (expand "to_measure")
         (expand "o" -1)
         (expand "x_converges?")
         (prop)
         (case-replace
          "IIntersection(LAMBDA (n: nat): X!1 <= 1 / (1 + n) + x!1) = X!1<=x!1")
         (("1"
           (hide -1)
           (lemma "convergence_sequences.limit_def")
           (inst - "P(X!1<=x!1)"
            "LAMBDA (i:nat): P(X!1 <= 1 / (1 + i) + x!1)")
           (assert)
           (hide -2 -3)
           (expand "convergence")
           (inst - "epsilon!1")
           (skosimp)
           (inst + "1/(1+n!1)")
           (skosimp)
           (lemma "distribution_increasing" ("F" "F!1"))
           (inst - "n!1")
           (assert)
           (expand "increasing?")
           (inst-cp - "y!1" "x!1+1/(1+n!1)")
           (inst - "x!1" "x!1+1/(1+n!1)")
           (assert)
           (inst-cp - "x!1")
           (inst-cp - "x!1+1/(1+n!1)")
           (inst - "y!1")
           (assert))
          ("2"
           (hide-all-but 1)
           (apply-extensionality :hide? t)
           (expand "<=")
           (expand "IIntersection")
           (case-replace "X!1(x!2) <= x!1")
           (("1" (skosimp) (assert))
            ("2"
             (assert)
             (lemma "archimedean" ("px" "X!1(x!2)-x!1"))
             (skosimp)
             (inst - "n!1-1")
             (assert))))))
        ("2"
         (hide 2)
         (expand "decreasing?")
         (skolem + ("i!1" "j!1"))
         (flatten)
         (expand "subset?")
         (expand "member")
         (expand "<=" 1)
         (skolem + ("t!1"))
         (flatten)
         (lemma "both_sides_div_pos_le2"
          ("py" "i!1+1" "px" "j!1+1" "pz" "1"))
         (assert))
        ("3"
         (hide 2)
         (expand "mu_fin?")
         (expand "to_measure")
         (propax))))
      ("2" (skosimp) (expand "measurable_set?") (propax))))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "constant_is_measurable")
   (inst - "(LAMBDA t: 0)")
   (expand "constant?")
   (expand "const_fun")
   (assert)
   (inst?))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "constant_is_measurable")
   (inst - "(LAMBDA t: 1)")
   (expand "constant?")
   (expand "const_fun")
   (inst?))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "X!1")
   (lemma "measurable_ge" ("f" "X!1"))
   (lemma "measurable_le" ("f" "X!1"))
   (assert)
   (inst - "x!1")
   (inst - "x!1")
   (lemma "measurable_intersection"
    ("a" "{z: T | X!1(z) <= x!1}" "b" "{z: T | X!1(z) >= x!1}"))
   (("1"
     (case-replace
      "(intersection[T]
                                ({z: T | X!1(z) <= x!1}, {z: T | X!1(z) >= x!1}))={t | X!1(t) = x!1}")
     (("1" (expand "measurable_set?") (propax))
      ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))
    ("2" (expand "measurable_set?") (propax))
    ("3" (expand "measurable_set?") (propax))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (typepred "X!1")
   (lemma "measurable_gt" ("f" "X!1"))
   (lemma "measurable_lt" ("f" "X!1"))
   (assert)
   (inst - "x!1")
   (inst - "x!1")
   (lemma "measurable_union"
    ("a" "{z: T | X!1(z) < x!1}" "b" "{z: T | X!1(z) > x!1}"))
   (("1"
     (case-replace
      "(union[T]
                                ({z: T | X!1(z) < x!1}, {z: T | X!1(z) > x!1}))={t | X!1(t) /= x!1}")
     (("1" (expand "measurable_set?") (propax))
      ("2" (hide-all-but 1) (apply-extensionality :hide? t) (grind))))
    ("2" (expand "measurable_set?") (propax))
    ("3" (expand "measurable_set?") (propax))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "sum_measurable" ("g1" "X!1" "g2" "lambda (t:T): x!1"))
   (("1" (expand "+") (propax))
    ("2"
     (lemma "constant_is_measurable")
     (inst - "(LAMBDA (t: T): x!1)")
     (expand "constant?")
     (expand "const_fun")
     (inst?))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "sum_measurable" ("g1" "lambda (t:T): x!1" "g2" "X!1"))
   (("1" (expand "+") (assert))
    ("2"
     (lemma "constant_is_measurable")
     (inst - "(LAMBDA (t: T): x!1)")
     (expand "constant?")
     (expand "const_fun")
     (inst?))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "constant_is_measurable")
   (inst - "lambda t: x!1")
   (("1"
     (lemma "diff_measurable" ("g1" "X!1" "g2" "LAMBDA t: x!1"))
     (("1" (expand "-" -1) (propax)) ("2" (propax))))
    ("2" (expand "constant?") (expand "const_fun") (inst?))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "constant_is_measurable")
   (inst - "lambda t: x!1")
   (("1"
     (lemma "diff_measurable" ("g2" "X!1" "g1" "LAMBDA t: x!1"))
     (("1" (expand "-" -1) (propax)) ("2" (propax))))
    ("2" (expand "constant?") (expand "const_fun") (inst?))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "distribution_function?")
   (inst + "lambda (t:T): 0")
   (("1"
     (skosimp)
     (expand "<=")
     (case-replace "0 <= x!1")
     (("1" (lemma "P_fullset" ("P" "P")) (expand "fullset") (assert))
      ("2" (lemma "P_emptyset" ("P" "P")) (expand "emptyset") (assert))))
    ("2"
     (lemma "constant_is_measurable")
     (inst - "LAMBDA (t: T): 0")
     (expand "constant?")
     (expand "const_fun")
     (inst?))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: probability_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "distribution_function")
   (replace -1)
   (assert)
   (hide -1)
   (lemma "m_increasing_convergence")
   (inst - "lambda (n:nat): X!1 <= x!1 - 1 / (1 + n)")
   (("1"
     (split -1)
     (("1"
       (expand "x_converges?")
       (expand "to_measure")
       (expand "o")
       (propax))
      ("2"
       (hide 2)
       (expand "increasing?")
       (skosimp)
       (expand "subset?")
       (expand "<=" 1)
       (expand "member")
       (skosimp)
       (lemma "both_sides_div_pos_le2"
        ("py" "x!2+1" "px" "y!1+1" "pz" "1"))
       (assert))))
    ("2" (hide 2) (skosimp) (expand "measurable_set?") (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "one")
   (expand "E")
   (lemma "integral_phi" ("F" "fullset[T]"))
   (("1"
     (expand "mu")
     (expand "to_measure")
     (typepred "P")
     (expand "probability_measure?")
     (flatten)
     (expand "probability_measure_full?")
     (replace -1)
     (case-replace "phi(fullset[T])=(LAMBDA (t: T): 1)")
     (hide-all-but 1)
     (apply-extensionality :hide? t)
     (expand "fullset")
     (expand "phi")
     (expand "member")
     (propax))
    ("2" (expand "mu_fin?") (expand "to_measure") (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "E")
   (lemma "E_phi_TCC1" ("A" "A!1"))
   (rewrite "integral_phi")
   (("1" (expand "mu") (expand "to_measure") (propax))
    ("2"
     (expand "measurable_set?")
     (expand "mu_fin?")
     (expand "to_measure")
     (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "E")
   (lemma "integral_scal" ("c" "c!1" "f" "X!1"))
   (expand "*")
   (propax))


proof_type: f_proof
decl_type: formula
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (expand "E")
   (lemma "integral_nonneg" ("f" "X!1"))
   (split)
   (("1" (propax)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (rewrite "div_mult_pos_le2")
   (expand "E")
   (lemma "indefinite_subset"
    ("E1"
     "{x:T | abs[T](X!1)(x) >= px!1}"
     "E2"
     "fullset[T]"
     "f"
     "abs[T](X!1)"))
   (("1"
     (split)
     (("1"
       (expand "integral" -1)
       (case-replace "phi(fullset[T]) * abs[T](X!1)=abs[T](X!1)")
       (("1"
         (hide -1)
         (typepred "px!1 <= abs[T](X!1)")
         (expand "<=" -1)
         (expand "<=" 1 1)
         (lemma "E_phi" ("A" "{t: T | abs[T](X!1)(t) >= px!1}"))
         (("1"
           (replace -1 1 rl)
           (hide -1)
           (expand "E" 1)
           (lemma "E_phi_TCC1" ("A" "{t: T | abs[T](X!1)(t) >= px!1}"))
           (lemma "integrable_scal"
            ("c"
             "px!1"
             "f"
             "phi[T, S]({t: T | abs[T](X!1)(t) >= px!1})"))
           (lemma "integral_scal"
            ("c"
             "px!1"
             "f"
             "phi[T, S]({t: T | abs[T](X!1)(t) >= px!1})"))
           (lemma "integral_ae_le"
            ("f1"
             "px!1 * phi[T, S]({t: T | abs[T](X!1)(t) >= px!1})"
             "f2"
             "phi({x:T | abs[T](X!1)(x) >= px!1}) * abs[T](X!1)"))
           (split -1)
           (("1"
             (name-replace "LHI"
              "integral.integral(phi({t: T | abs[T](X!1)(t) >= px!1}))")
             (name-replace "RHI" "integral.integral(abs[T](X!1))")
             (name-replace "MI1"
              "integral.integral(phi({x:T | abs[T](X!1)(x) >= px!1}) * abs[T](X!1))")
             (expand "*" -1)
             (expand "*" -2)
             (name-replace "FF"
              "(LAMBDA (t_1: T):
                               px!1 * phi[T, S]({t: T | abs[T](X!1)(t) >= px!1})(t_1))")
             (assert))
            ("2"
             (hide-all-but 1)
             (expand "ae_le?")
             (expand "pointwise_ae?")
             (expand "*")
             (expand "phi")
             (expand "member")
             (expand "abs")
             (expand "ae?")
             (expand "fullset")
             (expand "ae_in?")
             (inst + "emptyset[T]")
             (("1"
               (skosimp)
               (case-replace "abs(X!1(x!1)) >= px!1")
               (("1" (assert)) ("2" (assert))))
              ("2"
               (expand "negligible_set?")
               (inst + "emptyset[T]")
               (split)
               (("1"
                 (expand "null_set?")
                 (expand "mu_fin?")
                 (expand "mu")
                 (expand "to_measure")
                 (typepred "P")
                 (expand "probability_measure?")
                 (expand "finite_measure?")
                 (flatten))
                ("2" (grind))))))))
          ("2" (propax))))
        ("2"
         (hide-all-but 1)
         (apply-extensionality :hide? t)
         (expand "*")
         (expand "fullset")
         (expand "phi")
         (expand "member")
         (assert))))
      ("2" (hide 2) (grind))
      ("3"
       (hide 2)
       (expand "ae_nonneg?")
       (expand "pointwise_ae?")
       (expand "abs")
       (expand "ae?")
       (expand "fullset")
       (expand "ae_in?")
       (inst + "emptyset[T]")
       (("1" (skosimp) (assert))
        ("2"
         (expand "negligible_set?")
         (inst + "emptyset[T]")
         (split)
         (("1"
           (expand "null_set?")
           (expand "mu_fin?")
           (expand "mu")
           (typepred "P")
           (expand "probability_measure?")
           (expand "finite_measure?")
           (flatten)
           (expand "to_measure")
           (propax))
          ("2" (grind))))))))
    ("2"
     (hide 2)
     (typepred "abs[T](X!1)")
     (lemma "measurable_ge")
     (inst - "abs[T](X!1)")
     (lemma "integrable_is_measurable")
     (inst - "abs[T](X!1)")
     (assert)
     (inst - "px!1")
     (expand "integrable?" 1)
     (case-replace "phi(fullset[T]) * abs[T](X!1) = abs[T](X!1)")
     (apply-extensionality :hide? t)
     (hide-all-but 1)
     (expand "*")
     (expand "fullset")
     (expand "phi")
     (expand "member")
     (assert))
    ("3"
     (expand "measurable_set?")
     (hide 2)
     (lemma "measurable_ge[T,S]" ("f" "abs[T](X!1)"))
     (typepred "X!1")
     (lemma "integrable_is_measurable[T,S,to_measure(P)]")
     (inst - "X!1")
     (lemma "abs_measurable[T,S]" ("g" "X!1"))
     (("1" (assert) (inst - "px!1")) ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "trichotomy" ("x" "x!1"))
   (split -1)
   (("1"
     (lemma "markov_inequality" ("px" "x!1" "X" "X!1"))
     (("1" (rewrite "div_mult_pos_le2") (assert)) ("2" (assert))))
    ("2"
     (replace -1)
     (lemma "E_nonneg" ("X" "abs(X!1)"))
     (split)
     (("1" (assert)) ("2" (skosimp) (expand "abs") (assert))))
    ("3"
     (lemma "both_sides_times_neg_le1"
      ("nz" "x!1" "x" "P(x!1 <= abs(X!1))" "y" "0"))
     (("1"
       (lemma "E_nonneg" ("X" "abs(X!1)"))
       (split -1)
       (("1" (assert)) ("2" (skosimp) (expand "abs") (assert))))
      ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (rewrite "isf_is_integrable")
   (hide 2)
   (expand "isf?")
   (split)
   (("1"
     (expand "simple?")
     (expand "one")
     (expand "fullset")
     (expand "image")
     (case-replace
      "{y: real | EXISTS (x_1: ({x: T | TRUE})): y = 1}=singleton[real](1)")
     (("1" (hide -1) (assert))
      ("2"
       (hide 2)
       (apply-extensionality :hide? t)
       (expand "singleton")
       (case-replace "x!1=1")
       (("1"
         (inst + "choose[T](fullset[T])")
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (expand "fullset")
         (propax))
        ("2" (assert))))))
    ("2"
     (expand "one")
     (expand "nonzero_set?")
     (expand "mu_fin?")
     (expand "to_measure")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: expectation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "isf_phi" ("E" "A!1"))
   (("1" (rewrite "isf_is_integrable"))
    ("2"
     (hide 2)
     (typepred "A!1")
     (expand "measurable_set?")
     (expand "mu_fin?")
     (expand "to_measure")
     (propax))))


proof_type: f_proof
decl_type: formula
library: probability
theory: conditional
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (case "union(intersection(A!1,B!1),intersection(A!1,complement(B!1))) = A!1")
   (("1"
     (lemma "P_disjointunion")
     (inst - "intersection(A!1, B!1)"
      "intersection(A!1, complement(B!1))" "_")
     (inst - "P")
     (expand "P")
     (lemma "P_complement" ("A" "B!1"))
     (inst - "P")
     (expand "null?")
     (replace -1)
     (hide -1)
     (case-replace "P(B!1) = 0")
     (("1"
       (assert)
       (assert)
       (lemma "P0_intersection" ("A" "B!1" "B" "A!1"))
       (inst - "P")
       (assert)
       (rewrite "intersection_commutative")
       (assert)
       (hide-all-but 1)
       (grind))
      ("2"
       (assert)
       (case-replace "P(complement(B!1)) = 0")
       (("1"
         (rewrite "div_cancel2" 2)
         (assert)
         (lemma "P0_intersection" ("A" "complement(B!1)" "B" "A!1"))
         (inst - "P")
         (assert)
         (rewrite "intersection_commutative")
         (assert)
         (replace -1)
         (replace -4 *)
         (case-replace "P(B!1)=1")
         (("1"
           (assert)
           (split -4)
           (("1" (assert)) ("2" (hide-all-but 1) (grind))))
          ("2" (hide-all-but (-2 1)) (rewrite "P_complement") (assert))))
        ("2"
         (assert)
         (rewrite "div_cancel2" 3)
         (assert)
         (replace -2)
         (split -1)
         (("1"
           (rewrite "P_complement" 1)
           (assert)
           (lemma "div_cancel1"
            ("n0z"
             "1-P(B!1)"
             "x"
             "P(intersection(A!1, complement(B!1)))"))
           (replace -1 -2 :dir rl)
           (assert))
          ("2" (hide-all-but 1) (grind))))))))
    ("2"
     (hide 2)
     (apply-extensionality :hide? t)
     (expand "complement")
     (expand "intersection")
     (expand "union")
     (expand "member")
     (case-replace "A!1(x!1)")
     (("1" (assert) (flatten)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: probability
theory: conditional
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (name "SS"
         "LAMBDA (i:nat): IF i <= n!1 THEN intersection(A!1,BB!1(i)) ELSE emptyset[T] ENDIF")
   (case "A!1 = IUnion(SS)")
   (("1"
     (lemma "P_convergence" ("SS" "SS"))
     (("1"
       (inst - "P")
       (lemma "zero_tail_series" ("n" "n!1" "a" "P o SS"))
       (split -1)
       (("1"
         (assert)
         (replace -4 -1 rl)
         (replace -4)
         (replace -3 * rl)
         (lemma "convergence_sequences.unique_limit"
          ("u"
           "series(P o SS)"
           "l1"
           "P(A!1)"
           "l2"
           "series(P o SS)(n!1)"))
         (assert)
         (hide -2 -3 -5 -6)
         (hide -2)
         (expand "series")
         (expand "o ")
         (expand "SS")
         (rewrite "P_emptyset")
         (expand "P" 1 2)
         (expand "null?")
         (lemma "sigma_eq[nat]"
          ("low"
           "0"
           "high"
           "n!1"
           "F"
           "LAMBDA (x: nat):
                          IF x <= n!1 THEN P(intersection(A!1, BB!1(x))) ELSE 0 ENDIF"
           "G"
           "LAMBDA (i_1: nat):
                          IF P(BB!1(i_1)) = 0 THEN 0
                          ELSE P(intersection(A!1, BB!1(i_1))) / P(BB!1(i_1))
                          ENDIF
                           * P(BB!1(i_1))"))
         (("1"
           (split -1)
           (("1" (replace -1) (propax))
            ("2"
             (hide -1 2)
             (skosimp*)
             (typepred "n!2")
             (assert)
             (case-replace "P(BB!1(n!2)) = 0")
             (("1"
               (lemma "P_subset_le"
                ("A" "intersection(A!1, BB!1(n!2))" "B" "BB!1(n!2)"))
               (inst - "P")
               (split)
               (("1" (assert))
                ("2"
                 (hide-all-but 1)
                 (expand "intersection")
                 (expand "subset?")
                 (expand "member")
                 (skosimp))))
              ("2" (assert))))))
          ("2" (hide-all-but 1) (skosimp))))
        ("2"
         (hide -1 -2 -3 2)
         (skosimp)
         (expand "SS")
         (assert)
         (expand "o")
         (lemma "P_emptyset")
         (inst - "P"))))
      ("2"
       (hide -2 2)
       (expand "SS")
       (expand "intersection")
       (expand "member")
       (expand "emptyset")
       (assert)
       (expand "disjoint_indexed_measurable?")
       (expand "disjoint?")
       (skosimp)
       (expand "disjoint?")
       (expand "intersection")
       (expand "empty?")
       (skosimp)
       (expand "member")
       (flatten)
       (prop)
       (hide -7)
       (typepred "BB!1")
       (expand "disjoint_indexed_measurable?")
       (expand "disjoint?")
       (inst - "i!1" "j!1")
       (assert)
       (expand "disjoint?")
       (expand "intersection")
       (expand "empty?")
       (expand "member")
       (inst - "x!1")
       (assert))))
    ("2"
     (hide 2 -1)
     (apply-extensionality :hide? t)
     (expand "SS")
     (expand "IUnion")
     (expand "fullset" -1 2)
     (case-replace "A!1(x!1)")
     (("1"
       (rewrite "extensionality_postulate" -2 :dir rl)
       (inst - "x!1")
       (expand "Union")
       (skosimp)
       (typepred "a!1")
       (expand "extend")
       (prop)
       (expand "image")
       (skosimp)
       (typepred "x!2")
       (assert)
       (expand "fullset")
       (inst + "x!2")
       (expand "intersection")
       (expand "member")
       (propax))
      ("2"
       (assert)
       (skosimp)
       (expand "emptyset")
       (prop)
       (expand "intersection")
       (flatten)
       (expand "member")
       (propax))))))


proof_type: f_proof
decl_type: formula
library: probability
theory: conditional
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conditional_partition" ("A" "B!1" "BB" "AA!1" "n" "n!1"))
   (replace -2 -1)
   (replace -1 2 rl)
   (expand "null?")
   (rewrite "div_cancel4")
   (hide -1 -2)
   (expand "P")
   (expand "null?")
   (assert)
   (case-replace "P(AA!1(j!1)) = 0")
   (("1"
     (lemma "P0_intersection" ("A" "AA!1(j!1)" "B" "B!1"))
     (inst - "P")
     (assert))
    ("2"
     (assert)
     (rewrite "div_cancel2" 3)
     (rewrite "div_cancel2" 3)
     (rewrite "intersection_commutative"))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: conditional
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (expand "null?")
     (typepred "P(B!1)")
     (expand ">=" -1)
     (expand "<=" -1)
     (split -1)
     (("1"
       (typepred "P(intersection[T](A!1, B!1))")
       (lemma "both_sides_div_pos_le1"
        ("pz" "P(B!1)" "x" "0" "y" "P(intersection[T](A!1, B!1))"))
       (("1" (assert)) ("2" (assert))))
      ("2" (assert))))
    ("2"
     (lemma "P_subset_le"
      ("A" "intersection[T](A!1, B!1)" "B" "B!1" "P" "P"))
     (split -1)
     (("1" (expand "null?") (rewrite "div_mult_pos_le1" 1) (assert))
      ("2" (hide-all-but 1) (grind))))))


proof_type: t_proof
decl_type: tcc
library: probability
theory: conditional
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "null?")
   (lemma "conditional_partition" ("A" "B!1" "BB" "AA!1" "n" "n!1"))
   (replace -2)
   (assert))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "member")
   (expand "scott_closed_sets")
   (expand "extend")
   (skosimp)
   (expand "member")
   (expand "subset?")
   (expand "member")
   (typepred "lub(D!1)")
   (("1"
     (expand "least_upper_bound?")
     (flatten)
     (expand "down")
     (inst - "x!1")
     (split -2)
     (("1" (propax))
      ("2"
       (hide 2)
       (expand "upper_bound?")
       (skosimp)
       (typepred "r!1")
       (inst -3 "r!1")
       (assert))))
    ("2"
     (typepred "<=")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "A!1")
   (typepred "B!1")
   (expand "union")
   (expand "member")
   (expand "scott_closed_sets")
   (expand "extend")
   (prop)
   (("1"
     (skosimp*)
     (typepred "D!1")
     (lemma "directed_union_lower" ("D" "D!1" "L1" "A!1" "L2" "B!1"))
     (("1"
       (expand "union")
       (expand "member")
       (assert)
       (flatten)
       (split -1)
       (("1" (inst -7 "D!1") (assert)) ("2" (inst -9 "D!1") (assert))))
      ("2" (propax)) ("3" (propax))))
    ("2"
     (hide -2 -4)
     (expand "lower_set?")
     (expand "member")
     (skosimp*)
     (inst - "x!1" "y!1")
     (inst - "x!1" "y!1")
     (split -1)
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "scott_closed_sets")
   (expand "Intersection")
   (expand "subset?")
   (expand "extend")
   (expand "member")
   (skosimp*)
   (typepred "LS!1")
   (prop)
   (("1"
     (skosimp*)
     (typepred "D!1")
     (typepred "lub(D!1)")
     (("1"
       (typepred "a!1")
       (inst -8 "a!1")
       (replace -1)
       (assert)
       (prop)
       (inst -2 "D!1")
       (split -2)
       (("1" (propax))
        ("2"
         (hide 2)
         (skosimp)
         (inst -8 "x!1")
         (assert)
         (inst -8 "a!1"))))
      ("2"
       (typepred "<=")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (expand "lower_sets?")
     (expand "every")
     (expand "lower_set?")
     (skosimp)
     (expand "member")
     (skosimp)
     (typepred "a!1")
     (inst - "a!1")
     (inst - "a!1")
     (inst - "x!1" "y!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "scott_open_sets")
   (expand "Complement")
   (expand "topology?")
   (split)
   (("1"
     (expand "topology_empty?")
     (lemma "scott_full")
     (expand "member")
     (inst + "fullset[T]")
     (rewrite "complement_fullset"))
    ("2"
     (lemma "scott_empty")
     (expand "topology_full?")
     (expand "member")
     (inst + "emptyset[T]")
     (rewrite "complement_emptyset"))
    ("3"
     (expand "topology_Union?")
     (skosimp)
     (expand "member")
     (lemma "scott_Intersection" ("LS" "Complement(U!1)"))
     (("1"
       (split -1)
       (("1"
         (expand "member")
         (inst + "Intersection(Complement(U!1))")
         (rewrite "Demorgan2")
         (rewrite "Complement_Complement"))
        ("2"
         (hide 2)
         (expand "Complement")
         (expand "subset?")
         (expand "member")
         (skosimp)
         (skosimp)
         (typepred "b!1")
         (inst - "b!1")
         (assert)
         (skosimp)
         (typepred "b!2")
         (replace -4)
         (rewrite "complement_complement")
         (assert))))
      ("2"
       (hide 2)
       (expand "lower_sets?")
       (expand "every")
       (skosimp)
       (typepred "x!1")
       (expand "Complement")
       (skosimp)
       (typepred "b!1")
       (expand "subset?")
       (expand "member")
       (inst - "b!1")
       (assert)
       (skosimp)
       (replace -3)
       (typepred "b!2")
       (rewrite "complement_complement")
       (assert)
       (replace -3 * rl)
       (hide-all-but (-1 1))
       (expand "lower_set?")
       (expand "member")
       (skosimp)
       (expand "scott_closed_sets")
       (expand "extend")
       (propax))))
    ("4"
     (expand "topology_intersection?")
     (skosimp*)
     (typepred "A!1")
     (typepred "B!1")
     (skosimp*)
     (lemma "scott_union")
     (typepred "b!1")
     (typepred "b!2")
     (inst - "b!2" "b!1")
     (expand "member")
     (inst + "union(b!2, b!1)")
     (replace -4)
     (replace -5)
     (rewrite "demorgan1"))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("y"))
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "down_is_closed" ("x" "y"))
     (expand "member")
     (expand "Cl")
     (expand "adherent_point?")
     (lemma "open_complement" ("A" "down(y)"))
     (("1"
       (expand "closed?")
       (expand "member")
       (expand "scott_open_sets")
       (expand "Complement")
       (flatten -1)
       (hide -1)
       (split -1)
       (("1"
         (case-replace "down(y)(x!1)")
         (("1"
           (skosimp)
           (expand "singleton")
           (expand "intersection")
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (typepred "U!1")
           (expand "neighbourhood?")
           (expand "interior_point?")
           (skosimp)
           (expand "member")
           (inst - "y")
           (expand "down")
           (typepred "U!2")
           (lemma "open_is_upper" ("x" "U!2"))
           (expand "upper_set?")
           (expand "member")
           (inst - "x!1" "y")
           (assert)
           (expand "subset?")
           (inst - "y")
           (expand "member")
           (propax))
          ("2"
           (assert)
           (expand "singleton")
           (expand "intersection")
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (inst - "complement(down(y))")
           (("1"
             (split -3)
             (("1"
               (skosimp)
               (replace -2)
               (expand "complement")
               (expand "member")
               (expand "down")
               (rewrite "partial_order_reflexive"))
              ("2"
               (expand "neighbourhood?")
               (expand "interior_point?")
               (inst + "complement(down(y))")
               (("1"
                 (rewrite "subset_reflexive")
                 (expand "member")
                 (expand "complement")
                 (expand "member")
                 (propax))
                ("2"
                 (typepred "<=")
                 (expand "directed_complete_partial_order?")
                 (flatten))))))
            ("2"
             (typepred "<=")
             (expand "directed_complete_partial_order?")
             (assert))))))
        ("2"
         (inst + "down(y)")
         (typepred "<=")
         (expand "directed_complete_partial_order?")
         (flatten))))
      ("2"
       (typepred "<=")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (typepred "<=")
     (expand "directed_complete_partial_order?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (skosimp)
     (typepred "A!1")
     (lemma "open_is_upper" ("x" "A!1"))
     (expand "upper_set?")
     (expand "member")
     (inst - "x!1" "y!1")
     (assert))
    ("2"
     (skosimp)
     (expand "member")
     (rewrite "order_iff_closure")
     (case "FORALL (A: (closed?)): member(y!1, A) IMPLIES member(x!1, A)")
     (("1"
       (hide -2)
       (lemma "Cl_closed" ("A" "singleton(y!1)"))
       (expand "member")
       (inst - "Cl(singleton(y!1))")
       (split -2)
       (("1" (propax))
        ("2"
         (hide-all-but 1)
         (lemma "subset_of_Cl" ("A" "singleton(y!1)"))
         (expand "subset?")
         (inst - "y!1")
         (expand "member")
         (expand "singleton" -1 1)
         (propax))))
      ("2"
       (hide 2)
       (skosimp)
       (expand "member")
       (typepred "A!1")
       (lemma "open_complement" ("A" "A!1"))
       (assert)
       (inst - "complement(A!1)")
       (expand "complement")
       (expand "member")
       (propax))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "T0_space?")
   (expand "is_T0?")
   (expand "member")
   (skosimp*)
   (lemma "closure_is_down")
   (lemma "Cl_closed")
   (inst-cp - "singleton(x!1)")
   (inst - "singleton(y!1)")
   (inst-cp - "x!1")
   (inst - "y!1")
   (replace -3)
   (replace -4)
   (hide -3 -4)
   (inst-cp + "complement(down(x!1))")
   (("1"
     (inst + "complement(down(y!1))")
     (("1"
       (flatten)
       (expand "complement")
       (expand "member")
       (expand "down")
       (lemma "partial_order_antisymmetric")
       (inst - "x!1" "y!1")
       (rewrite "partial_order_reflexive")
       (rewrite "partial_order_reflexive")
       (assert))
      ("2"
       (expand "scott_open_sets")
       (expand "Complement")
       (inst + "down(y!1)")
       (("1"
         (assert)
         (expand "closed?")
         (expand "member")
         (expand "scott_open_sets")
         (expand "Complement")
         (skosimp)
         (typepred "b!1")
         (rewrite "complement_equal" -2)
         (typepred "<=")
         (expand "directed_complete_partial_order?")
         (propax))
        ("2"
         (typepred "<=")
         (expand "directed_complete_partial_order?")
         (flatten))))
      ("3"
       (typepred "<=")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (hide -1 2)
     (expand "closed?")
     (expand "scott_open_sets")
     (expand "Complement")
     (expand "member")
     (propax))
    ("3"
     (typepred "<=")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "hausdorff_space?")
   (lemma "scott_topology")
   (assert)
   (expand "hausdorff?")
   (expand "is_T2?")
   (expand "trivial_partial_order?")
   (split)
   (("1"
     (skosimp*)
     (split)
     (("1"
       (flatten)
       (inst - "x!1" "y!1")
       (assert)
       (skosimp)
       (typepred "U!1")
       (typepred "V!1")
       (expand "scott_open_sets")
       (expand "Complement")
       (skosimp*)
       (typepred "b!1")
       (typepred "b!2")
       (expand "scott_closed_sets")
       (expand "extend")
       (prop)
       (lemma "complement_lower_set" ("L" "b!1"))
       (("1"
         (lemma "complement_lower_set" ("L" "b!2"))
         (("1"
           (replace -7 * rl)
           (replace -8 * rl)
           (hide-all-but (1 -1 -2 -9 -11 -12 -10))
           (expand "upper_set?")
           (expand "member")
           (inst - "x!1" "y!1")
           (assert)
           (expand "disjoint?")
           (expand "empty?")
           (inst - "y!1")
           (expand "intersection")
           (expand "member")
           (propax))
          ("2" (propax))))
        ("2" (propax))))
      ("2" (flatten) (replace -1) (rewrite "partial_order_reflexive"))))
    ("2"
     (skosimp*)
     (inst + "singleton(x!1)" "singleton(y!1)")
     (("1"
       (expand "singleton")
       (expand "member")
       (expand "disjoint?")
       (expand "intersection")
       (expand "empty?")
       (expand "member")
       (skosimp*)
       (assert))
      ("2"
       (expand "scott_open_sets")
       (expand "Complement")
       (inst + "complement(singleton[T](y!1))")
       (("1" (rewrite "complement_complement"))
        ("2"
         (expand "scott_closed_sets")
         (expand "extend")
         (prop)
         (("1"
           (skosimp*)
           (typepred "lub(D!1)")
           (("1"
             (expand "least_upper_bound?")
             (flatten)
             (expand "singleton")
             (expand "complement")
             (expand "member")
             (replace -5)
             (hide -5 -7)
             (expand "subset?")
             (expand "member")
             (expand "upper_bound?")
             (expand "lower_set?")
             (expand "member")
             (inst -2 "x!1")
             (split -2)
             (("1" (inst -5 "y!1" "x!1") (assert))
              ("2"
               (skosimp)
               (typepred "r!1")
               (inst - "r!1")
               (inst-cp -5 "r!1" "y!1")
               (assert)
               (replace -6)
               (hide -2 -6)
               (inst -3 "y!1"))))
            ("2"
             (typepred "<=")
             (expand "directed_complete_partial_order?")
             (flatten))))
          ("2"
           (expand "lower_set?")
           (expand "singleton")
           (expand "complement")
           (expand "member")
           (skosimp*)
           (inst - "y!2" "x!2")
           (assert))))))
      ("3"
       (expand "scott_open_sets")
       (expand "Complement")
       (inst + "complement(singleton(x!1))")
       (("1" (rewrite "complement_complement"))
        ("2"
         (expand "scott_closed_sets")
         (expand "extend")
         (prop)
         (("1"
           (skosimp)
           (typepred "D!1")
           (typepred "lub(D!1)")
           (("1"
             (expand "least_upper_bound?")
             (flatten)
             (expand "lower_set?")
             (expand "member")
             (expand "singleton")
             (expand "complement")
             (expand "member")
             (replace -7)
             (hide -9 -7 -3 -4)
             (expand "subset?")
             (expand "member")
             (inst - "y!1")
             (expand "upper_bound?")
             (inst -3 "_" "x!1")
             (assert)
             (inst -3 "y!1")
             (assert)
             (inst-cp -3 "y!1")
             (assert)
             (skosimp)
             (typepred "r!1")
             (inst - "r!1")
             (inst - "r!1")
             (assert)
             (inst - "r!1" "x!1")
             (assert))
            ("2"
             (expand "lower_set?")
             (expand "complement")
             (expand "member")
             (expand "singleton")
             (assert)
             (typepred "<=")
             (expand "directed_complete_partial_order?")
             (propax))))
          ("2"
           (expand "lower_set?")
           (skosimp)
           (expand "complement")
           (expand "member")
           (expand "singleton")
           (replace -2)
           (inst - "x!1" "x!2")
           (assert))))))))))


proof_type: j_proof
decl_type: tcc
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (lemma "lt_order")
   (expand "closed?")
   (expand "member")
   (expand "scott_open_sets")
   (expand "Complement")
   (skosimp)
   (typepred "b!1")
   (expand "scott_closed_sets")
   (expand "extend")
   (rewrite "complement_equal")
   (assert))


proof_type: j_proof
decl_type: tcc
library: scott
theory: scott
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (lemma "closed_complement" ("A" "x!1"))
   (assert)
   (lemma "closed_is_lower" ("x" "complement(x!1)"))
   (lemma "complement_lower_set" ("L" "complement(x!1)"))
   (("1" (rewrite "complement_complement")) ("2" (propax))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: scott_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "le1!1")
   (typepred "le2!1")
   (expand "partial_order?")
   (expand "preorder?")
   (flatten)
   (split)
   (("1"
     (expand "reflexive?")
     (skosimp)
     (inst - "x!1`2")
     (inst - "x!1`1")
     (assert))
    ("2"
     (expand "transitive?")
     (skosimp)
     (inst - "x!1`2" "y!1`2" "z!1`2")
     (inst - "x!1`1" "y!1`1" "z!1`1")
     (assert)
     (assert))
    ("3"
     (expand "antisymmetric?")
     (skosimp)
     (inst - "x!1`2" "y!1`2")
     (inst - "x!1`1" "y!1`1")
     (assert)
     (decompose-equality))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: scott_product
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (typepred "product_order(le1, le2)")
   (expand "directed_complete_partial_order?")
   (hide -1)
   (expand "product_order")
   (lemma "product_preserves_directed_complete[T1,T2]")
   (inst -1 "le1" "le2")
   (("1" (expand "*") (propax))
    ("2"
     (hide 2)
     (assert)
     (typepred "le2")
     (expand "directed_complete_partial_order?")
     (propax))
    ("3"
     (hide 2)
     (typepred "le1")
     (expand "directed_complete_partial_order?")
     (propax))))


proof_type: j_proof
decl_type: tcc
library: scott
theory: fun_preds_partial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "strict_increasing?")
   (expand "increasing?")
   (skosimp)
   (inst - "x!2" "y!1")
   (replace 1)
   (replace -1)
   (expand "/=")
   (typepred "le2")
   (expand "partial_order?")
   (expand "preorder?")
   (expand "reflexive?")
   (flatten)
   (inst - "x!1(x!2)")
   (assert))


proof_type: j_proof
decl_type: tcc
library: scott
theory: fun_preds_partial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "strict_decreasing?")
   (expand "decreasing?")
   (skosimp)
   (typepred "le2")
   (expand "partial_order?")
   (expand "preorder?")
   (expand "reflexive?")
   (flatten)
   (inst - "x!1(y!1)")
   (inst - "x!2" "y!1")
   (assert))


proof_type: j_proof
decl_type: tcc
library: scott
theory: fun_preds_partial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (expand "strict_monotonic?")
   (expand "monotonic?")
   (flatten)
   (split)
   (("1" (use "strict_increasing_is_increasing"))
    ("2" (use "strict_decreasing_is_decreasing"))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (typepred "g!1")
   (expand "lub_set?")
   (typepred "le2")
   (expand "directed_complete_partial_order?")
   (flatten)
   (expand "directed_complete?")
   (inst - "image(g!1,D!1)")
   (hide 2)
   (split)
   (("1"
     (expand "nonempty?")
     (expand "empty?")
     (skosimp)
     (inst - "g!1(x!1)")
     (expand "member")
     (expand "image")
     (inst + "x!1"))
    ("2"
     (expand "directed?")
     (skosimp*)
     (expand "image")
     (skosimp*)
     (replace -1)
     (replace -2)
     (expand "directed?")
     (inst - "x!2" "x!3")
     (assert)
     (skosimp)
     (inst + "g!1(z!1)")
     (("1"
       (expand "increasing?")
       (inst-cp - "x!2" "z!1")
       (inst - "x!3" "z!1")
       (assert)
       (assert))
      ("2" (expand "image") (inst + "z!1"))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (typepred "g!1")
   (expand "directed?")
   (expand "directed?")
   (skosimp*)
   (expand "image")
   (skosimp*)
   (replace -4)
   (replace -5)
   (hide -4 -5 -2)
   (inst - "x!2" "x!3")
   (assert)
   (skosimp)
   (inst + "g!1(z!1)")
   (("1"
     (expand "increasing?")
     (inst-cp - "x!2" "z!1")
     (inst - "x!3" "z!1")
     (assert))
    ("2" (expand "image") (inst + "z!1"))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (lemma "directed_image" ("g" "g!1" "D" "D!1"))
   (typepred "lub(image(g!1, D!1))")
   (("1"
     (expand "least_upper_bound?")
     (flatten)
     (inst - "g!1(lub(D!1))")
     (("1"
       (split -2)
       (("1" (propax))
        ("2"
         (hide 2)
         (expand "upper_bound?" 1)
         (skosimp)
         (typepred "r!1")
         (expand "image")
         (skosimp)
         (replace -1)
         (hide -1 -2 -3)
         (typepred "g!1")
         (typepred "lub(D!1)")
         (("1"
           (expand "least_upper_bound?")
           (flatten)
           (hide -2)
           (expand "upper_bound?")
           (inst - "x!1")
           (expand "increasing?")
           (inst - "x!1" "lub(D!1)")
           (("1" (assert))
            ("2"
             (typepred "le1")
             (expand "directed_complete_partial_order?")
             (flatten))))
          ("2"
           (typepred "le1")
           (expand "directed_complete_partial_order?")
           (assert))))))
      ("2"
       (typepred "le1")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (typepred "le2")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem + ("f"))
   (expand "increasing?")
   (flatten)
   (skolem + ("x" "y"))
   (flatten)
   (name "X" "lambda (z:T1): z=x OR z=y")
   (case "lub_set?(X)")
   (("1"
     (case "lub[T1,le1](X)=y")
     (("1"
       (inst - "X")
       (("1"
         (replace -1)
         (case-replace "f(x)=f(y)")
         (("1"
           (typepred "le2")
           (expand "directed_complete_partial_order?")
           (expand "partial_order?")
           (expand "preorder?")
           (flatten)
           (expand "reflexive?")
           (inst - "f(y)"))
          ("2"
           (case-replace
            "image(f,X) = LAMBDA (z:T2): z = f(x) OR z = f(y)")
           (("1"
             (name-replace "Y" "LAMBDA (z: T2): z = f(x) OR z = f(y)")
             (flatten)
             (case "lub_set?(Y)")
             (("1"
               (case "lub[T2,le2](Y)=f(x) OR lub[T2,le2](Y)=f(y)")
               (("1"
                 (split -1)
                 (("1" (assert))
                  ("2"
                   (typepred "lub[T2, le2](Y)")
                   (expand "least_upper_bound?")
                   (flatten)
                   (expand "upper_bound?")
                   (inst - "f(x)")
                   (("1" (assert)) ("2" (expand "Y") (propax))))))
                ("2"
                 (flatten)
                 (typepred "lub[T2, le2](Y)")
                 (expand "least_upper_bound?")
                 (flatten)
                 (expand "upper_bound?")
                 (inst - "f(y)")
                 (("1"
                   (typepred "le2")
                   (expand "directed_complete_partial_order?")
                   (expand "partial_order?")
                   (expand "antisymmetric?")
                   (flatten)
                   (inst - "lub[T2, le2](Y)" "f(y)")
                   (assert))
                  ("2" (expand "Y") (propax))))
                ("3"
                 (assert)
                 (typepred "le2")
                 (expand "directed_complete_partial_order?")
                 (propax))))
              ("2"
               (expand "lub_set?")
               (typepred "le2")
               (expand "directed_complete_partial_order?")
               (expand "directed_complete?")
               (flatten)
               (inst - "Y")
               (expand "directed?")
               (skosimp)
               (expand "directed?")
               (inst -8 "x!1" "y!1")
               (assert))
              ("3"
               (typepred "le2")
               (expand "directed_complete_partial_order?")
               (flatten))))
            ("2"
             (apply-extensionality 1 :hide? t)
             (expand "image")
             (hide-all-but 1)
             (case-replace "EXISTS (x: (X)): x!1 = f(x)")
             (("1"
               (skosimp)
               (typepred "x!2")
               (expand "X")
               (split -1)
               (("1" (assert)) ("2" (assert))))
              ("2"
               (replace 1 2)
               (assert)
               (split -1)
               (("1" (inst + "x") (expand "X") (propax))
                ("2" (inst + "y") (expand "X") (propax))))))))))
        ("2"
         (hide 2 -3)
         (split)
         (("1"
           (expand "nonempty?")
           (expand "empty?")
           (inst - "x")
           (expand "member")
           (expand "X")
           (propax))
          ("2"
           (expand "directed?")
           (expand "directed?")
           (skosimp)
           (typepred "lub[T1, le1](X)")
           (replace -4)
           (expand "least_upper_bound?")
           (flatten)
           (expand "upper_bound?")
           (inst + "y")
           (("1" (inst-cp - "x!1") (inst - "y!1") (assert))
            ("2" (expand "X") (propax))))))))
      ("2"
       (hide -3 2)
       (typepred "lub[T1, le1](X)")
       (expand "least_upper_bound?")
       (flatten)
       (expand "upper_bound?")
       (inst -2 "y")
       (inst -1 "y")
       (("1"
         (split -2)
         (("1"
           (typepred "le1")
           (expand "directed_complete_partial_order?")
           (expand "partial_order?")
           (flatten)
           (expand "antisymmetric?")
           (inst - "lub[T1, le1](X)" "y")
           (assert))
          ("2"
           (skosimp)
           (typepred "r!1")
           (expand "X")
           (split -1)
           (("1" (assert))
            ("2"
             (typepred "le1")
             (expand "directed_complete_partial_order?")
             (expand "partial_order?")
             (expand "preorder?")
             (flatten)
             (expand "reflexive?")
             (inst - "y")
             (assert))))))
        ("2" (expand "X") (propax))))
      ("3" (propax))))
    ("2"
     (hide 2 -2 -1)
     (expand "lub_set?")
     (expand "least_bounded_above?")
     (inst + "y")
     (expand "least_upper_bound?")
     (expand "upper_bound?")
     (split)
     (("1"
       (skosimp)
       (typepred "r!1")
       (expand "X")
       (split -1)
       (("1" (assert))
        ("2"
         (typepred "le1")
         (expand "directed_complete_partial_order?")
         (expand "partial_order?")
         (expand "preorder?")
         (flatten)
         (expand "reflexive?")
         (inst - "y")
         (assert))))
      ("2" (skosimp*) (inst - "y") (expand "X") (propax))))
    ("3"
     (typepred "le1")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "scott_continuous?")
   (split)
   (("1"
     (flatten)
     (case-replace "increasing?(f!1)")
     (("1"
       (expand "lub_preserving?")
       (skosimp)
       (typepred "D!1")
       (lemma "directed_image" ("g" "f!1" "D" "D!1"))
       (("1"
         (case "nonempty?[T2](image[T1, T2](f!1,D!1))")
         (("1"
           (lemma "closure_is_down"
            ("x" "lub[T2, le2](image(f!1, D!1))"))
           (("1"
             (name "FD" "image(f!1, D!1)")
             (replace -1)
             (name "JFD" "lub[T2, le2](FD)")
             (replace -1)
             (lemma "down_is_closed[T2,le2]" ("x" "JFD"))
             (expand "member")
             (rewrite "continuous_closed_sets")
             (inst - "down(JFD)")
             (("1"
               (expand "closed?")
               (expand "scott_open_sets")
               (expand "Complement")
               (expand "member")
               (split -10)
               (("1"
                 (skosimp)
                 (typepred "b!1")
                 (rewrite "complement_equal")
                 (case "subset?(D!1,b!1)")
                 (("1"
                   (expand "scott_closed_sets")
                   (expand "extend")
                   (prop)
                   (inst - "D!1")
                   (assert)
                   (typepred "lub[T2,le2](FD)")
                   (replace -7)
                   (typepred "lub(D!1)")
                   (("1"
                     (name "JD" "lub(D!1)")
                     (replace -1)
                     (expand "least_upper_bound?")
                     (flatten)
                     (expand "increasing?")
                     (inst -5 "f!1(JD)")
                     (split -5)
                     (("1"
                       (expand "inverse_image")
                       (expand "member")
                       (replace -9 -7 rl)
                       (assert)
                       (expand "down")
                       (lemma "partial_order_antisymmetric"
                        ("x" "f!1(JD)" "y" "JFD"))
                       (assert))
                      ("2"
                       (expand "upper_bound?")
                       (skosimp)
                       (typepred "r!1")
                       (replace -12 -1 rl)
                       (expand "image")
                       (skosimp)
                       (replace -1)
                       (inst -18 "x!1" "JD")
                       (inst -3 "x!1")
                       (assert))))
                    ("2"
                     (typepred "le1")
                     (expand "directed_complete_partial_order?")
                     (flatten))))
                  ("2"
                   (expand "subset?")
                   (skosimp)
                   (expand "member")
                   (replace -3 1 rl)
                   (expand "inverse_image")
                   (expand "member")
                   (expand "down")
                   (expand "JFD")
                   (typepred "lub[T2, le2](FD)")
                   (expand "least_upper_bound?")
                   (flatten)
                   (expand "upper_bound?")
                   (inst - "f!1(x!1)")
                   (expand "FD")
                   (expand "image")
                   (inst + "x!1"))))
                ("2"
                 (inst + "down(JFD)")
                 (typepred "le2")
                 (expand "directed_complete_partial_order?")
                 (flatten))))
              ("2"
               (typepred "le2")
               (expand "directed_complete_partial_order?")
               (flatten))))
            ("2"
             (typepred "le2")
             (expand "directed_complete_partial_order?")
             (flatten))))
          ("2"
           (expand "nonempty?")
           (expand "empty?")
           (skosimp)
           (expand "member")
           (inst - "f!1(x!1)")
           (expand "image")
           (inst + "x!1"))))
        ("2" (propax))))
      ("2"
       (hide 2)
       (expand "increasing?")
       (skosimp)
       (case "inverse_image(f!1, Cl(singleton(f!1(y!1))))(y!1)")
       (("1"
         (lemma "Cl_closed" ("A" "singleton(f!1(y!1))"))
         (rewrite "continuous_closed_sets")
         (rewrite "order_iff_closure" 1)
         (inst - "Cl(singleton(f!1(y!1)))")
         (assert)
         (expand "closed?" -4)
         (expand "scott_open_sets")
         (expand "scott_closed_sets")
         (expand "member")
         (expand "extend")
         (expand "Complement")
         (skosimp)
         (typepred "b!1")
         (rewrite "complement_equal")
         (assert)
         (expand "inverse_image")
         (expand "member")
         (expand "lower_set?")
         (expand "member")
         (inst -2 "y!1" "x!1")
         (replace -6 -2 rl)
         (assert))
        ("2"
         (expand "inverse_image")
         (expand "member")
         (lemma "subset_of_Cl" ("A" "singleton(f!1(y!1))"))
         (expand "subset?")
         (inst - "f!1(y!1)")
         (expand "member")
         (expand "singleton")
         (propax))))
      ("3"
       (typepred "le2")
       (expand "directed_complete_partial_order?")
       (flatten))
      ("4"
       (typepred "le1")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (flatten)
     (rewrite "continuous_open_sets")
     (skosimp)
     (case "upper_set?(inverse_image(f!1,Y!1))")
     (("1"
       (expand "open?")
       (expand "member")
       (expand "scott_open_sets")
       (expand "Complement")
       (skosimp)
       (typepred "b!1")
       (expand "scott_closed_sets")
       (expand "extend")
       (prop)
       (name "X" "inverse_image(f!1, Y!1)")
       (replace -1)
       (inst + "complement(X)")
       (("1" (rewrite "complement_complement"))
        ("2"
         (expand "scott_closed_sets")
         (expand "extend")
         (lemma "complement_upper_set" ("U" "X"))
         (("1"
           (assert)
           (skosimp)
           (typepred "D!1")
           (replace -5 * rl)
           (expand "complement")
           (expand "member")
           (replace -12)
           (typepred "lub(D!1)")
           (inst -9 "image(f!1,D!1)")
           (("1"
             (expand "inverse_image")
             (expand "member")
             (expand "lub_preserving?")
             (inst -11 "D!1")
             (split -11)
             (("1"
               (split -9)
               (("1" (assert))
                ("2"
                 (expand "subset?")
                 (skosimp)
                 (expand "member")
                 (expand "image")
                 (skosimp)
                 (typepred "x!2")
                 (expand "lower_set?")
                 (inst -8 "x!2")
                 (assert))))
              ("2"
               (expand "lub_set?")
               (lemma "directed_image" ("g" "f!1" "D" "D!1"))
               (typepred "le2")
               (expand "directed_complete_partial_order?")
               (flatten)
               (expand "directed_complete?")
               (inst - "image(f!1, D!1)")
               (expand "directed?" -2)
               (propax))))
            ("2"
             (lemma "directed_image" ("g" "f!1" "D" "D!1"))
             (assert)
             (hide-all-but (-3 1))
             (expand "nonempty?")
             (expand "empty?")
             (skosimp)
             (inst - "f!1(x!1)")
             (expand "member")
             (expand "image")
             (inst + "x!1"))))
          ("2" (propax))))))
      ("2"
       (hide 2)
       (expand "open?")
       (expand "member")
       (expand "scott_open_sets")
       (expand "Complement")
       (skosimp)
       (typepred "b!1")
       (expand "scott_closed_sets")
       (expand "extend")
       (prop)
       (expand "upper_set?")
       (expand "member")
       (expand "inverse_image")
       (skosimp)
       (expand "member")
       (replace -7)
       (expand "complement")
       (expand "member")
       (expand "lower_set?")
       (expand "member")
       (inst - "f!1(y!1)" "f!1(x!1)")
       (expand "increasing?")
       (inst - "x!1" "y!1")
       (assert))
      ("3"
       (typepred "le1")
       (expand "directed_complete_partial_order?")
       (flatten))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "restrict")
   (expand "directed_complete?")
   (skosimp)
   (typepred "D!1")
   (expand "pointwise")
   (expand "least_bounded_above?")
   (case "FORALL (x: T1): lub_set?[T2, le2]({y: T2 | EXISTS (f: (D!1)): y=f(x)})")
   (("1"
     (name "F"
           "LAMBDA (x:T1): lub[T2,le2]({y: T2 | EXISTS (f: (D!1)): y=f(x)})")
     (("1"
       (case "increasing?(F)")
       (("1"
         (lemma "directed_is_lub_set[T1,le1]")
         (lemma "lub_set_image" ("g" "F"))
         (("1"
           (name "FX"
                 "LAMBDA (D:directed[T1, le1]): {y: T2 | EXISTS (f:(D!1),x:(D)): y = f(x)}")
           (case "forall (D: directed[T1, le1]): nonempty?[T2](FX(D)) AND directed?[T2](le2)(FX(D))")
           (("1"
             (case "forall (D: directed[T1, le1]): lub_set?(FX(D))")
             (("1"
               (case "forall (D:directed[T1, le1]): F(lub(D)) = lub(FX(D))")
               (("1"
                 (case "FORALL (D: directed[T1, le1]): lub(image[T1,T2](F,D)) = lub(FX(D))")
                 (("1"
                   (case "lub_preserving?(F)")
                   (("1"
                     (case "scott_continuous?(F)")
                     (("1"
                       (inst + "F")
                       (expand "least_upper_bound?")
                       (split 1)
                       (("1"
                         (expand "upper_bound?")
                         (skosimp)
                         (skosimp)
                         (typepred "r!1")
                         (inst -14 "x!1")
                         (typepred
                          "lub({y: T2 | EXISTS (f: (D!1)): y = f(x!1)})")
                         (("1"
                           (expand "least_upper_bound?")
                           (flatten)
                           (expand "upper_bound?")
                           (inst - "r!1(x!1)")
                           (("1" (expand "F") (propax))
                            ("2" (inst + "r!1"))))
                          ("2" (propax))))
                        ("2"
                         (skosimp)
                         (skosimp)
                         (typepred "r!1")
                         (expand "upper_bound?")
                         (inst -14 "x!1")
                         (typepred
                          "lub({y: T2 | EXISTS (f: (D!1)): y = f(x!1)})")
                         (("1"
                           (expand "least_upper_bound?")
                           (flatten)
                           (inst - "r!1(x!1)")
                           (split -2)
                           (("1" (expand "F") (propax))
                            ("2"
                             (hide 2)
                             (expand "upper_bound?")
                             (skosimp)
                             (typepred "r!2")
                             (skosimp)
                             (replace -1)
                             (inst -4 "f!1")
                             (inst -4 "x!1"))))
                          ("2" (propax))))))
                      ("2" (expand "scott_continuous?") (assert))))
                    ("2"
                     (hide 2)
                     (expand "lub_preserving?")
                     (skosimp)
                     (inst - "D!2")
                     (inst - "D!2")
                     (assert))))
                  ("2"
                   (hide 2 -1)
                   (skosimp)
                   (lemma "lub_set_image" ("g" "F" "D" "D!2"))
                   (inst - "D!2")
                   (typepred "lub(image[T1, T2](F, D!2))")
                   (typepred "lub(FX(D!2))")
                   (expand "least_upper_bound?")
                   (flatten)
                   (inst - "lub(image[T1, T2](F, D!2))")
                   (("1"
                     (split -2)
                     (("1"
                       (inst -4 "lub(FX(D!2))")
                       (("1"
                         (split -4)
                         (("1"
                           (lemma "partial_order_antisymmetric"
                            ("x"
                             "lub(image[T1, T2](F, D!2))"
                             "y"
                             "lub(FX(D!2))"))
                           (assert))
                          ("2"
                           (hide 2 -1)
                           (expand "upper_bound?")
                           (skosimp)
                           (typepred "r!1")
                           (expand "image")
                           (skosimp)
                           (replace -1)
                           (inst -12 "x!1")
                           (typepred
                            "lub({y: T2 | EXISTS (f: (D!1)): y = f(x!1)})")
                           (("1"
                             (expand "least_upper_bound?")
                             (flatten)
                             (inst - "lub(FX(D!2))")
                             (("1"
                               (split -2)
                               (("1" (expand "F") (propax))
                                ("2"
                                 (hide 2)
                                 (expand "upper_bound?")
                                 (skosimp)
                                 (typepred "r!2")
                                 (skosimp)
                                 (replace -1)
                                 (inst -4 "f!1(x!1)")
                                 (expand "FX")
                                 (inst + "f!1" "x!1"))))
                              ("2"
                               (typepred "le2")
                               (expand "directed_complete_partial_order?")
                               (flatten))))
                            ("2" (propax))))))
                        ("2"
                         (typepred "le2")
                         (expand "directed_complete_partial_order?")
                         (flatten))))
                      ("2"
                       (hide 2)
                       (expand "upper_bound?")
                       (skosimp)
                       (typepred "r!1")
                       (expand "FX" -1)
                       (skosimp)
                       (replace -1)
                       (inst -3 "F(x!1)")
                       (("1"
                         (hide-all-but (1 -3 -13))
                         (inst - "x!1")
                         (name-replace "DRL100"
                          "lub(image[T1, T2](F, D!2))")
                         (expand "F")
                         (typepred
                          "lub({y: T2 | EXISTS (f: (D!1)): y = f(x!1)})")
                         (("1"
                           (expand "least_upper_bound?")
                           (flatten)
                           (hide -2)
                           (expand "upper_bound?")
                           (inst - "f!1(x!1)")
                           (("1"
                             (lemma "partial_order_transitive"
                              ("x"
                               "f!1(x!1)"
                               "y"
                               "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(x!1)})"
                               "z"
                               "DRL100"))
                             (assert))
                            ("2" (inst + "f!1"))))
                          ("2" (propax))))
                        ("2" (expand "image") (inst + "x!1"))))))
                    ("2"
                     (typepred "le2")
                     (expand "directed_complete_partial_order?")
                     (flatten))))
                  ("3" (propax))))
                ("2"
                 (skosimp)
                 (hide 2)
                 (expand "F" 1)
                 (expand "FX")
                 (hide -3 -7)
                 (inst - "D!2")
                 (inst - "D!2")
                 (flatten)
                 (typepred
                  "lub({y: T2 | EXISTS (f: (D!1), x: (D!2)): y = f(x)})")
                 (("1"
                   (typepred
                    "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(lub(D!2))})")
                   (("1"
                     (expand "least_upper_bound?")
                     (flatten)
                     (expand "upper_bound?")
                     (inst -2
                      "lub({y: T2 | EXISTS (f: (D!1), x: (D!2)): y = f(x)})")
                     (split -2)
                     (("1"
                       (inst -4
                        "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(lub(D!2))})")
                       (("1"
                         (split -4)
                         (("1"
                           (lemma "partial_order_antisymmetric"
                            ("x"
                             "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(lub(D!2))})"
                             "y"
                             "lub({y: T2 | EXISTS (f: (D!1), x: (D!2)): y = f(x)})"))
                           (assert))
                          ("2"
                           (hide 2)
                           (skosimp)
                           (typepred "r!1")
                           (skosimp)
                           (typepred "x!1")
                           (inst -4 "f!1(lub(D!2))")
                           (("1"
                             (name-replace "DRL100"
                              "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(lub(D!2))})")
                             (replace -2)
                             (hide-all-but (1 -1 -4))
                             (typepred "f!1")
                             (expand "scott_continuous?")
                             (flatten)
                             (typepred "lub(D!2)")
                             (expand "least_upper_bound?")
                             (flatten)
                             (expand "upper_bound?")
                             (inst - "x!1")
                             (expand "increasing?")
                             (inst - "x!1" "lub(D!2)")
                             (("1"
                               (assert)
                               (lemma "partial_order_transitive"
                                ("x"
                                 "f!1(x!1)"
                                 "y"
                                 "f!1(lub(D!2))"
                                 "z"
                                 "DRL100"))
                               (assert))
                              ("2"
                               (typepred "le1")
                               (expand "directed_complete_partial_order?")
                               (flatten))))
                            ("2" (inst + "f!1"))
                            ("3"
                             (typepred "le1")
                             (expand "directed_complete_partial_order?")
                             (flatten))
                            ("4"
                             (typepred "le2")
                             (expand "directed_complete_partial_order?")
                             (flatten)
                             (lemma "directed_is_lub_set[T1,le1]")
                             (inst?))))))
                        ("2"
                         (inst -10 "lub(D!2)")
                         (("1"
                           (typepred "le1")
                           (expand "directed_complete_partial_order?")
                           (assert))
                          ("2"
                           (lemma "directed_is_lub_set[T1,le1]")
                           (inst?))))
                        ("3"
                         (skosimp*)
                         (typepred "le1")
                         (expand "directed_complete_partial_order?")
                         (flatten))
                        ("4"
                         (skosimp*)
                         (lemma "directed_is_lub_set[T1,le1]")
                         (inst?))))
                      ("2"
                       (skosimp)
                       (typepred "r!1")
                       (skosimp)
                       (replace -1)
                       (hide 2)
                       (hide -1)
                       (typepred "f!1")
                       (expand "scott_continuous?")
                       (flatten)
                       (expand "lub_preserving?")
                       (inst - "D!2")
                       (lemma "lub_set_image" ("g" "f!1" "D" "D!2"))
                       (assert)
                       (replace -3)
                       (expand "image")
                       (name-replace "DRL101"
                        "{y: T2 | EXISTS (f: (D!1), x: (D!2)): y = f(x)}")
                       (name-replace "DRL102"
                        "{y: T2 | EXISTS (x: (D!2)): y = f!1(x)}")
                       (lemma "above_lub[T2,le2]")
                       (inst - "DRL101" "DRL102")
                       (split -1)
                       (("1" (propax))
                        ("2"
                         (hide 2)
                         (expand "above?")
                         (skosimp)
                         (typepred "x!1")
                         (expand "DRL102")
                         (skosimp)
                         (replace -1)
                         (expand "DRL101")
                         (inst + "f!1(x!2)")
                         (("1" (rewrite "partial_order_reflexive"))
                          ("2"
                           (expand "DRL101")
                           (inst + "f!1" "x!2"))))))))
                    ("2"
                     (inst -8 "lub(D!2)")
                     (("1"
                       (typepred "le1")
                       (expand "directed_complete_partial_order?")
                       (flatten))
                      ("2"
                       (lemma "directed_is_lub_set[T1,le1]")
                       (inst?))))
                    ("3"
                     (skosimp*)
                     (typepred "le1")
                     (expand "directed_complete_partial_order?")
                     (flatten))
                    ("4"
                     (skosimp*)
                     (lemma "directed_is_lub_set[T1,le1]")
                     (inst?))))
                  ("2" (propax))))
                ("3" (propax))
                ("4"
                 (assert)
                 (skosimp*)
                 (typepred "le1")
                 (expand "directed_complete_partial_order?")
                 (flatten))
                ("5" (propax))))
              ("2"
               (skosimp)
               (inst - "D!2")
               (flatten)
               (lemma "directed_is_lub_set" ("x" "FX(D!2)"))
               (("1" (propax)) ("2" (expand "directed?" 1) (propax))))
              ("3"
               (skosimp*)
               (typepred "le2")
               (expand "directed_complete_partial_order?")
               (flatten))))
            ("2"
             (hide 2 -1 -5)
             (skosimp)
             (typepred "D!2")
             (expand "nonempty?")
             (expand "empty?")
             (expand "member")
             (split 2)
             (("1"
               (skosimp*)
               (expand "FX")
               (inst - "x!2(x!1)")
               (inst + "x!2" "x!1"))
              ("2"
               (hide 2 3)
               (expand "directed?")
               (skosimp*)
               (expand "FX")
               (skosimp*)
               (replace -1)
               (replace -2)
               (typepred "f!1")
               (typepred "f!2")
               (inst -12 "f!1" "f!2")
               (assert)
               (expand "scott_continuous?")
               (flatten)
               (hide-all-but (1 -1 -3 -4 -6 -9 -14))
               (skosimp)
               (expand "directed?")
               (inst - "x!2" "x!3")
               (assert)
               (skosimp)
               (expand "increasing?")
               (inst - "x!3" "z!2")
               (inst - "x!2" "z!2")
               (assert)
               (inst - "z!2")
               (inst - "z!2")
               (lemma "partial_order_transitive" ("z" "z!1(z!2)"))
               (inst-cp - "f!1(x!2)" "f!1(z!2)")
               (inst - "f!2(x!3)" "f!2(z!2)")
               (assert)
               (inst + "z!1(z!2)")
               (("1" (assert))
                ("2" (expand "FX") (inst + "z!1" "z!2"))))))
            ("3"
             (skosimp*)
             (typepred "le2")
             (expand "directed_complete_partial_order?")
             (flatten))))
          ("2" (propax))))
        ("2"
         (hide 2)
         (expand "increasing?")
         (skosimp)
         (expand "F")
         (hide -2)
         (inst-cp - "x!1")
         (inst - "y!1")
         (typepred
          "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(x!1)})")
         (("1"
           (typepred
            "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(y!1)})")
           (("1"
             (expand "least_upper_bound?")
             (flatten)
             (expand "upper_bound?")
             (inst -4
              "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(y!1)})")
             (("1"
               (split -4)
               (("1" (propax))
                ("2"
                 (hide 2)
                 (skosimp)
                 (typepred "r!1")
                 (skosimp)
                 (replace -1)
                 (inst -2 "f!1(y!1)")
                 (("1"
                   (typepred "f!1")
                   (expand "scott_continuous?")
                   (flatten)
                   (expand "increasing?")
                   (inst - "x!1" "y!1")
                   (assert)
                   (lemma "partial_order_transitive"
                    ("x"
                     "f!1(x!1)"
                     "y"
                     "f!1(y!1)"
                     "z"
                     "lub[T2, le2]({y: T2 | EXISTS (f: (D!1)): y = f(y!1)})"))
                   (assert))
                  ("2" (inst + "f!1"))))))
              ("2"
               (typepred "le2")
               (expand "directed_complete_partial_order?")
               (flatten))))
            ("2" (propax))))
          ("2" (propax))))
        ("3"
         (typepred "le2")
         (expand "directed_complete_partial_order?")
         (flatten))
        ("4"
         (typepred "le1")
         (expand "directed_complete_partial_order?")
         (flatten))))
      ("2" (propax))))
    ("2"
     (hide 2)
     (skosimp)
     (expand "lub_set?")
     (typepred "le2")
     (expand "directed_complete_partial_order?")
     (flatten)
     (expand "directed_complete?")
     (inst - "{y: T2 | EXISTS (f: (D!1)): y = f(x!1)}")
     (hide 2 -1)
     (split)
     (("1"
       (expand "nonempty?")
       (expand "empty?")
       (skosimp)
       (expand "member")
       (inst - "x!2(x!1)")
       (inst + "x!2"))
      ("2"
       (expand "directed?")
       (skosimp*)
       (replace -1)
       (replace -2)
       (typepred "f!1")
       (typepred "f!2")
       (inst - "f!1" "f!2")
       (assert)
       (skosimp)
       (inst - "x!1")
       (inst - "x!1")
       (inst + "z!1(x!1)")
       (("1" (assert)) ("2" (inst + "z!1"))))))
    ("3"
     (skosimp*)
     (typepred "le2")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "pointwise_complete")
   (expand "directed_complete_partial_order?")
   (assert)
   (expand "restrict")
   (typepred "le2")
   (expand "directed_complete_partial_order?")
   (flatten)
   (assert)
   (hide -2 -3)
   (expand "partial_order?")
   (prop)
   (("1"
     (expand "pointwise")
     (expand "preorder?")
     (prop)
     (("1" (expand "reflexive?") (skosimp*) (inst?))
      ("2"
       (expand "transitive?")
       (skosimp*)
       (inst -1 "x!2")
       (inst - "x!2")
       (assert)
       (inst - "x!1(x!2)" "y!1(x!2)" "z!1(x!2)")
       (assert))))
    ("2"
     (expand "antisymmetric?")
     (skosimp*)
     (expand "pointwise")
     (apply-extensionality 1 :hide? t)
     (inst - "x!2")
     (inst - "x!2")
     (inst - "x!1(x!2)" "y!1(x!2)")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (expand "nonempty?")
   (expand "empty?")
   (skosimp)
   (expand "member")
   (inst - "g!1(x!1)")
   (expand "image")
   (inst + "x!1"))


proof_type: t_proof
decl_type: tcc
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (expand "nonempty?")
   (expand "empty?")
   (skosimp)
   (inst - "f!1(x!1)")
   (expand "member")
   (expand "image")
   (inst + "x!1"))


proof_type: t_proof
decl_type: tcc
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (expand "lub_set?")
   (typepred "le2")
   (expand "directed_complete_partial_order?")
   (flatten)
   (expand "directed_complete?")
   (inst - "image[T1,T2](f!1,D!1)")
   (expand "directed?" -4)
   (propax))


proof_type: j_proof
decl_type: tcc
library: scott
theory: scott_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "x!1")
   (rewrite "scott_continuous_def")
   (expand "scott_continuous?")
   (flatten))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "least_unique"
    ("<=" "<=" "S" "fullset[T]" "s" "x!1" "t" "y!1"))
   (("1" (propax)) ("2" (propax)) ("3" (propax))
    ("4"
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (expand "directed_complete_partial_order?")
     (expand "partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "bottom")
   (expand "least?")
   (flatten)
   (expand "lower_bound?")
   (inst - "x!1")
   (expand "fullset")
   (propax))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "bottom")
   (expand "least?")
   (flatten)
   (expand "lower_bound?")
   (inst - "x!1")
   (("1"
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (expand "directed_complete_partial_order?")
     (expand "partial_order?")
     (flatten)
     (expand "antisymmetric?")
     (inst - "bottom" "x!1")
     (assert))
    ("2" (expand "fullset") (propax))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (typepred "<=")
   (expand "pointed_directed_complete_partial_order?")
   (flatten)
   (expand "has_bottom?")
   (skosimp)
   (expand "nonempty?")
   (expand "empty?")
   (inst - "x!1")
   (grind))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "lub(D!1)")
   (("1"
     (typepred "lub(add(bottom,D!1))")
     (expand "least_upper_bound?")
     (flatten)
     (expand "upper_bound?")
     (inst -2 "lub(D!1)")
     (("1"
       (split -2)
       (("1"
         (inst -4 "lub(add(bottom, D!1))")
         (("1"
           (split -4)
           (("1"
             (lemma "partial_order_antisymmetric"
              ("x" "lub(D!1)" "y" "lub(add(bottom, D!1))"))
             (assert))
            ("2"
             (hide 2)
             (skosimp)
             (typepred "r!1")
             (inst -3 "r!1")
             (expand "add")
             (expand "member")
             (propax))))
          ("2"
           (typepred "<=")
           (expand "pointed_directed_complete_partial_order?")
           (expand "directed_complete_partial_order?")
           (expand "partial_order?")
           (flatten)
           (assert))))
        ("2"
         (skosimp)
         (typepred "r!1")
         (expand "add")
         (split -1)
         (("1" (replace -1 * rl) (rewrite "bottom_le"))
          ("2" (expand "member") (inst -3 "r!1"))))))
      ("2"
       (typepred "<=")
       (expand "pointed_directed_complete_partial_order?")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (flatten)
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1" (expand "power") (skosimp) (expand "increasing?") (skosimp*))
    ("2"
     (skosimp*)
     (expand "power" 1)
     (expand "o")
     (inst - "phi!1")
     (typepred "phi!1")
     (expand "increasing?")
     (skosimp*)
     (inst - "power(phi!1, j!1)(x!1)" "power(phi!1, j!1)(y!1)")
     (inst - "x!1" "y!1")
     (assert))
    ("3"
     (skosimp*)
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "phi!1")
   (expand "increasing?")
   (skosimp*)
   (lemma "increasing_phi_n" ("phi" "phi!1" "n" "x!1"))
   (lemma "bottom_le" ("x" "power(phi!1, y!1-x!1)(bottom)"))
   (("1"
     (hide -3)
     (expand "increasing?")
     (inst - "bottom" "power(phi!1, y!1 - x!1)(bottom)")
     (("1"
       (assert)
       (lemma "power_mult" ("a" "phi!1" "n" "x!1" "m" "y!1-x!1"))
       (expand "o")
       (replace -1 1 rl)
       (assert))
      ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "nonempty?")
   (expand "empty?")
   (inst - "bottom")
   (expand "FIX_APPROX")
   (grind)
   (inst + "0")
   (grind))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "FIX_APPROX")
   (expand "fullset")
   (expand "image")
   (expand "chain?")
   (expand "total_order?")
   (expand "dichotomous?")
   (expand "restrict")
   (typepred "<=")
   (expand "pointed_directed_complete_partial_order?")
   (flatten)
   (expand "directed_complete_partial_order?")
   (flatten)
   (hide -2 -3)
   (expand "partial_order?")
   (prop)
   (expand "preorder?")
   (flatten)
   (skosimp)
   (typepred "x!1")
   (skosimp)
   (typepred "y!1")
   (skosimp)
   (lemma "trich_lt" ("x" "x!2" "y" "x!3"))
   (case "forall (i,j:nat): i <= j => power(phi!1, i)(bottom) <= power(phi!1, j)(bottom)")
   (("1"
     (split -2)
     (("1" (inst - "x!2" "x!3") (assert))
      ("2"
       (replace -1)
       (replace -3 * rl)
       (replace -4 * rl)
       (hide-all-but (1 -5))
       (expand "reflexive?")
       (inst - "x!1"))
      ("3" (inst - "x!3" "x!2") (assert))))
    ("2"
     (hide-all-but (-4 -5 -6 1))
     (skosimp)
     (lemma "increasing_power" ("phi" "phi!1"))
     (expand "increasing?")
     (inst - "i!1" "j!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "X!1")
   (expand "directed?")
   (skosimp)
   (expand "chain?")
   (expand "total_order?")
   (expand "restrict")
   (expand "dichotomous?")
   (inst - "x!1" "y!1")
   (split)
   (("1" (inst + "y!1") (assert)) ("2" (inst + "x!1") (assert))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (typepred "lub(emptyset[T])")
   (("1"
     (expand "least_upper_bound?")
     (flatten)
     (expand "upper_bound?")
     (inst -2 "bottom")
     (split -2)
     (("1" (lemma "le_bottom" ("x" "lub(emptyset[T])")) (assert))
      ("2" (skosimp) (typepred "r!1") (expand "emptyset") (propax))))
    ("2"
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (flatten)
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "fix")
   (expand "FIX")
   (expand "member")
   (case "forall n: power(phi!1,n)(x!1) = x!1")
   (("1"
     (lemma "bottom_le" ("x" "x!1"))
     (lemma "increasing_phi_n" ("phi" "phi!1"))
     (case "forall n: power(phi!1, n)(bottom) <= x!1")
     (("1"
       (lemma "fix_approx_nonempty" ("phi" "phi!1"))
       (lemma "fix_approx_chain" ("phi" "phi!1"))
       (case "lub_set?(FIX_APPROX(phi!1))")
       (("1"
         (typepred "lub[T, <=](FIX_APPROX(phi!1))")
         (expand "least_upper_bound?")
         (flatten)
         (inst - "x!1")
         (replace 1 -2)
         (expand "upper_bound?")
         (skosimp)
         (typepred "r!1")
         (expand "FIX_APPROX")
         (hide -2)
         (expand "image")
         (skosimp)
         (inst -5 "x!2")
         (assert))
        ("2" (lemma "fix_TCC1" ("phi" "phi!1")) (propax))
        ("3"
         (typepred "<=")
         (expand "pointed_directed_complete_partial_order?")
         (expand "directed_complete_partial_order?")
         (flatten))))
      ("2"
       (skosimp)
       (inst - "n!1")
       (expand "increasing?")
       (inst - "bottom" "x!1")
       (inst - "n!1")
       (assert))))
    ("2"
     (induct "n")
     (("1" (expand "power") (propax))
      ("2"
       (skosimp*)
       (expand "power" 1)
       (expand "o")
       (replace -1)
       (propax))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "phi!1")
   (expand "fix")
   (lemma "fix_approx_chain" ("phi" "phi!1"))
   (case "lub_set?(FIX_APPROX(phi!1))")
   (("1"
     (typepred "lub(FIX_APPROX(phi!1))")
     (expand "least_upper_bound?")
     (flatten)
     (inst - "phi!1(lub[T, <=](FIX_APPROX(phi!1)))")
     (("1"
       (split -2)
       (("1" (propax))
        ("2"
         (hide 2)
         (expand "upper_bound?")
         (skosimp)
         (typepred "r!1")
         (name-replace "LUB" "lub[T, <=](FIX_APPROX(phi!1))")
         (expand "FIX_APPROX")
         (expand "fullset")
         (expand "image")
         (skosimp)
         (case-replace "x!1=0")
         (("1" (expand "power") (replace -2) (rewrite "bottom_le"))
          ("2"
           (inst - "power(phi!1,x!1-1)(bottom)")
           (("1"
             (expand "increasing?")
             (inst - "power(phi!1, x!1 - 1)(bottom)" "LUB")
             (("1" (assert) (expand "power" -1) (expand "o") (assert))
              ("2" (assert))))
            ("2"
             (expand "FIX_APPROX")
             (expand "image")
             (inst + "x!1-1")
             (assert)
             (expand "fullset")
             (propax))
            ("3" (assert))))))))
      ("2"
       (typepred "<=")
       (expand "pointed_directed_complete_partial_order?")
       (expand "directed_complete_partial_order?")
       (flatten))))
    ("2"
     (hide 2)
     (lemma "fix_approx_nonempty" ("phi" "phi!1"))
     (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(phi!1)"))
     (("1"
       (assert)
       (lemma "directed_is_lub_set" ("x" "FIX_APPROX(phi!1)"))
       (("1" (propax)) ("2" (expand "directed?" 1) (propax))))
      ("2" (propax))))
    ("3"
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "psi!1")
   (rewrite "scott_continuous_def")
   (expand "scott_continuous?")
   (expand "lub_preserving?")
   (flatten)
   (expand "FIX")
   (expand "member")
   (lemma "fix_approx_chain" ("phi" "psi!1"))
   (lemma "fix_approx_nonempty" ("phi" "psi!1"))
   (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(psi!1)"))
   (("1"
     (assert)
     (case "lub_set?(FIX_APPROX(psi!1))")
     (("1"
       (inst - "FIX_APPROX(psi!1)")
       (("1"
         (lemma "lub_set_image" ("g" "psi!1" "D" "FIX_APPROX(psi!1)"))
         (("1"
           (assert)
           (lemma "lub_add_bottom"
            ("D" "image(psi!1, FIX_APPROX(psi!1))"))
           (("1"
             (expand "fix")
             (assert)
             (replace -8 1)
             (hide -8)
             (replace -1)
             (hide -1)
             (typepred "lub(FIX_APPROX(psi!1))")
             (typepred "lub(add(bottom,image(psi!1,FIX_APPROX(psi!1))))")
             (expand "least_upper_bound?")
             (flatten)
             (inst -2 "lub(FIX_APPROX(psi!1))")
             (split -2)
             (("1"
               (inst -
                "lub(add(bottom, image(psi!1, FIX_APPROX(psi!1))))")
               (split -4)
               (("1"
                 (lemma "partial_order_antisymmetric"
                  ("x"
                   "lub(add(bottom, image(psi!1, FIX_APPROX(psi!1))))"
                   "y"
                   "lub(FIX_APPROX(psi!1))"))
                 (assert))
                ("2"
                 (hide 2)
                 (expand "upper_bound?")
                 (skosimp)
                 (typepred "r!1")
                 (inst -3 "r!1")
                 (hide 2)
                 (expand "add")
                 (flatten)
                 (expand "member")
                 (expand "image")
                 (expand "FIX_APPROX")
                 (expand "image")
                 (skosimp)
                 (replace -1)
                 (case-replace "x!1=0")
                 (("1" (expand "power") (propax))
                  ("2"
                   (inst + "power(psi!1,x!1-1)(bottom)")
                   (("1" (expand "power" 3 1) (expand "o" 3) (assert))
                    ("2"
                     (expand "FIX_APPROX")
                     (expand "image")
                     (inst + "x!1-1")
                     (assert)
                     (expand "fullset")
                     (propax))
                    ("3" (assert))))))))
              ("2"
               (hide 2)
               (expand "upper_bound?")
               (skosimp)
               (typepred "r!1")
               (expand "add")
               (split -1)
               (("1" (replace -1 * rl) (rewrite "bottom_le"))
                ("2"
                 (expand "member")
                 (expand "image")
                 (skosimp)
                 (typepred "x!1")
                 (inst -4 "r!1")
                 (replace -2 1)
                 (expand "FIX_APPROX")
                 (expand "image")
                 (skosimp)
                 (replace -1 1)
                 (inst + "x!2+1")
                 (("1" (expand "power" 1 2) (expand "o" 1) (propax))
                  ("2" (expand "fullset") (propax))))))))
            ("2"
             (hide 2)
             (split 1)
             (("1"
               (expand "nonempty?")
               (expand "empty?")
               (skosimp)
               (expand "member")
               (expand "image")
               (expand "FIX_APPROX")
               (expand "image")
               (skosimp)
               (case-replace "x!2=0")
               (("1"
                 (expand "power")
                 (inst - "psi!1(bottom)")
                 (inst + "bottom")
                 (expand "FIX_APPROX")
                 (expand "image")
                 (inst + "0")
                 (("1" (expand "power") (propax))
                  ("2" (expand "fullset") (propax))))
                ("2"
                 (inst - "x!1")
                 (inst + "power(psi!1,x!2-1)(bottom)")
                 (("1"
                   (expand "power" -4)
                   (assert)
                   (expand "o" -4)
                   (propax))
                  ("2"
                   (expand "FIX_APPROX")
                   (expand "image")
                   (inst + "x!2-1")
                   (assert)
                   (expand "fullset")
                   (propax))
                  ("3" (assert))))))
              ("2"
               (expand "directed?")
               (expand "directed?")
               (skosimp)
               (expand "image")
               (skosimp*)
               (replace -1)
               (replace -2)
               (hide -1 -2)
               (typepred "x!2")
               (typepred "x!3")
               (inst - "x!2" "x!3")
               (assert)
               (skosimp)
               (inst + "psi!1(z!1)")
               (("1"
                 (expand "increasing?")
                 (inst-cp -9 "x!2" "z!1")
                 (inst -9 "x!3" "z!1")
                 (assert)
                 (assert))
                ("2" (expand "image") (inst + "z!1"))))))))
          ("2" (expand "directed?" 1) (propax))))
        ("2" (expand "directed?" 1) (propax))))
      ("2"
       (lemma "directed_is_lub_set" ("x" "FIX_APPROX(psi!1)"))
       (("1" (propax)) ("2" (expand "directed?" 1) (propax))))))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "fix_in_FIX" ("psi" "psi!1"))
   (expand "nonempty?")
   (expand "empty?")
   (inst - "fix(psi!1)"))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "fix_in_FIX" ("psi" "psi!1"))
   (expand "member")
   (expand "FIX")
   (propax))


proof_type: f_proof
decl_type: formula
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "psi!1")
   (rewrite "scott_continuous_def")
   (expand "scott_continuous?")
   (flatten)
   (expand "increasing?")
   (expand "fix")
   (typepred "lub(FIX_APPROX(psi!1))")
   (("1"
     (expand "least_upper_bound?")
     (flatten)
     (name-replace "FIX_F" "lub(FIX_APPROX(psi!1))")
     (name-replace "F" "psi!1")
     (inst - "x!1")
     (hide -1)
     (assert)
     (hide 2)
     (expand "upper_bound?")
     (skosimp)
     (typepred "r!1")
     (expand "FIX_APPROX")
     (expand "fullset")
     (expand "image")
     (case "forall (n:nat): power(F,n)(bottom) <= x!1")
     (("1" (skolem - ("n!1")) (replace -2) (inst - "n!1"))
      ("2"
       (hide -1 2)
       (induct "n")
       (("1" (expand "power") (assert) (rewrite "bottom_le"))
        ("2"
         (skosimp)
         (expand "power" 1)
         (expand "o")
         (inst - "power(F, j!1)(bottom)" "x!1")
         (assert)
         (typepred "<=")
         (expand "pointed_directed_complete_partial_order?")
         (expand "directed_complete_partial_order?")
         (expand "partial_order?")
         (expand "preorder?")
         (flatten)
         (expand "transitive?")
         (inst - "F(power(F, j!1)(bottom))" "F(x!1)" "x!1")
         (assert))))))
    ("2"
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (expand "directed_complete_partial_order?")
     (flatten))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (typepred "<=")
   (expand "pointed_directed_complete_partial_order?")
   (flatten)
   (expand "has_least?")
   (skosimp)
   (inst + "t!1"))


proof_type: t_proof
decl_type: tcc
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "monoid?")
   (expand "monad?")
   (expand "groupoid?")
   (expand "star_closed?")
   (split)
   (("1" (expand "fullset") (expand "member") (propax))
    ("2" (expand "fullset") (expand "member") (propax))
    ("3"
     (expand "identity?")
     (expand "restrict")
     (skosimp)
     (split)
     (("1" (apply-extensionality :hide? t) (expand "o") (propax))
      ("2" (expand "o") (apply-extensionality :hide? t))))
    ("4"
     (expand "associative?")
     (skosimp)
     (expand "restrict")
     (apply-extensionality :hide? t)
     (grind))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "D!1")
   (expand "lub_set?")
   (typepred "<=")
   (expand "pointed_directed_complete_partial_order?")
   (expand "directed_complete_partial_order?")
   (flatten)
   (expand "directed_complete?")
   (inst - "D!1")
   (("1"
     (expand "least_bounded_above?")
     (skosimp)
     (inst + "t!1")
     (hide -5)
     (expand "least_upper_bound?")
     (flatten)
     (split)
     (("1"
       (expand "upper_bound?")
       (skosimp)
       (typepred "r!1")
       (expand "add")
       (split)
       (("1" (lemma "bottom_le" ("x" "t!1")) (assert))
        ("2" (expand "member") (inst -3 "r!1"))))
      ("2"
       (skosimp)
       (inst -4 "r!1")
       (assert)
       (expand "upper_bound?" (2 -1))
       (skosimp)
       (typepred "r!2")
       (inst - "r!2")
       (expand "add")
       (flatten)
       (expand "member")
       (propax))))
    ("2"
     (assert)
     (hide 2)
     (expand "directed?")
     (expand "directed?")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "lub_set?")
   (expand "least_bounded_above?")
   (inst + "bottom")
   (expand "least_upper_bound?")
   (expand "upper_bound?")
   (split)
   (("1" (skosimp) (typepred "r!1") (expand "emptyset") (propax))
    ("2" (skosimp) (rewrite "bottom_le"))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "fix_approx_chain" ("phi" "phi!1"))
   (lemma "fix_approx_nonempty" ("phi" "phi!1"))
   (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(phi!1)"))
   (("1"
     (assert)
     (assert)
     (lemma "directed_is_lub_set" ("x" "FIX_APPROX(phi!1)"))
     (("1" (propax)) ("2" (expand "directed?" 1) (propax))))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: scott
theory: admissible
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "p!1")
   (expand "admissible_pred?")
   (inst-cp - "emptyset[T]")
   (rewrite "lub_emptyset")
   (split -2)
   (("1"
     (inst - "FIX_APPROX(phi!1)")
     (lemma "fix_approx_nonempty" ("phi" "phi!1"))
     (lemma "fix_approx_chain" ("phi" "phi!1"))
     (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(phi!1)"))
     (("1"
       (expand "directed?" -5)
       (assert)
       (expand "fix")
       (split -5)
       (("1" (propax))
        ("2"
         (hide-all-but (-4 -5 1))
         (skosimp)
         (typepred "x!1")
         (expand "FIX_APPROX")
         (expand "image")
         (skosimp)
         (replace -1)
         (hide -1)
         (case "forall (n:nat): p!1(power(phi!1,n)(bottom))")
         (("1" (inst - "x!2"))
          ("2"
           (hide 2)
           (induct "n")
           (("1" (expand "power") (propax))
            ("2"
             (skosimp*)
             (expand "power" 1)
             (expand "o")
             (inst - "power(phi!1, j!1)(bottom)")
             (assert))))))))
      ("2" (propax))))
    ("2" (skosimp) (typepred "x!1") (expand "emptyset") (propax))
    ("3"
     (expand "empty?")
     (flatten)
     (skosimp)
     (expand "member")
     (expand "emptyset")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: admissible
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "directed_complete_partial_order?")
   (expand "partial_order?")
   (expand "preorder?")
   (split)
   (("1" (expand "reflexive?") (skosimp))
    ("2" (expand "transitive?") (skosimp) (assert))
    ("3"
     (expand "antisymmetric?")
     (skosimp)
     (assert)
     (case-replace "x!1")
     (assert))
    ("4"
     (expand "directed_complete?")
     (skosimp)
     (typepred "D!1")
     (expand "least_bounded_above?")
     (case "D!1(FALSE)")
     (("1"
       (inst + "FALSE")
       (expand "least_upper_bound?")
       (split)
       (("1" (expand "upper_bound?") (propax))
        ("2" (skosimp) (expand "upper_bound?") (inst - "FALSE"))))
      ("2"
       (inst + "TRUE")
       (expand "least_upper_bound?")
       (expand "upper_bound?")
       (skosimp)
       (typepred "r!1")
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: admissible
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (hide -1)
   (split)
   (("1"
     (expand "lub_set?")
     (expand "least_bounded_above?")
     (typepred "<=")
     (expand "pointed_directed_complete_partial_order?")
     (flatten)
     (expand "fullset")
     (expand "has_least?")
     (skosimp)
     (expand "least?")
     (expand "lower_bound?")
     (inst + "t!1")
     (expand "least_upper_bound?")
     (hide -1)
     (split)
     (("1"
       (expand "upper_bound?")
       (skosimp)
       (typepred "r!1")
       (expand "empty?")
       (inst -3 "r!1")
       (expand "member")
       (propax))
      ("2" (expand "upper_bound?") (skosimp*) (inst -2 "r!1"))))
    ("2" (lemma "directed_is_lub_set[T,<=]") (inst - "D!1"))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: admissible
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "admissible_pred?")
   (expand "lub_preserving?")
   (skosimp)
   (typepred "D!1")
   (typepred "lub(image((LAMBDA x: TRUE), D!1))")
   (("1"
     (expand "least_upper_bound?")
     (flatten)
     (expand "upper_bound?")
     (inst -2 "TRUE")
     (split -2)
     (("1" (propax))
      ("2" (skosimp) (typepred "r!1") (expand "image") (skosimp))))
    ("2" (hide-all-but 1) (grind))))


proof_type: f_proof
decl_type: formula
library: scott
theory: dual_fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (lemma "fixpoint_induction[[T1,T2],(le1*le2)]" ("p" "p!1"))
   (typepred "phi!1")
   (typepred "psi!1")
   (name "PHI" "LAMBDA (z:[T1,T2]): (phi!1(z`1),psi!1(z`2))")
   (case "increasing?(PHI)")
   (("1"
     (inst - "PHI")
     (split -5)
     (("1"
       (hide -3 -6)
       (lemma "fix_approx_nonempty" ("phi" "psi!1"))
       (lemma "fix_approx_nonempty" ("phi" "phi!1"))
       (lemma "fix_approx_nonempty" ("phi" "PHI"))
       (lemma "fix_approx_chain" ("phi" "psi!1"))
       (lemma "fix_approx_chain" ("phi" "phi!1"))
       (lemma "fix_approx_chain" ("phi" "PHI"))
       (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(psi!1)"))
       (("1"
         (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(phi!1)"))
         (("1"
           (lemma "ne_chain_is_directed" ("X" "FIX_APPROX(PHI)"))
           (("1"
             (assert)
             (expand "fix")
             (lemma "product_lub"
              ("r1" "le1" "r2" "le2" "D" "FIX_APPROX(PHI)"))
             (("1"
               (case-replace
                "{x: T1 | EXISTS (z: (FIX_APPROX(PHI))): z`1 = x} = FIX_APPROX(phi!1)")
               (("1"
                 (case-replace
                  "{y: T2 | EXISTS (z: (FIX_APPROX(PHI))): z`2 = y} = FIX_APPROX(psi!1)")
                 (("1"
                   (hide -1 -2)
                   (rewrite "lub_rew" 1)
                   (rewrite "lub_rew" 1)
                   (rewrite "lub_rew" -11)
                   (replace -1)
                   (propax))
                  ("2"
                   (hide 2)
                   (hide -1)
                   (apply-extensionality 1 :hide? t)
                   (case "forall (n:nat): power(PHI,n)(bottom)`2 = power(psi!1,n)(bottom)")
                   (("1"
                     (case-replace "FIX_APPROX(psi!1)(x!1)")
                     (("1"
                       (expand "FIX_APPROX")
                       (expand "image")
                       (skosimp)
                       (replace -1 1)
                       (inst -2 "x!2")
                       (replace -2 1 rl)
                       (inst + "power(PHI, x!2)(bottom)")
                       (expand "FIX_APPROX")
                       (expand "image")
                       (inst + "x!2"))
                      ("2"
                       (assert)
                       (skosimp)
                       (typepred "z!1")
                       (expand "FIX_APPROX")
                       (expand "image")
                       (skosimp)
                       (inst + "x!2")
                       (inst -2 "x!2")
                       (assert))))
                    ("2"
                     (hide-all-but 1)
                     (induct "n")
                     (("1"
                       (expand "power")
                       (lemma "fixpoints[T2,le2].bottom_le"
                        ("x" "bottom`2"))
                       (lemma "bottom_le[[T1,T2],(le1*le2)]")
                       (expand "*")
                       (inst - "(bottom,bottom)")
                       (flatten)
                       (typepred "le2")
                       (expand "pointed_directed_complete_partial_order?")
                       (expand "directed_complete_partial_order?")
                       (expand "partial_order?")
                       (flatten)
                       (expand "antisymmetric?")
                       (inst - "bottom`2" "bottom")
                       (assert))
                      ("2"
                       (skosimp)
                       (expand "power" 1)
                       (expand "o")
                       (replace -1 1 rl)
                       (hide -1)
                       (expand "PHI" 1 1)
                       (propax))))))))
                ("2"
                 (hide 2)
                 (apply-extensionality 1 :hide? t)
                 (case "forall (n:nat): power(PHI,n)(bottom)`1 = power(phi!1,n)(bottom)")
                 (("1"
                   (case-replace "FIX_APPROX(phi!1)(x!1)")
                   (("1"
                     (expand "FIX_APPROX")
                     (expand "image")
                     (skosimp)
                     (replace -1 1)
                     (inst -2 "x!2")
                     (replace -2 1 rl)
                     (inst + "power(PHI, x!2)(bottom)")
                     (expand "FIX_APPROX")
                     (expand "image")
                     (inst + "x!2"))
                    ("2"
                     (assert)
                     (skosimp)
                     (typepred "z!1")
                     (expand "FIX_APPROX")
                     (expand "image")
                     (skosimp)
                     (replace -3 1 rl)
                     (replace -1 1)
                     (hide-all-but (-2 1))
                     (inst + "x!2")
                     (inst - "x!2"))))
                  ("2"
                   (hide-all-but 1)
                   (induct "n")
                   (("1"
                     (expand "power")
                     (lemma "fixpoints[T1,le1].bottom_le"
                      ("x" "bottom`1"))
                     (lemma "fixpoints[[T1,T2],(le1*le2)].bottom_le")
                     (inst - "(bottom,bottom)")
                     (expand "*")
                     (flatten)
                     (hide -2)
                     (typepred "le1")
                     (expand "pointed_directed_complete_partial_order?")
                     (expand "directed_complete_partial_order?")
                     (expand "partial_order?")
                     (flatten)
                     (expand "antisymmetric?")
                     (inst - "bottom`1" "bottom")
                     (assert))
                    ("2"
                     (skosimp)
                     (expand "power" 1)
                     (expand "o")
                     (replace -1 1 rl)
                     (hide -1)
                     (expand "PHI" 1 1)
                     (propax))))))))
              ("2"
               (typepred "le2")
               (expand "pointed_directed_complete_partial_order?")
               (flatten))
              ("3"
               (typepred "le1")
               (expand "pointed_directed_complete_partial_order?")
               (flatten))))
            ("2" (propax))))
          ("2" (propax))))
        ("2" (propax))))
      ("2" (skosimp) (inst - "x!1`1" "x!1`2") (expand "PHI") (assert))))
    ("2"
     (hide-all-but (-2 -3 1))
     (expand "increasing?")
     (skosimp)
     (expand "*")
     (flatten)
     (expand "PHI")
     (inst - "x!1`2" "y!1`2")
     (inst - "x!1`1" "y!1`1")
     (assert)
     (assert))
    ("3"
     (assert)
     (lemma "product_preserves_partial_order" ("r1" "le1" "r2" "le2"))
     (("1" (propax))
      ("2"
       (typepred "le2")
       (expand "pointed_directed_complete_partial_order?")
       (expand "directed_complete_partial_order?")
       (flatten))
      ("3"
       (typepred "le1")
       (expand "pointed_directed_complete_partial_order?")
       (expand "directed_complete_partial_order?")
       (flatten))))))


proof_type: t_proof
decl_type: tcc
library: scott
theory: dual_fixpoints
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "directed_complete_partial_order?")
   (split)
   (("1" (grind))
    ("2"
     (expand "directed_complete?")
     (skosimp)
     (typepred "D!1")
     (expand "least_bounded_above?")
     (case "D!1(FALSE)")
     (("1"
       (inst + "FALSE")
       (expand "least_upper_bound?")
       (expand "upper_bound?")
       (skosimp)
       (inst - "FALSE"))
      ("2"
       (inst + "TRUE")
       (expand "least_upper_bound?")
       (expand "upper_bound?")
       (skosimp)
       (typepred "r!1")
       (assert))))))


proof_type: j_proof
decl_type: tcc
library: scott
theory: pointwise_orders_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "scott_continuous_dcpo[T1, T2, d1!1, d2!1]")
   (expand "continuous_pointwise")
   (expand "restrict")
   (propax))


proof_type: j_proof
decl_type: tcc
library: scott
theory: pointwise_orders_aux
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "p1!1")
   (typepred "p2!1")
   (expand "pointed_directed_complete_partial_order?")
   (flatten)
   (expand "has_least?")
   (expand "fullset")
   (skosimp*)
   (inst + "LAMBDA (x:T1): t!1")
   (("1"
     (expand "least?")
     (expand "lower_bound?")
     (skosimp)
     (expand "continuous_pointwise")
     (expand "pointwise")
     (skosimp)
     (inst -2 "r!1(x!1)"))
    ("2"
     (lemma
      "const_continuous[T1,scott_open_sets[T1,p1!1],
                                               T2,scott_open_sets[T2,p2!1]]")
     (("1"
       (inst - "t!1")
       (expand "const_fun")
       (rewrite "scott_continuous_def[T1, T2, p1!1, p2!1]"))
      ("2" (rewrite "scott_topology[T2,p2!1]"))
      ("3" (lemma "scott_topology[T1,p1!1]") (propax))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: partial_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (skosimp*)
     (expand "graph")
     (expand "extend")
     (expand "LPartFun_to_SPartFun")
     (assert))
    ("2"
     (skosimp*)
     (inst + "down(f!1(x!1))")
     (("1"
       (expand "graph")
       (expand "extend")
       (expand "LPartFun_to_SPartFun")
       (assert)
       (expand "graph")
       (propax))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: scott
theory: partial_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (split)
   (("1"
     (flatten)
     (apply-extensionality :hide? t)
     (expand "graph")
     (expand "extend")
     (expand "LPartFun_to_SPartFun")
     (rewrite "extensionality_postulate" -1 :dir rl)
     (("1"
       (case-replace "f1!1(x!1)=bottom")
       (("1"
         (lemma "member_graph" ("f" "f2!1" "x" "x!1"))
         (assert)
         (skosimp)
         (inst - "(x!1,y!1)")
         (assert)
         (expand "graph")
         (expand "extend")
         (expand "LPartFun_to_SPartFun")
         (propax))
        ("2"
         (lemma "member_graph" ("f" "f1!1" "x" "x!1"))
         (assert)
         (skosimp)
         (inst - "(x!1,y!1)")
         (assert)
         (expand "graph")
         (expand "extend")
         (expand "LPartFun_to_SPartFun")
         (expand "graph")
         (assert)
         (prop)
         (assert)
         (lemma "down_equal" ("y1" "f1!1(x!1)" "y2" "f2!1(x!1)"))
         (assert))))
      ("2" (skosimp) (skosimp) (expand "LPartFun_to_SPartFun") (propax))
      ("3" (skosimp) (expand "LPartFun_to_SPartFun") (propax))
      ("4" (skosimp) (skosimp) (expand "LPartFun_to_SPartFun") (propax))
      ("5" (skosimp) (expand "LPartFun_to_SPartFun") (propax))))
    ("2" (skosimp) (replace -1) (propax))))


proof_type: f_proof
decl_type: formula
library: scott
theory: partial_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "graph?")
   (skosimp)
   (expand "graph")
   (expand "extend")
   (prop)
   (expand "LPartFun_to_SPartFun")
   (expand "graph")
   (lemma "down_equal" ("y1" "up(y1!1)" "y2" "up(y2!1)"))
   (assert))


proof_type: f_proof
decl_type: formula
library: scott
theory: partial_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (typepred "g!1")
   (expand "graph?")
   (expand "from_graph")
   (expand "graph")
   (expand "extend")
   (expand "LPartFun_to_SPartFun")
   (expand "graph")
   (apply-extensionality 1 :hide? t)
   (("1"
     (case-replace "g!1(x!1, x!2)")
     (("1"
       (case-replace "{y | g!1(x!1, y)} = singleton(x!2)")
       (("1"
         (assert)
         (rewrite "choose_singleton")
         (rewrite "nonempty_singleton")
         (assert))
        ("2"
         (hide 2)
         (apply-extensionality 1 :hide? t)
         (expand "singleton")
         (case-replace "x!3=x!2")
         (assert)
         (inst - "x!1" "x!2" "x!3")
         (assert))))
      ("2" (assert) (prop) (lift-if -1) (assert) (prop) (assert))))
    ("2" (skosimp) (lift-if -1) (assert))))


proof_type: f_proof
decl_type: formula
library: scott
theory: partial_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (apply-extensionality :hide? t)
   (expand "graph")
   (expand "from_graph")
   (expand "extend")
   (expand "LPartFun_to_SPartFun")
   (expand "graph")
   (lift-if)
   (case-replace "up?(f!1(x!1))")
   (("1"
     (lift-if)
     (assert)
     (prop)
     (("1"
       (lemma "choose_member" ("a" "{y | (down(f!1(x!1)) = y)}"))
       (split -1)
       (("1"
         (name-replace "AA" "choose({y | (down(f!1(x!1)) = y)})")
         (expand "member")
         (replace -1 1 rl)
         (rewrite "up_down"))
        ("2" (expand "nonempty?") (propax))))
      ("2"
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (inst - "down(f!1(x!1))"))))
    ("2"
     (assert)
     (lift-if)
     (assert)
     (prop)
     (expand "nonempty?")
     (expand "empty?")
     (skosimp)
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (apply-extensionality 1 :hide? t)
   (expand "-")
   (rewrite "sigma_minus"))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (apply-extensionality 1 :hide? t)
   (expand "+")
   (rewrite "sigma_sum"))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (expand "*")
   (apply-extensionality 1 :hide? t)
   (lemma "sigma_scal")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (apply-extensionality 1 :hide? t)
   (rewrite "sigma_eq")
   (skosimp*)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "convergence_cauchy1")
   (inst?)
   (assert)
   (hide -2)
   (expand "convergence")
   (skosimp*)
   (expand "cauchy")
   (inst - "epsilon!1")
   (skosimp*)
   (inst 1 "n!1+1")
   (skosimp*)
   (expand "series")
   (inst - "i!1" "i!1-1")
   (("1" (assert) (expand "sigma" -1 1) (propax)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conv_series_terms_to_0")
   (inst?)
   (assert)
   (hide -2)
   (rewrite "limit_def")
   (expand "convergent?")
   (inst?))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "convergence_cauchy1")
   (inst?)
   (assert)
   (hide -2)
   (lemma "convergence_cauchy2")
   (inst?)
   (assert)
   (hide 2)
   (expand "cauchy")
   (skosimp*)
   (inst? -)
   (skosimp*)
   (inst?)
   (skosimp*)
   (inst - "i!1" "j!1")
   (assert)
   (expand "series")
   (case-replace "i!1 = j!1")
   (("1" (assert))
    ("2"
     (case-replace "i!1 < j!1")
     (("1"
       (rewrite "sigma_diff_neg")
       (rewrite "sigma_diff_neg")
       (lemma "sigma_abs")
       (inst?)
       (case-replace "(LAMBDA (n:nat): abs(a!1(n))) = abs(a!1)")
       (("1" (hide -1) (assert) (grind :exclude "sigma"))
        ("2"
         (hide -1 -5 3)
         (apply-extensionality :hide? t)
         (("1" (grind)) ("2" (skosimp*) (grind))))))
      ("2"
       (lemma "sigma_diff")
       (inst?)
       (assert)
       (replace -1)
       (hide -1)
       (rewrite "sigma_diff")
       (lemma "sigma_abs")
       (inst?)
       (assert)
       (case "(LAMBDA (n:nat): abs(a!1(n))) = abs(a!1)")
       (("1" (replace -1) (hide -1) (assert))
        ("2"
         (hide -1 4)
         (apply-extensionality 1 :hide? t)
         (("1" (hide -3) (grind))
          ("2" (skosimp*) (hide -3) (grind))))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (lemma "convergence_cauchy1")
     (inst?)
     (assert)
     (hide -2)
     (expand "cauchy")
     (skosimp*)
     (inst -1 "epsilon!1")
     (skosimp*)
     (inst 1 "n!1+1")
     (skosimp*)
     (expand "series")
     (inst -1 "n!2" "m!1")
     (assert)
     (case "sigma(0, n!2, a!1) - sigma(0, m!1, a!1) = sigma(m!1+1, n!2, a!1)")
     (("1" (replace -1) (hide -1) (expand "abs") (propax))
      ("2" (hide -1 2) (lemma "sigma_diff") (inst?) (assert))))
    ("2"
     (lemma "convergence_cauchy2")
     (inst?)
     (assert)
     (hide 2)
     (expand "cauchy")
     (skosimp*)
     (inst - "epsilon!1")
     (skosimp*)
     (inst 1 "N!1")
     (skosimp*)
     (expand "series")
     (case "i!1 = j!1")
     (("1" (replace -1) (assert) (expand "abs") (assert))
      ("2"
       (case "i!1 < j!1")
       (("1"
         (rewrite "sigma_diff_neg")
         (inst?)
         (assert)
         (expand "abs")
         (lift-if)
         (ground))
        ("2" (rewrite "sigma_diff") (inst?) (assert))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "convergent?")
   (inst + "0")
   (expand "convergence")
   (skosimp*)
   (inst 1 "1")
   (skosimp*)
   (expand "series")
   (rewrite "sigma_const")
   (grind))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (rewrite "limit_def")
   (("1"
     (expand "convergence")
     (skosimp*)
     (inst 1 "1")
     (skosimp*)
     (expand "series")
     (rewrite "sigma_const")
     (grind))
    ("2" (hide 2) (rewrite "zero_series_conv"))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "N!1 = 0")
   (("1"
     (case-replace "a!1 = (LAMBDA n: a!1(n + 0))")
     (("1" (assert)) ("2" (hide 2) (apply-extensionality :hide? t))))
    ("2"
     (expand "series")
     (expand "convergent?")
     (skosimp*)
     (name "AA" "sigma(0, N!1-1, a!1)")
     (("1"
       (inst + "l!1-AA")
       (expand "convergence")
       (skosimp*)
       (inst -2 "epsilon!1")
       (skosimp*)
       (inst + "n!1")
       (skosimp*)
       (lemma "sigma_shift")
       (inst?)
       (assert)
       (replace -1 * rl)
       (hide -1)
       (replace -1 * rl)
       (inst -2 "N!1+i!1")
       (assert)
       (lemma "sigma_split")
       (inst?)
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "N!1 = 0")
   (("1"
     (case-replace "a!1 = (LAMBDA n: a!1(n + 0))")
     (("1" (assert)) ("2" (hide 2) (apply-extensionality :hide? t))))
    ("2"
     (expand "series")
     (expand "convergent?")
     (skosimp*)
     (name "AA" "sigma(0, N!1-1, a!1)")
     (("1"
       (inst + "l!1+AA")
       (expand "convergence")
       (skosimp*)
       (inst -2 "epsilon!1")
       (skosimp*)
       (inst + "n!1+N!1")
       (skosimp*)
       (inst -2 "i!1-N!1")
       (("1"
         (assert)
         (assert)
         (lemma "sigma_shift")
         (inst?)
         (assert)
         (replace -1 * rl)
         (hide -1)
         (lemma "sigma_split")
         (inst -1 "a!1" "i!1" "0" "N!1-1")
         (assert))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1" (lemma "tail_series_conv") (inst?) (assert))
    ("2" (lemma "tail_series_conv2") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "tail_series_conv")
   (inst?)
   (inst -1 "N!1")
   (assert)
   (hide -2)
   (lemma "tail_series_conv2")
   (inst -1 "N!1" "b!1")
   (assert)
   (hide 2)
   (case-replace
    "series(LAMBDA n: a!1(n + N!1)) = series(LAMBDA n: b!1(n + N!1))")
   (hide -1 2)
   (expand "series")
   (apply-extensionality 1 :hide? t)
   (rewrite "sigma_eq")
   (hide 2)
   (skosimp*)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (case "m!1 = 0")
   (("1" (ground))
    ("2"
     (prop)
     (("1"
       (expand "convergent?")
       (skosimp*)
       (inst + "l!1 - sigma(0, m!1-1, a!1)")
       (("1"
         (expand "convergence")
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "n!1")
         (skosimp*)
         (case "m!1 - 1 >= i!1")
         (("1" (expand "sigma" 1 2) (assert) (inst - "m!1-1") (assert))
          ("2" (rewrite "sigma_split" :dir rl) (inst?) (assert))))
        ("2" (assert))))
      ("2"
       (expand "convergent?")
       (skosimp*)
       (inst + "l!1 + sigma(0, m!1-1, a!1)")
       (("1"
         (expand "convergence")
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "max(n!1,m!1)")
         (skosimp*)
         (expand "max")
         (lift-if)
         (ground)
         (("1"
           (lemma "sigma_split")
           (inst - "a!1" "i!1" "0" "m!1-1")
           (assert)
           (replace -1)
           (assert)
           (inst?)
           (assert))
          ("2"
           (lemma "sigma_split")
           (inst - "a!1" "i!1" "0" "m!1-1")
           (assert)
           (replace -1)
           (assert)
           (inst?)
           (assert))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "c!1 = 0")
   (("1"
     (hide -1 -2)
     (expand "*")
     (assert)
     (lemma "zero_series_conv")
     (case "(LAMBDA (x: nat): 0 * series(a!1)(x)) = series(LAMBDA n: 0)")
     (("1" (replace -1 +) (propax))
      ("2"
       (hide -1 2)
       (apply-extensionality 1 :hide? t)
       (expand "series")
       (assert)
       (lemma "sigma_const")
       (inst?)
       (lift-if)
       (ground))))
    ("2"
     (expand "convergent?")
     (skosimp*)
     (inst + "c!1*l!1")
     (expand "convergence")
     (skosimp*)
     (inst -1 "epsilon!1/abs(c!1)")
     (("1"
       (skosimp*)
       (inst + "n!1")
       (skosimp*)
       (inst?)
       (assert)
       (assert)
       (expand "*")
       (case-replace
        "c!1 * series(a!1)(i!1) - c!1 * l!1 = c!1 * (series(a!1)(i!1) - l!1)")
       (("1"
         (hide -1)
         (rewrite "abs_mult")
         (lemma "both_sides_div_pos_lt1")
         (inst -1 "abs(c!1)" "abs(c!1) * abs((series(a!1)(i!1) - l!1)) "
          "epsilon!1")
         (("1" (assert)) ("2" (hide -1 3) (grind))))
        ("2" (hide -1 3) (assert))))
      ("2"
       (hide 3)
       (typepred "epsilon!1")
       (rewrite "pos_div_ge")
       (("1"
         (rewrite "pos_div_gt")
         (("1" (grind)) ("2" (hide 2) (grind))))
        ("2" (hide 2) (grind))))
      ("3" (hide 3) (grind))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (lemma "scal_series_conv")
     (inst - "(LAMBDA (x: nat): cnz!1 * a!1(x))" "1/cnz!1")
     (expand "*")
     (lemma "series_scal")
     (inst - "(LAMBDA (x: nat): cnz!1 * a!1(x))" "1/cnz!1")
     (assert)
     (expand "*")
     (replace -1)
     (assert)
     (hide -1)
     (case-replace "(LAMBDA n: 1 / cnz!1 * (cnz!1 * a!1(n))) = a!1")
     (("1"
       (assert)
       (hide 2)
       (lemma "series_scal")
       (inst?)
       (expand "*")
       (replace -1)
       (propax))
      ("2" (apply-extensionality 1 :hide? t))))
    ("2" (lemma "scal_series_conv") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "limit_def")
   (("1"
     (name "LSH" "limit(series(LAMBDA n: a!1(pn!1 + n)))")
     (("1"
       (replace -1)
       (rewrite "limit_def")
       (("1"
         (hide -2)
         (expand "convergence")
         (skosimp*)
         (inst -1 "epsilon!1")
         (skosimp*)
         (inst + "n!1+pn!1")
         (skosimp*)
         (inst -1 "i!1-pn!1")
         (("1"
           (assert)
           (expand "series")
           (lemma "sigma_split")
           (inst -1 "a!1" "i!1" "0" "pn!1-1")
           (assert)
           (replace -1)
           (hide -1)
           (assert)
           (lemma "sigma_shift")
           (inst -1 "a!1" "i!1-pn!1" "0" "pn!1")
           (assert))
          ("2" (assert))))
        ("2" (rewrite "tail_series_conv"))))
      ("2" (rewrite "tail_series_conv"))))
    ("2" (rewrite "tail_series_conv"))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "limit_def")
   (inst -1 "limit(a!1)" "a!1")
   (assert)
   (expand "convergence")
   (inst -1 "-limit(a!1)/2")
   (skosimp*)
   (inst -1 "n!1")
   (assert)
   (grind :exclude "limit"))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (copy -1)
   (hide -1)
   (expand "series")
   (lemma "sigma_first")
   (inst?)
   (case-replace
    "(LAMBDA (n: nat): sigma(0, n, a!1)) =
                                (LAMBDA (n: nat): a!1(0) + sigma(1, n, a!1))")
   (("1"
     (hide -1 -2)
     (lemma "limit_sum")
     (inst - "(LAMBDA (n: nat): sigma(1, n, a!1))"
      "(LAMBDA (n: nat): a!1(0))")
     (("1"
       (expand "+")
       (replace -1)
       (hide -1)
       (lemma "limit_const")
       (inst - "a!1(0)")
       (expand "const_fun")
       (replace -1)
       (propax))
      ("2"
       (hide 2)
       (lemma "convergent_const")
       (expand "const_fun")
       (inst?))
      ("3"
       (case "convergent?(series(a!1))")
       (("1"
         (hide 2)
         (lemma "end_series_conv")
         (inst?)
         (inst - "1")
         (assert)
         (expand "series")
         (propax))
        ("2" (hide 2 3) (reveal -5) (propax))))))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (inst?)
     (assert)
     (expand "sigma")
     (propax))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "inf_sum")
   (lemma "limit_scal")
   (inst - "c!1" "series(a!1,k!1)")
   (assert)
   (lemma "series_m_scal")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "convergence_cauchy1")
   (inst -1 "series(b!1)")
   (assert)
   (lemma "convergence_cauchy2")
   (inst -1 "series(a!1)")
   (assert)
   (hide -2 2)
   (expand "cauchy")
   (skosimp*)
   (inst? -)
   (skosimp*)
   (inst?)
   (skosimp*)
   (inst -3 "i!1" "j!1")
   (assert)
   (case-replace "i!1 = j!1")
   (("1" (assert))
    ("2"
     (expand "series")
     (case "i!1 < j!1")
     (("1"
       (rewrite "sigma_diff_neg" +)
       (rewrite "sigma_diff_neg")
       (lemma "sigma_abs")
       (inst?)
       (lemma "sigma_abs_bnd")
       (inst - "a!1" "b!1" "j!1" "1+i!1")
       (split -1)
       (("1"
         (case-replace
          "abs(-sigma(1 + i!1, j!1, a!1)) = abs(sigma(1 + i!1, j!1, a!1))")
         (("1"
           (hide -1)
           (case "sigma(1 + i!1, j!1, b!1) <= abs(-sigma(1 + i!1, j!1, b!1))")
           (("1" (assert))
            ("2" (hide -1 -2 -6 -7 3) (grind :exclude "sigma"))))
          ("2" (hide -1 -2 -6 -7 3) (grind :exclude "sigma"))))
        ("2" (hide -1 -4 3) (skosimp*) (inst?))))
      ("2"
       (rewrite "sigma_diff")
       (rewrite "sigma_diff")
       (lemma "sigma_abs")
       (inst?)
       (lemma "sigma_abs_bnd")
       (inst - "a!1" "b!1" "i!1" "1+j!1")
       (split -1)
       (("1"
         (case "sigma(1 + i!1, j!1, b!1) <= abs(sigma(1 + i!1, j!1, b!1))")
         (("1" (assert))
          ("2" (hide -1 -2 -5 -6 4) (grind :exclude "sigma"))))
        ("2" (skosimp*) (inst?))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "tail_series_conv2")
   (inst -1 "N!1" "a!1")
   (assert)
   (hide 2)
   (lemma "tail_series_conv")
   (inst -1 "N!1" "b!1")
   (split -1)
   (("1"
     (hide -2)
     (lemma "comparison_test")
     (inst -1 "(LAMBDA n: a!1(n + N!1))" "(LAMBDA n: b!1(n + N!1))")
     (assert)
     (hide -1 2)
     (skosimp*)
     (inst -1 "n!1+N!1")
     (assert))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "inf_sum")
   (case-replace "series(b!1, m!1) = series(a!1, m!1)")
   (assert)
   (hide 2)
   (expand "series")
   (apply-extensionality 1 :hide? t)
   (rewrite "sigma_eq")
   (skosimp*)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "inf_sum")
   (lemma "comparison_test_gen")
   (inst - "a!1" "b!1")
   (lemma "end_series_conv")
   (inst?)
   (assert)
   (split -2)
   (("1"
     (lemma "end_series_conv")
     (inst - "a!1" "m!1")
     (assert)
     (name "LA" "limit(series(a!1, m!1))")
     (replace -1)
     (name "LB" "limit(series(b!1, m!1))")
     (replace -1)
     (lemma "cnv_seq_order")
     (inst - "LA" "LB" "series(a!1,m!1)" "series(b!1,m!1)")
     (assert)
     (prop)
     (("1" (lemma "limit_equiv") (inst?) (assert))
      ("2" (lemma "limit_equiv") (inst?) (assert))
      ("3"
       (skosimp*)
       (hide 2)
       (expand "series")
       (lemma "sigma_le")
       (inst?)
       (assert)
       (skosimp*)
       (inst?)
       (expand "abs")
       (lift-if)
       (ground))))
    ("2" (inst + "m!1") (skosimp*) (inst?))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "inf_sum")
   (lemma "comparison_test_gen")
   (inst - "a!1" "b!1")
   (lemma "end_series_conv")
   (inst?)
   (assert)
   (split -2)
   (("1"
     (lemma "end_series_conv")
     (inst - "a!1" "m!1")
     (assert)
     (hide -2 -3)
     (name "LA" "limit(series(a!1, m!1))")
     (replace -1)
     (name "LB" "limit(series(b!1, m!1))")
     (replace -1)
     (case "LA <= LB AND -LB <= LA")
     (("1" (expand "abs") (lift-if) (ground))
      ("2"
       (hide 2)
       (split +)
       (("1"
         (lemma "cnv_seq_order")
         (inst - "LA" "LB" "series(a!1,m!1)" "series(b!1,m!1)")
         (assert)
         (prop)
         (("1" (lemma "limit_equiv") (inst?) (assert))
          ("2" (lemma "limit_equiv") (inst?) (assert))
          ("3"
           (skosimp*)
           (hide 2)
           (expand "series")
           (lemma "sigma_le")
           (inst?)
           (assert)
           (skosimp*)
           (inst?)
           (expand "abs")
           (lift-if)
           (ground))))
        ("2"
         (lemma "cnv_seq_order")
         (inst - "-LB" "LA" "-series(b!1,m!1)" "series(a!1,m!1)")
         (assert)
         (prop)
         (("1"
           (lemma "conv_series_scal")
           (inst?)
           (inst -1 "-1")
           (assert)
           (lemma "inf_sum_scal")
           (inst -1 "b!1" "-1" "m!1")
           (assert)
           (expand "inf_sum")
           (lemma "series_m_scal")
           (inst?)
           (assert)
           (replace -1 * rl)
           (replace -4)
           (lemma "limit_equiv")
           (inst?)
           (assert)
           (case-replace "-series(b!1, m!1) = -1*series(b!1, m!1)")
           (("1"
             (assert)
             (hide -1 -2 -3)
             (lemma "end_series_conv")
             (inst -1 "-b!1" "m!1")
             (case-replace "-1 * series(b!1) = series(-b!1)")
             (("1"
               (assert)
               (case-replace
                "series(-b!1, m!1) = (-1 * series(b!1, m!1))")
               (expand "*")
               (apply-extensionality 1 :hide? t)
               (expand "-")
               (assert)
               (hide 2 3 4)
               (expand "series")
               (lemma "sigma_scal")
               (inst?)
               (assert))
              ("2"
               (expand "series")
               (assert)
               (expand "*")
               (apply-extensionality 1 :hide? t)
               (lemma "sigma_scal")
               (inst?)
               (assert)
               (expand "-")
               (assert))))
            ("2"
             (apply-extensionality 1 :hide? t)
             (expand "-")
             (assert)
             (expand "*")
             (assert))))
          ("2" (lemma "limit_equiv") (inst?) (assert))
          ("3"
           (lemma "limit_equiv")
           (inst?)
           (assert)
           (skosimp*)
           (hide 2)
           (expand "series")
           (expand "-")
           (case-replace "-sigma(m!1, n!1, b!1) = sigma(m!1, n!1, -b!1)")
           (("1"
             (hide -1)
             (lemma "sigma_le")
             (inst?)
             (assert)
             (skosimp*)
             (inst?)
             (expand "-")
             (expand "abs")
             (lift-if)
             (ground))
            ("2"
             (hide 2)
             (lemma "sigma_scal")
             (inst?)
             (inst - "-1")
             (assert)
             (expand "-")
             (assert))))))))))
    ("2" (inst + "m!1") (skosimp*) (inst?))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "inf_sum_le_abs")
   (inst?)
   (assert)
   (hide 2)
   (prop)
   (("1" (skosimp*) (grind))
    ("2" (lemma "end_series_conv") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "convergent?")
   (skosimp*)
   (inst 1 "l!1+l!2")
   (expand "convergence")
   (skosimp*)
   (inst - "epsilon!1/2")
   (inst - "epsilon!1/2")
   (skosimp*)
   (inst + "max(n!1,n!2)")
   (skosimp*)
   (inst - "i!1")
   (inst - "i!1")
   (split -1)
   (("1"
     (split -2)
     (("1"
       (hide -3)
       (expand "series")
       (lemma "sigma_sum")
       (inst?)
       (inst - "a!1")
       (expand "+ ")
       (replace -1 * rl)
       (hide -1)
       (grind :exclude "sigma"))
      ("2" (hide -1 2) (grind))))
    ("2" (hide -1 2) (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "cnv_seq_sum")
   (inst -1 "l1!1" "l2!1" "series(a!1)" "series(b!1)")
   (assert)
   (hide -2 -3)
   (expand "series")
   (case "(LAMBDA (n: nat): sigma(0, n, a!1)) +
                                    (LAMBDA (n: nat): sigma(0, n, b!1)) = (LAMBDA (n: nat): sigma(0, n, a!1 + b!1))")
   (("1" (replace -1) (propax))
    ("2"
     (hide -1 2)
     (expand "+ ")
     (apply-extensionality 1 :hide? t)
     (lemma "sigma_sum")
     (inst?))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "inf_sum")
   (rewrite "limit_def")
   (("1"
     (lemma "series_sum_convergence")
     (inst?)
     (assert)
     (hide 2)
     (expand "convergent?")
     (skosimp*)
     (split)
     (("1" (hide -2) (lemma "limit_def") (inst?) (assert))
      ("2" (hide -1) (lemma "limit_def") (inst?) (assert))))
    ("2"
     (hide 2)
     (expand "convergent?")
     (skosimp*)
     (inst 1 "l!1+l!2")
     (rewrite "series_sum_convergence"))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "decreasing_bounded_convergence")
   (expand "convergent?")
   (case "bounded_below?[nat]((LAMBDA (n: nat): abs(x!1) ^ n))")
   (("1"
     (inst - "(LAMBDA (n: nat): abs(x!1) ^ n)")
     (inst + "inf((LAMBDA (n: nat): abs(x!1) ^ n))")
     (assert)
     (hide -1 2)
     (expand "decreasing?")
     (skosimp*)
     (case-replace "x!1 = 0")
     (("1"
       (expand "abs" 1)
       (assert)
       (expand "^")
       (expand "expt")
       (assert)
       (lift-if)
       (ground))
      ("2"
       (lemma "both_sides_expt_lt1_le")
       (inst?)
       (("1" (assert)) ("2" (hide -2 3) (grind))))))
    ("2"
     (hide -1 2)
     (expand "bounded_below?")
     (inst + "0")
     (skosimp*)
     (lemma "expt_pos")
     (inst?)
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (name "LL" "limit(LAMBDA (n: nat): abs(x!1) ^ n)")
   (("1"
     (case "convergent?(abs(x!1) * (LAMBDA (n: nat): abs(x!1) ^ n))")
     (("1"
       (case "abs(x!1)*LL = limit(abs(x!1) * (LAMBDA (n: nat): abs(x!1) ^ n))")
       (("1"
         (case "abs(x!1) * (LAMBDA (n: nat): abs(x!1) ^ n) = (LAMBDA (n: nat): abs(x!1) ^ (n+1))")
         (("1"
           (case-replace
            "limit(abs(x!1) * (LAMBDA (n: nat): abs(x!1) ^ n)) = limit(LAMBDA (n: nat): abs(x!1) ^ (n+1))")
           (("1"
             (hide -2)
             (case-replace
              "limit(LAMBDA (n: nat): abs(x!1) ^ (n+1)) = limit(LAMBDA (n: nat): abs(x!1) ^ n)")
             (("1"
               (hide -1 -2 -4)
               (replace -2)
               (hide -2)
               (lemma "both_sides_times1")
               (inst?)
               (("1" (inst -1 "1") (assert)) ("2" (assert))))
              ("2"
               (hide -1 -2 2)
               (rewrite "limit_def")
               (("1"
                 (replace -2)
                 (expand "convergence")
                 (skosimp*)
                 (rewrite "limit_def" -)
                 (expand "convergence")
                 (inst - "epsilon!1")
                 (skosimp*)
                 (inst 1 "n!1+1")
                 (skosimp*)
                 (inst -3 "i!1+1")
                 (assert))
                ("2"
                 (expand "*")
                 (hide 2)
                 (case "(LAMBDA (x: nat): abs(x!1) * abs(x!1) ^ x) = (LAMBDA (n: nat): abs(x!1) ^ (1 + n))")
                 (("1" (assert))
                  ("2"
                   (hide -1 -2 -3 2 3)
                   (apply-extensionality 1 :hide? t)
                   (expand "^")
                   (expand "expt" 1 2)
                   (propax))))))
              ("3"
               (hide -1 -2 -4 2)
               (case "(LAMBDA (n: nat): abs(x!1) ^ (1 + n)) = abs(x!1) * (LAMBDA (n: nat): abs(x!1) ^ n)")
               (("1" (replace -1 * rl) (propax))
                ("2"
                 (hide -1 -2 2)
                 (expand "*")
                 (apply-extensionality 1 :hide? t)
                 (expand "^")
                 (expand "expt" 1 1)
                 (propax))))))
            ("2" (assert))
            ("3"
             (hide -1 -2 -3 2)
             (lemma "convergent_scal")
             (lemma "abs_x_to_n_conv")
             (inst?)
             (inst?)
             (inst - "abs(x!1)")
             (assert)
             (hide -1 -3)
             (expand "*")
             (expand "^")
             (expand "expt" 1)
             (propax))))
          ("2"
           (hide -1 -2 -3 2)
           (expand "*")
           (apply-extensionality 1 :hide? t)
           (expand "^")
           (expand "expt" 1 2)
           (propax))))
        ("2"
         (hide -1 2)
         (lemma "limit_scal")
         (replace -2 * rl)
         (hide -2)
         (inst?)
         (("1" (assert)) ("2" (hide 2) (rewrite "abs_x_to_n_conv"))))
        ("3" (propax))))
      ("2"
       (hide -1 2)
       (lemma "convergent_scal")
       (lemma "abs_x_to_n_conv")
       (inst?)
       (inst?)
       (assert))))
    ("2" (hide 2) (rewrite "abs_x_to_n_conv"))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "abs_x_to_n_conv")
   (inst?)
   (assert)
   (expand "convergent?")
   (skosimp*)
   (inst + "l!1")
   (case-replace "l!1 = 0")
   (("1"
     (expand "convergence")
     (skosimp*)
     (inst - "epsilon!1")
     (skosimp*)
     (inst + "n!1")
     (skosimp*)
     (inst?)
     (assert)
     (hide -1 -3)
     (case-replace "abs(x!1 ^ i!1) = abs(x!1)^i!1")
     (("1" (hide -1) (expand "abs") (lift-if) (ground))
      ("2" (hide -1 2) (rewrite "abs_hat_nat"))))
    ("2"
     (hide 2)
     (lemma "cnv_seq_abs_x_to_n")
     (inst?)
     (assert)
     (rewrite "limit_def")
     (lemma "unique_limit")
     (inst?)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "abs_x_to_n_conv")
   (inst?)
   (assert)
   (case "convergence(LAMBDA (n: nat): x!1 ^ n, 0)")
   (("1"
     (hide -2)
     (lemma "cnv_seq_scal")
     (inst?)
     (inst - "c!1")
     (assert)
     (hide -2)
     (case-replace
      "(c!1 * (LAMBDA (n: nat): x!1 ^ n), 0) = (LAMBDA (n: nat): c!1 * x!1 ^ n, 0)")
     (hide -1 2)
     (expand "*")
     (propax))
    ("2"
     (hide 2)
     (expand "convergent?")
     (skosimp*)
     (case-replace "l!1 = 0")
     (("1"
       (expand "convergence")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "n!1")
       (skosimp*)
       (inst?)
       (assert)
       (hide -1 -2 -4)
       (case-replace "abs(x!1 ^ i!1) = abs(x!1)^i!1")
       (("1" (hide -1) (expand "abs") (lift-if) (ground))
        ("2" (hide -1 2) (rewrite "abs_hat_nat"))))
      ("2"
       (hide 2)
       (lemma "cnv_seq_abs_x_to_n")
       (inst?)
       (assert)
       (rewrite "limit_def")
       (lemma "unique_limit")
       (inst?)
       (inst?)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (assert)
   (rewrite "sigma_scal_right" :dir rl)
   (lemma "sigma_split")
   (inst - "LAMBDA (i: nat): geometric(x)(i) * x" "n" "0" "n-1")
   (assert)
   (replace -1)
   (hide -1)
   (expand "sigma" + 3)
   (expand "sigma" + 3)
   (expand "geometric" + 3)
   (case "x ^ n * x = x^(1+n)")
   (("1"
     (replace -1)
     (hide -1)
     (assert)
     (lemma "sigma_split")
     (inst - "geometric(x)" "n" "0" "0")
     (assert)
     (replace -1)
     (hide -1)
     (expand "sigma" + 1)
     (expand "sigma" + 1)
     (expand "geometric" + 1)
     (expand "^" + 1)
     (expand "expt" + 1)
     (lemma "sigma_shift")
     (inst - "geometric(x)" "n-1" "0" "1")
     (assert)
     (replace -1)
     (hide -1)
     (case "(LAMBDA (n_1: nat): geometric(x)(1 + n_1)) = (LAMBDA (i: nat): geometric(x)(i) * x)")
     (("1" (assert))
      ("2"
       (hide 2)
       (decompose-equality)
       (expand "geometric")
       (expand "^")
       (expand "expt" + 1)
       (assert))))
    ("2" (hide 2) (expand "^") (expand "expt" + 2) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (case-replace
    "(LAMBDA (n: nat): sigma(0, n, geometric(x!1))) = (LAMBDA (n: nat): (1-x!1^(n+1))/(1-x!1))")
   (("1"
     (hide -1)
     (case-replace
      "(LAMBDA (n: nat): (1 - x!1 ^(n+1)) / (1 - x!1)) = (LAMBDA (n: nat): 1 / (1 - x!1)) - (LAMBDA (n: nat): x!1 ^(n+1) / (1 - x!1))")
     (("1"
       (hide -1)
       (lemma "cnv_seq_diff")
       (inst -1 "1/(1-x!1)" "0" "(LAMBDA (n: nat): 1/(1-x!1))"
        "(LAMBDA (n: nat): x!1^(n+1)/(1-x!1))")
       (("1"
         (assert)
         (hide 2)
         (lemma "cnv_seq_const")
         (inst -1 "1/(1-x!1)")
         (expand "const_fun")
         (replace -1)
         (assert)
         (hide -1)
         (lemma "cnv_seq_div")
         (inst -1 "0" "(1-x!1)" "(LAMBDA (n: nat): x!1^(n+1))"
          "(LAMBDA (n: nat): (1-x!1))")
         (expand "/" -1)
         (hide 2)
         (lemma "cnv_seq_const")
         (inst -1 "(1-x!1)")
         (expand "const_fun")
         (assert)
         (hide -1)
         (lemma "convergence_x_to_n")
         (inst?)
         (inst -1 "x!1")
         (assert)
         (expand "^")
         (expand "expt" 1)
         (propax))
        ("2" (hide 2) (grind))))
      ("2" (hide 2) (expand "-") (apply-extensionality 1 :hide? t))
      ("3" (hide 2) (grind))))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (lemma "sigma_geometric")
     (inst?)
     (assert))
    ("3" (hide 2) (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "geometric_series")
   (inst?)
   (assert)
   (lemma "cnv_seq_scal")
   (inst -1 "c!1" "1 / (1 - x!1)" "series(geometric(x!1))")
   (assert)
   (hide -2)
   (expand "*")
   (expand "series")
   (case-replace
    "(LAMBDA (n: nat):  sigma(0, n, LAMBDA (x: nat): c!1 * geometric(x!1)(x))) =(LAMBDA (x: nat): c!1 * sigma(0, x, geometric(x!1)))")
   (("1" (assert))
    ("2"
     (hide -1 2)
     (apply-extensionality :hide? t)
     (rewrite "sigma_scal")
     (assert)
     (case-replace
      "(LAMBDA (x: nat): geometric(x!1)(x)) = geometric(x!1)")
     (hide 2)
     (apply-extensionality 1 :hide? t))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "inf_sum")
   (rewrite "limit_def")
   (("1" (rewrite "geometric_series"))
    ("2"
     (hide 2)
     (expand "convergent?")
     (lemma "geometric_series")
     (inst?)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n1")
   (("1" (skosimp*) (assert) (expand "^") (expand "expt") (assert))
    ("2"
     (skosimp*)
     (inst?)
     (assert)
     (replace -2)
     (assert)
     (inst?)
     (lemma "both_sides_times_pos_le1")
     (inst -1 "rho!1" "abs(a!1(j!1))" "abs(a!1(0)) * rho!1 ^ j!1")
     (assert)
     (case-replace "rho!1 ^ (1 + j!1) = rho!1 ^ j!1 * rho!1")
     (("1" (assert))
      ("2"
       (hide -1 -3)
       (name-replace "T3" "abs(a!1(0)) * (rho!1 ^ j!1 * rho!1)")
       (name-replace "T2" "rho!1 * abs(a!1(j!1))")
       (assert)
       (hide -1 -2 -3 2)
       (expand "^")
       (expand "expt" 1 1)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "const_geometric_series")
   (inst -1 "abs(a!1(0))" "rho!1")
   (expand "abs" -1 1)
   (assert)
   (lemma "comparison_test")
   (inst -1 "a!1" "abs(a!1(0)) * geometric(rho!1)")
   (assert)
   (hide 2)
   (split +)
   (("1" (expand "convergent?") (inst?))
    ("2"
     (hide -1)
     (expand "geometric")
     (lemma "scaf_abs")
     (skosimp*)
     (expand "*")
     (inst?)
     (assert)
     (hide 2)
     (skosimp*)
     (inst -3 "n!2")
     (rewrite "abs_div")
     (("1"
       (lemma "both_sides_times_pos_le1")
       (inst -1 "abs(a!1(n!2))" "abs(a!1(1 + n!2)) / abs(a!1(n!2))"
        "rho!1")
       (("1" (assert)) ("2" (hide -2 -3 2) (inst?) (grind))
        ("3" (hide -2 -3 2) (inst?) (grind))))
      ("2" (hide -2 -3 2) (inst?))))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "tail_conv")
   (inst?)
   (name BB
         "(LAMBDA n: IF n < N!1 then a!1(N!1)/rho!1^(N!1-n)
                                                                                  ELSE a!1(n) ENDIF)")
   (inst - "BB")
   (assert)
   (hide 2)
   (split +)
   (("1"
     (lemma "ratio_test")
     (inst?)
     (assert)
     (hide 2)
     (split)
     (("1"
       (skosimp*)
       (replace -2 * rl)
       (assert)
       (hide -2)
       (lift-if)
       (split -1)
       (("1" (flatten) (hide -4 -5) (inst?) (assert))
        ("2" (flatten) (inst?) (assert))))
      ("2"
       (inst?)
       (assert)
       (skosimp*)
       (case "n!1 < N!1")
       (("1"
         (replace -2 * rl)
         (hide -2)
         (assert)
         (lift-if)
         (split 1)
         (("1"
           (flatten)
           (hide -3 -5)
           (expand "^")
           (expand "expt" 1 2)
           (grind))
          ("2"
           (flatten)
           (case-replace "n!1 = N!1-1")
           (("1" (assert) (hide -3 -5) (grind)) ("2" (assert))))))
        ("2"
         (assert)
         (inst -4 "n!1")
         (assert)
         (replace -1 * rl)
         (assert))))))
    ("2" (inst?) (skosimp*) (replace -2 * rl) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "tail_series_conv2")
   (inst?)
   (inst - "N!1")
   (assert)
   (hide 2)
   (lemma "ratio_test")
   (inst?)
   (assert)
   (prop)
   (("1" (skosimp*) (inst?) (assert))
    ("2"
     (hide 2)
     (inst + "rho!1")
     (assert)
     (skosimp*)
     (inst - "n!1 + N!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (name "LL" "limit(LAMBDA n: abs(a!1(n + 1) / a!1(n)))")
   (("1"
     (case "LL >= 0")
     (("1"
       (replace -2)
       (rewrite "limit_def")
       (hide -4)
       (lemma "ratio_test_gen")
       (inst?)
       (assert)
       (replace -3)
       (assert)
       (hide 2)
       (expand "convergence")
       (case "(EXISTS (nr: real): LL < nr AND nr < 1)")
       (("1"
         (skosimp*)
         (inst - "abs(nr!1)-LL")
         (("1"
           (skosimp*)
           (inst + "abs(nr!1)")
           (("1"
             (expand "abs" 1 1)
             (assert)
             (inst 1 "n!1")
             (skosimp*)
             (inst - "n!2")
             (assert)
             (hide -3 -6 2)
             (grind))
            ("2" (hide -4 -5) (grind))))
          ("2" (hide -3 -4 2) (grind))))
        ("2" (hide 2 3) (inst 1 "(1+LL)/2") (assert))))
      ("2"
       (hide -3 2)
       (lemma "limit_pos")
       (inst?)
       (split -1)
       (("1" (assert))
        ("2"
         (hide -1 -3 2)
         (skosimp*)
         (inst-cp -1 "n!1")
         (inst -1 "n!1+1")
         (grind)
         (lemma "div_eq_zero")
         (inst?)
         (assert))
        ("3" (reveal -2) (propax))))))
    ("2" (assert)) ("3" (propax))))


proof_type: t_proof
decl_type: tcc
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conv_series_terms_to_0")
   (inst?)
   (assert)
   (hide -2)
   (expand "convergent?")
   (inst?))


proof_type: t_proof
decl_type: tcc
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (lemma "conv_series_scal")
   (inst?)
   (inst - "c!1")
   (("1"
     (assert)
     (lemma "end_series_conv")
     (inst?)
     (assert)
     (rewrite "series_scal")
     (assert)
     (hide -1)
     (lemma "end_series_conv")
     (assert)
     (inst - "(LAMBDA n: c!1 * a!1(n))" "k!1")
     (assert)
     (expand "series")
     (expand "*")
     (propax))
    ("2"
     (assert)
     (flatten)
     (replace -1)
     (expand "*")
     (hide -)
     (lemma "end_series_conv")
     (inst?)
     (assert)
     (hide 2)
     (lemma "zero_series_conv")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "comparison_test_gen")
   (expand "conv_series?")
   (inst - "a!1" "b!1")
   (assert)
   (lemma "end_series_conv")
   (inst?)
   (assert)
   (split -2)
   (("1" (lemma "end_series_conv") (inst - "a!1" "m!1") (assert))
    ("2" (inst + "m!1") (skosimp*) (inst?))))


proof_type: t_proof
decl_type: tcc
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (lemma "convergent_abs")
   (inst - "a!1")
   (assert)
   (lemma "end_series_conv")
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (lemma "series_sum_convergence")
   (inst?)
   (expand "convergent?")
   (skosimp*)
   (inst 1 "l!1+l!2")
   (inst -1 "l!2" "l!1")
   (assert))


proof_type: t_proof
decl_type: tcc
library: series
theory: series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (lemma "geometric_series")
   (inst?)
   (expand "convergent?")
   (assert)
   (inst?))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "pn" 1)
   (("1" (grind)) ("2" (assert))
    ("3" (skosimp*) (expand "^") (expand "expt" 1) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "powerseries")
   (lemma "conv_series_terms_to_0")
   (inst?)
   (assert)
   (hide -2)
   (lemma "convergence_cauchy")
   (inst - "powerseq(a!1, x!1)")
   (flatten)
   (hide -2)
   (split -1)
   (("1"
     (hide -2)
     (lemma "cauchy_bounded")
     (inst?)
     (assert)
     (expand "bounded?")
     (propax))
    ("2" (expand "convergent?") (inst?))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conv_series_terms_to_0")
   (expand "powerseries")
   (inst?)
   (assert)
   (hide -2)
   (expand "convergence")
   (expand "absolutely_convergent_series?")
   (inst -1 "1")
   (skosimp*)
   (lemma "comparison_test_gen")
   (inst?)
   (assert)
   (inst -1 "geometric(abs(x!1/x1!1))")
   (assert)
   (hide 2)
   (split +)
   (("1"
     (lemma "geometric_series")
     (expand "convergent?")
     (inst?)
     (assert)
     (split -1)
     (("1" (hide -2) (inst?))
      ("2"
       (hide -1 2)
       (rewrite "abs_abs")
       (rewrite "abs_div")
       (lemma "div_mult_pos_lt1")
       (inst?)
       (assert))))
    ("2"
     (assert)
     (inst 1 "n!1")
     (skosimp*)
     (expand "powerseq")
     (expand "abs" 1 2)
     (rewrite "abs_abs")
     (expand "geometric")
     (inst?)
     (assert)
     (case-replace
      "abs(a!1(n!2) * x!1 ^ n!2) = abs(a!1(n!2) * x1!1 ^ n!2) * abs(x!1/x1!1)^n!2")
     (("1" (hide -1) (mult-by -2 "abs(x!1 / x1!1) ^ n!2") (assert))
      ("2"
       (hide 2)
       (case-replace "abs(x!1 / x1!1) ^ n!2 = abs((x!1 / x1!1) ^ n!2)")
       (("1"
         (rewrite "abs_mult" :dir rl)
         (assert)
         (hide -1 2)
         (expand "^")
         (rewrite "expt_of_div")
         (assert))
        ("2"
         (hide 2)
         (hide -2 -3)
         (name-replace "BBB" "(x!1 / x1!1)")
         (rewrite "abs_hat_nat"))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "powerseries_conv_point")
   (inst?)
   (("1"
     (expand "powerseries")
     (inst -1 "y!1")
     (assert)
     (expand "absolutely_convergent_series?")
     (lemma "convergent_abs")
     (inst -1 "powerseq(a!1,y!1)")
     (assert))
    ("2" (hide -1 2) (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "divergent_series?")
   (lemma "powerseries_conv_point")
   (inst?)
   (inst?)
   (("1"
     (assert)
     (expand "powerseries")
     (expand "absolutely_convergent_series?")
     (hide -3)
     (lemma "convergent_abs")
     (inst -1 "powerseq(a!1, x1!1)")
     (assert))
    ("2" (assert) (hide -2 2) (typepred "x1!1") (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "powerseries")
   (expand "powerseq")
   (lemma "tail_series_conv2")
   (inst?)
   (inst -1 "1")
   (assert)
   (hide 2)
   (lemma "zero_series_conv")
   (case-replace "(LAMBDA n: 0) = (LAMBDA n: a!1(1 + n) * 0 ^ (1 + n))")
   (hide -1 2)
   (apply-extensionality 1 :hide? t)
   (grind))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series_convergent_only_at_0")
   (expand "series_convergent_within")
   (expand "divergent_series?")
   (split 2)
   (("1"
     (hide 2 3)
     (lemma "zero_powerseries_conv")
     (inst?)
     (expand "powerseries")
     (propax))
    ("2"
     (skosimp*)
     (case "abs(x!1) < abs(x!2)")
     (("1"
       (lemma "powerseries_conv")
       (inst -1 "a!1" "x!2" "x!1")
       (expand "powerseries")
       (assert))
      ("2"
       (lemma "real_complete")
       (inst -1 "{x: real | convergent?(series(powerseq(a!1, x)))}")
       (("1"
         (split -1)
         (("1"
           (skosimp*)
           (name-replace "LUB" "y!1")
           (lemma "real_lower_complete")
           (inst -1 "{x: real | convergent?(series(powerseq(a!1, x)))}")
           (("1"
             (split -1)
             (("1"
               (skosimp*)
               (name-replace "GLB" "x!3")
               (case "LUB >= 0")
               (("1"
                 (case "GLB <= 0")
                 (("1"
                   (case "abs(GLB) = abs(LUB)")
                   (("1"
                     (inst 4 "abs(LUB)")
                     (("1"
                       (split 4)
                       (("1"
                         (skosimp*)
                         (case "x!4 >= 0")
                         (("1"
                           (expand "least_upper_bound?")
                           (flatten)
                           (inst -8 "x!4")
                           (split -8)
                           (("1" (hide -4 -7 -8 -9 1 4) (grind))
                            ("2"
                             (expand "upper_bound?")
                             (skosimp*)
                             (typepred "s!1")
                             (lemma "powerseries_conv")
                             (inst -1 "a!1" "s!1" "x!4")
                             (assert)
                             (expand "powerseries")
                             (hide -1 -4 -7 -8 -9 3 6)
                             (grind))))
                          ("2"
                           (expand "greatest_lower_bound?")
                           (flatten)
                           (inst -6 "x!4")
                           (split -6)
                           (("1" (hide -6 -7 -8 2 5) (grind))
                            ("2"
                             (expand "lower_bound?")
                             (skosimp*)
                             (typepred "s!1")
                             (lemma "powerseries_conv")
                             (inst -1 "a!1" "s!1" "x!4")
                             (assert)
                             (expand "powerseries")
                             (hide -1 -6 -7 -8 4 7)
                             (grind))))))
                        ("2"
                         (expand "series_divergent_outside")
                         (expand "abs" 1 1)
                         (skosimp*)
                         (lift-if)
                         (split -1)
                         (("1"
                           (flatten)
                           (expand "greatest_lower_bound?")
                           (flatten)
                           (expand "lower_bound?")
                           (inst -6 "x!4")
                           (("1" (hide -7 -8 -9 1 4) (grind))
                            ("2" (expand "divergent_series?") (propax))))
                          ("2"
                           (flatten)
                           (expand "divergent_series?")
                           (expand "least_upper_bound?")
                           (flatten)
                           (hide -6 -8)
                           (expand "upper_bound?")
                           (inst -6 "x!4")
                           (hide -2 -7 3)
                           (grind))))))
                      ("2"
                       (expand "abs" 1)
                       (assert)
                       (case-replace "LUB = 0")
                       (("1"
                         (expand "least_upper_bound?")
                         (flatten)
                         (expand "upper_bound?")
                         (inst -6 "x!2")
                         (assert)
                         (expand "greatest_lower_bound?")
                         (flatten)
                         (expand "lower_bound?")
                         (inst -5 "x!2")
                         (expand "abs" -2)
                         (assert))
                        ("2" (assert))))))
                    ("2"
                     (hide 5)
                     (case "abs(GLB) > abs(LUB)")
                     (("1"
                       (name "WW" "abs(LUB) + (abs(GLB) - abs(LUB))/2")
                       (case "convergent?(powerseries(a!1)(WW))")
                       (("1"
                         (expand "least_upper_bound?")
                         (flatten)
                         (expand "upper_bound?")
                         (inst -7 "WW")
                         (("1" (hide -1 -6 -8 -9 4) (grind))
                          ("2" (expand "powerseries") (propax))))
                        ("2"
                         (expand "greatest_lower_bound?")
                         (flatten)
                         (expand "lower_bound?")
                         (inst -6 "-WW")
                         (split -6)
                         (("1" (hide -6 -7 -8 1 5) (grind))
                          ("2"
                           (skosimp*)
                           (typepred "s!1")
                           (lemma "powerseries_conv")
                           (inst -1 "a!1" "s!1" "WW")
                           (expand "powerseries")
                           (assert)
                           (hide -1 -6 -7 -8 3 7)
                           (grind))))))
                      ("2"
                       (name "WW" "abs(GLB) + (abs(LUB) - abs(GLB))/2")
                       (case "convergent?(powerseries(a!1)(-WW))")
                       (("1"
                         (expand "greatest_lower_bound?")
                         (flatten)
                         (hide -6)
                         (expand "lower_bound?")
                         (expand "powerseries")
                         (inst -5 "-WW")
                         (hide -1 -6 -7 5)
                         (grind))
                        ("2"
                         (expand "least_upper_bound?")
                         (flatten)
                         (inst -6 "WW")
                         (split -6)
                         (("1" (hide -5 -6 -7 1 6) (grind))
                          ("2"
                           (expand "upper_bound?")
                           (skosimp*)
                           (typepred "s!1")
                           (lemma "powerseries_conv")
                           (inst -1 "a!1" "s!1" "-WW")
                           (assert)
                           (expand "powerseries")
                           (hide -1 -5 -6 -7 3 8)
                           (grind))))))))))
                  ("2"
                   (hide -4 4 5)
                   (lemma "zero_powerseries_conv")
                   (inst?)
                   (expand "greatest_lower_bound?")
                   (flatten)
                   (expand "lower_bound?")
                   (inst -3 "0")
                   (expand "powerseries")
                   (propax))))
                ("2"
                 (lemma "zero_powerseries_conv")
                 (inst?)
                 (hide -2 -4 4 5)
                 (expand "least_upper_bound?")
                 (flatten)
                 (expand "upper_bound?")
                 (inst -2 "0")
                 (("1" (assert))
                  ("2" (expand "powerseries") (propax))))))
              ("2"
               (hide -1 5)
               (inst 1 "-abs(x!1)")
               (expand "lower_bound?")
               (skosimp*)
               (lemma "powerseries_diverg")
               (inst -1 "a!1" "s!1" "x!1")
               (("1"
                 (expand "divergent_series?")
                 (expand "powerseries")
                 (assert)
                 (hide -1 5)
                 (grind))
                ("2"
                 (case-replace "x!1 = 0")
                 (("1" (lemma "zero_powerseries_conv") (inst?))
                  ("2" (assert))))))))
            ("2"
             (expand "nonempty?")
             (expand "empty?")
             (expand "member")
             (inst - "x!2"))))
          ("2"
           (inst 1 "abs(x!1)")
           (expand "upper_bound?")
           (skosimp*)
           (lemma "powerseries_diverg")
           (inst -1 "a!1" "s!1" "x!1")
           (("1"
             (expand "powerseries")
             (expand "divergent_series?")
             (assert)
             (hide -1 5 6)
             (grind))
            ("2"
             (case-replace "x!1 = 0")
             (("1" (lemma "zero_powerseries_conv") (inst?))
              ("2" (assert))))))))
        ("2"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst -1 "x!2"))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "powerseries_conv_point")
   (expand "absolutely_convergent_series?")
   (inst?)
   (name "AA" "abs(x!1) + (abs(c!1) - abs(x!1))/2")
   (inst - "AA")
   (("1"
     (inst - "AA")
     (("1"
       (expand "powerseries")
       (assert)
       (hide -2 2)
       (replace -1 * rl)
       (hide -1)
       (typepred "x!1")
       (grind))
      ("2"
       (hide -2 2)
       (replace -1 * rl)
       (hide -1)
       (typepred "x!1")
       (grind))))
    ("2"
     (hide -2 2)
     (replace -1 * rl)
     (hide -1)
     (typepred "x!1")
     (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "apowerseq")
   (expand "powerseq")
   (apply-extensionality 1 :hide? t)
   (lift-if)
   (ground)
   (replace -1)
   (expand "^")
   (expand "expt")
   (propax))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "end_series_conv")
   (expand "conv_powerseries?")
   (expand "powerseries")
   (split +)
   (("1" (ground) (skosimp*) (inst?) (inst?) (assert))
    ("2" (flatten) (skosimp*) (inst?) (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality 1 :hide? t)
   (("1"
     (expand "Inf_sum")
     (expand "powerseries")
     (expand "inf_sum")
     (propax))
    ("2"
     (skosimp*)
     (expand "conv_powerseries?")
     (expand "conv_series?")
     (expand "powerseries")
     (inst?))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "Inf_sum")
   (apply-extensionality 1 :hide? t)
   (("1" (expand "inf_sum") (expand "powerseries") (propax))
    ("2"
     (skosimp*)
     (expand "conv_powerseries?")
     (expand "powerseries")
     (expand "conv_series?")
     (inst?))
    ("3" (skosimp*) (expand "conv_powerseries?") (inst?))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "EXISTS (y:T): abs(y) > abs(x!1)")
   (("1"
     (skosimp*)
     (lemma "powerseries_conv_point")
     (expand "absolutely_convergent_series?")
     (inst?)
     (assert)
     (inst -1 "y!1")
     (("1" (assert) (inst -2 "y!1")) ("2" (assert) (hide -2 2) (grind))))
    ("2"
     (hide -1 2)
     (case "x!1 >= 0")
     (("1"
       (lemma "open")
       (inst -1 "x!1")
       (skosimp*)
       (inst + "x!1 + delta!1/2")
       (("1" (hide -1) (grind)) ("2" (inst?) (assert) (hide 1) (grind))))
      ("2"
       (lemma "open")
       (inst -1 "x!1")
       (skosimp*)
       (inst + "x!1 - delta!1/2")
       (("1" (hide -1) (grind)) ("2" (inst?) (assert) (grind))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "simple")
   (flatten)
   (lemma "tail_series_conv2")
   (inst -1 "1" "_")
   (inst?)
   (assert)
   (hide 2)
   (expand "series")
   (expand "^")
   (expand "expt")
   (assert)
   (expand "convergent?")
   (inst 1 "0")
   (expand "convergence")
   (skosimp*)
   (inst 1 "100")
   (skosimp*)
   (assert)
   (case-replace
    "(LAMBDA (n_1962: nat):
                        0 * expt(0, n_1962) / factorial(1 + n_1962)) = (LAMBDA n: 0)")
   (("1" (rewrite "sigma_const") (expand "abs") (assert))
    ("2" (hide 2) (apply-extensionality 1 :hide? t))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "x!1 = 0")
   (("1" (rewrite "simple_0_conv"))
    ("2"
     (lemma "ratio_test_gen")
     (inst?)
     (assert)
     (hide 3)
     (split +)
     (("1"
       (skosimp*)
       (expand "simple")
       (rewrite "div_eq_zero")
       (assert)
       (expand "^")
       (lemma "expt_nonzero_aux")
       (inst?)
       (assert))
      ("2"
       (inst + "1/2")
       (assert)
       (inst + "floor(abs(2*x!1))")
       (skosimp*)
       (case-replace
        "simple(x!1)(1 + n!1) / simple(x!1)(n!1) = x!1/(1+n!1)")
       (("1"
         (hide -1)
         (typepred "floor(abs(2 * x!1))")
         (hide -1)
         (case "n!1 > abs(2 * x!1) - 1")
         (("1"
           (hide -2 -3 -4)
           (rewrite "abs_div")
           (expand "abs" 1 2)
           (lemma "both_sides_div_pos_le1")
           (inst -1 "1+n!1" "abs(x!1)" "1/2*(1+n!1)")
           (flatten)
           (hide -1)
           (case-replace "1 / 2 * (1 + n!1) / (1 + n!1) = 1/2")
           (("1"
             (split -2)
             (("1" (assert))
              ("2"
               (hide -1 2)
               (lemma "both_sides_times_pos_le1")
               (inst -1 "2" "abs(x!1)" "1 / 2 * (1 + n!1)")
               (flatten)
               (hide -2)
               (split -1)
               (("1" (propax))
                ("2"
                 (hide 2)
                 (case-replace "1 / 2 * (1 + n!1) * 2 = 1+n!1")
                 (("1"
                   (hide -1)
                   (rewrite "abs_mult")
                   (expand "abs" -1 1)
                   (assert))
                  ("2" (hide 2) (assert))))))))
            ("2"
             (hide -1 -2 2)
             (name-replace "NN" "(1 + n!1)")
             (assert))))
          ("2" (assert))))
        ("2"
         (hide -1 2)
         (expand "simple")
         (case "(forall (a: real),(b,c,d: nzreal): (a/b)/(c/d) = (a/c)/(b/d))")
         (("1"
           (inst?)
           (("1"
             (replace -1)
             (hide -1)
             (case-replace "(x!1 ^ (1 + n!1)) / x!1 ^ n!1 = x!1")
             (("1"
               (case-replace
                "(factorial(1 + n!1) / factorial(n!1)) = 1 + n!1")
               (hide 2)
               (expand "factorial" 1 1)
               (assert))
              ("2" (hide 2) (expand "^") (expand "expt" 1 1) (assert))))
            ("2"
             (hide 2)
             (expand "^")
             (lemma "expt_nonzero_aux")
             (inst?)
             (assert))))
          ("2" (hide 2 3) (skosimp*) (assert))))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "powerseries")
   (expand "powerseq")
   (lemma "geometric_conv")
   (expand "geometric")
   (inst - "-x!1")
   (rewrite "abs_neg")
   (assert)
   (case-replace
    "(LAMBDA (k: nat): (-1) ^ k * x!1 ^ k) = (LAMBDA n: (-x!1) ^ n)")
   (hide -1 2)
   (apply-extensionality 1 :hide? t)
   (lemma "mult_expt")
   (inst?)
   (("1" (assert))
    ("2"
     (flatten)
     (replace -1)
     (typepred "x!2")
     (case-replace "x!2 = 0")
     (("1" (assert)) ("2" (assert) (grind))))))


proof_type: t_proof
decl_type: tcc
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (expand "conv_powerseries?")
   (inst?)
   (expand "powerseries")
   (propax))


proof_type: t_proof
decl_type: tcc
library: series
theory: power_series_conv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (expand "conv_powerseries?")
   (expand "powerseries")
   (inst?))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_powerseries?")
   (case-replace "x!1 = 0")
   (("1"
     (case-replace
      "deriv_powerseq(a!1, 0) = (LAMBDA n: IF n = 1 THEN a!1(1) ELSE 0 ENDIF)")
     (("1"
       (hide -1)
       (lemma "tail_series_conv2")
       (inst?)
       (inst - "2")
       (assert)
       (hide 2)
       (rewrite "zero_series_conv"))
      ("2"
       (hide 2)
       (expand "deriv_powerseq")
       (apply-extensionality 1 :hide? t)
       (("1"
         (lift-if)
         (ground)
         (lemma "zero_hat")
         (hide -3)
         (inst?)
         (replace -1)
         (assert))
        ("2" (skosimp*) (assert))))))
    ("2"
     (case "(EXISTS (y:T): abs(x!1) < y)")
     (("1"
       (skosimp*)
       (case "abs(y!1) > 0")
       (("1"
         (inst - "y!1")
         (lemma "powerseries_bounded")
         (inst?)
         (assert)
         (rewrite "bounded?_lem")
         (skosimp*)
         (lemma "comparison_test")
         (name "BS"
               "(LAMBDA n: IF n = 0 THEN 0 ELSE n*B!1/abs(y!1)*abs(x!1/y!1)^(n-1) ENDIF)")
         (("1"
           (inst - "deriv_powerseq(a!1, x!1)" "BS")
           (assert)
           (hide 3)
           (prop)
           (("1"
             (case-replace "B!1 = 0")
             (("1"
               (case-replace "BS = (LAMBDA n: 0)")
               (("1" (rewrite "zero_series_conv"))
                ("2"
                 (replace -2 * rl)
                 (apply-extensionality 1 :hide? t)
                 (("1" (lift-if) (ground)) ("2" (skosimp*) (assert))))))
              ("2"
               (case "(EXISTS (NN: posnat): (NN+1)/NN*abs(x!1/y!1) < 1)")
               (("1"
                 (skosimp*)
                 (lemma "ratio_test_gt_N")
                 (inst?)
                 (assert)
                 (hide 3)
                 (inst + "NN!1")
                 (inst + "(NN!1 + 1) / NN!1 * abs(x!1 / y!1)")
                 (("1"
                   (assert)
                   (skosimp*)
                   (case "BS(n!1) /= 0")
                   (("1"
                     (assert)
                     (flatten)
                     (name "RR" "abs(x!1/y!1)")
                     (replace -1)
                     (case "RR < 1")
                     (("1"
                       (case-replace
                        "BS(1 + n!1) / BS(n!1) = (n!1+1)/n!1* RR")
                       (("1"
                         (rewrite "abs_mult")
                         (case-replace "abs(RR) = RR")
                         (("1"
                           (rewrite "abs_div")
                           (rewrite "abs_div")
                           (expand "abs" 2)
                           (field 2))
                          ("2" (replace -3 * rl) (rewrite "abs_abs"))))
                        ("2"
                         (hide 3)
                         (replace -5 * rl)
                         (assert)
                         (assert)
                         (case-replace "RR ^ n!1 = RR*RR ^ (n!1-1)")
                         (("1"
                           (name-replace "RRnm1" "RR ^ (n!1 - 1)")
                           (field 2))
                          ("2"
                           (hide 2 3)
                           (hide-all-but 1)
                           (expand "^")
                           (expand "expt" 1 1)
                           (propax))))))
                      ("2"
                       (hide-all-but (-1 -6 -7 1))
                       (rewrite "abs_div")
                       (assert)
                       (expand "abs" -1 2)
                       (replace -1 * rl)
                       (cross-mult 1)
                       (assert))))
                    ("2"
                     (assert)
                     (flatten)
                     (replace -4 * rl)
                     (assert)
                     (hide -4)
                     (mult-cases -1)
                     (("1"
                       (typepred "B!1")
                       (case-replace "B!1 = 0")
                       (reveal 4)
                       (field -2))
                      ("2"
                       (lemma "expt_pos")
                       (inst?)
                       (("1" (assert))
                        ("2"
                         (rewrite "abs_div")
                         (expand "abs" 1 2)
                         (cross-mult 1)
                         (assert)
                         (lemma "abs_eq_0")
                         (inst?)
                         (assert))))))))
                  ("2"
                   (mult-cases 1)
                   (rewrite "abs_div")
                   (expand "abs" 1 2)
                   (cross-mult 1)
                   (assert)
                   (lemma "abs_eq_0")
                   (inst?)
                   (assert))))
                ("2"
                 (hide -1 -2 -5 3)
                 (case "EXISTS (NBIG: posnat): NBIG > abs(x!1)/(y!1 - abs(x!1))")
                 (("1"
                   (skosimp*)
                   (inst + "NBIG!1")
                   (rewrite "abs_div")
                   (cross-mult -1)
                   (cross-mult 1)
                   (assert)
                   (expand "abs" 1 3)
                   (assert))
                  ("2"
                   (hide 2)
                   (inst + "ceiling(abs(x!1) / (y!1 - abs(x!1)))+1")
                   (("1" (assert))
                    ("2"
                     (assert)
                     (case-replace "(abs(x!1) / (y!1 - abs(x!1))) > 0")
                     (("1" (assert))
                      ("2"
                       (hide 2)
                       (cross-mult 1)
                       (assert)
                       (lemma "abs_eq_0")
                       (inst?)
                       (assert))))))))))))
            ("2"
             (skosimp*)
             (replace -1 * rl)
             (hide -1)
             (assert)
             (expand "deriv_powerseq")
             (lift-if)
             (ground)
             (("1" (rewrite "abs_0") (assert))
              ("2"
               (inst?)
               (replace -1)
               (expand "powerseq")
               (assert)
               (rewrite "abs_mult")
               (cross-mult 1)
               (assert))
              ("3"
               (expand "powerseq")
               (inst - "n!1")
               (rewrite "abs_mult")
               (hide -4)
               (expand "abs" 2 2)
               (rewrite "abs_mult")
               (assert)
               (rewrite "abs_mult" -)
               (rewrite "exponentiation.abs_expt")
               (rewrite "div_expt")
               (rewrite "abs_div")
               (div-by -1 "abs(y!1 ^ n!1)")
               (("1"
                 (case-replace
                  "abs(y!1 ^ n!1) = abs(y!1)*abs(y!1 ^(n!1-1))")
                 (("1"
                   (hide -1)
                   (mult-by -1 "abs(x!1 ^ (n!1 - 1)) * n!1")
                   (assert))
                  ("2"
                   (hide-all-but 1)
                   (expand "^")
                   (expand "expt" 1 1)
                   (rewrite "abs_mult"))))
                ("2"
                 (hide -1 -3 3)
                 (lemma "exponentiation.abs_expt")
                 (inst?)
                 (assert)
                 (replace -1 * rl)
                 (hide -1)
                 (rewrite "expt_pos"))))))))
          ("2" (skosimp*) (assert))))
        ("2" (assert))))
      ("2"
       (hide -1 3)
       (lemma "open")
       (case "x!1 >= 0")
       (("1"
         (expand "abs")
         (assert)
         (inst?)
         (skosimp*)
         (inst + "x!1 + delta!1/2")
         (("1" (assert)) ("2" (inst?) (assert))))
        ("2"
         (expand "abs")
         (assert)
         (inst - "-x!1")
         (("1"
           (skosimp*)
           (inst + "-x!1 + delta!1/2")
           (("1" (assert)) ("2" (inst?) (assert))))
          ("2" (lemma "ball") (inst?) (assert))))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_powerseries_conv")
   (inst?)
   (replace -2)
   (assert)
   (inst?)
   (lemma "tail_series_conv")
   (inst?)
   (inst -1 "1")
   (assert)
   (hide -2)
   (case-replace
    "powerseq(derivseq(a!1), x!1) = (LAMBDA n: deriv_powerseq(a!1, x!1)(1 + n))")
   (hide =1 2)
   (expand "powerseq")
   (apply-extensionality 1 :hide? t)
   (expand "derivseq")
   (expand "deriv_powerseq")
   (lift-if)
   (ground)
   (replace -1)
   (hide -2 -3)
   (grind))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: we
script:
  (""
   (skosimp*)
   (expand "powerseq")
   (expand "derivseq")
   (expand "deriv_powerseq")
   (lemma "limit_series_shift")
   (inst?)
   (("1"
     (inst -1 "1")
     (split -1)
     (("1"
       (rewrite "sigma_rew")
       (("1"
         (assert)
         (case-replace
          "(LAMBDA (k: nat):
                                      IF k = 0 THEN 1 * a!1(1)
                                      ELSE a!1(1 + k) * x!1 ^ k + k * a!1(1 + k) * x!1 ^ k
                                      ENDIF) = ((LAMBDA n:
                                      a!1(1 + n) * x!1 ^ n + n * a!1(1 + n) * x!1 ^ n))")
         (assert)
         (hide 2)
         (apply-extensionality 1 :hide? t)
         (lift-if)
         (ground)
         (hide -2 -3)
         (replace -1)
         (grind))
        ("2"
         (hide 2)
         (assert)
         (lemma "deriv_powerseries_conv")
         (skosimp*)
         (assert))))
      ("2"
       (hide 2)
       (assert)
       (lemma "deriv_powerseries_conv")
       (inst?)
       (replace -2)
       (assert)
       (inst - "x!1")
       (expand "deriv_powerseq")
       (propax))))
    ("2" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_powerseries?")
   (skosimp*)
   (lemma "derivseq_conv")
   (inst?)
   (expand "conv_powerseries?")
   (inst?)
   (replace -2)
   (expand "powerseries")
   (propax))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "powerseq")
   (case-replace "n!1 = 0")
   (("1"
     (expand "deriv_powerseq")
     (split +)
     (("1"
       (lemma "const_derivable_fun[T]")
       (expand "const_fun")
       (assert)
       (inst?))
      ("2"
       (assert)
       (lemma "deriv_const_fun[T]")
       (expand "const_fun")
       (inst?))))
    ("2"
     (lemma "deriv_exp_fun[T]")
     (inst -1 "(LAMBDA x: x)" "n!1")
     (assert)
     (split -1)
     (("1"
       (flatten)
       (split)
       (("1"
         (expand "^" -1)
         (hide -2)
         (lemma "scal_derivable_fun[T]")
         (inst -1 "a!1(n!1)" "(LAMBDA t: t^n!1)")
         (expand "*")
         (assert)
         (lemma "deriv_scal_fun[T]")
         (inst -1 "a!1(n!1)" "(LAMBDA x: x^n!1)")
         (expand "*" -1)
         (hide -1)
         (expand "^" -2)
         (hide -2)
         (case-replace "deriv((LAMBDA x: x)) = const_fun(1)")
         (("1" (expand "restrict") (propax))
          ("2" (expand "restrict") (propax))
          ("3" (expand "restrict") (propax))))
        ("2"
         (expand "deriv_powerseq")
         (lemma "deriv_scal_fun[T]")
         (inst -1 "a!1(n!1)" "(LAMBDA x: x^n!1)")
         (("1"
           (expand "*" -1)
           (replace -1)
           (hide -1)
           (assert)
           (expand "^" -2)
           (replace -2)
           (hide -2)
           (expand "*")
           (case-replace "deriv((LAMBDA x: x)) = const_fun(1)")
           (("1"
             (expand "const_fun")
             (hide -1 -2)
             (ground)
             (apply-extensionality 1 :hide? t)
             (lift-if)
             (ground)
             (replace -1)
             (assert))
            ("2"
             (hide -1 2 3)
             (lemma "deriv_id_fun[T]")
             (expand "const_fun")
             (propax))
            ("3"
             (hide 2)
             (lemma "identity_derivable_fun[T]")
             (expand "I")
             (propax))))
          ("2"
           (hide 2)
           (lemma "identity_derivable_fun[T]")
           (expand "I")
           (expand "^" -2)
           (propax))))))
      ("2"
       (hide 3)
       (lemma "identity_derivable_fun[T]")
       (expand "I")
       (propax))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skosimp*)
     (expand "sigma")
     (expand "sigma")
     (expand "powerseq")
     (expand "^")
     (expand "expt")
     (lemma "const_derivable_fun[T]")
     (inst -1 "a!1(0)")
     (expand "const_fun")
     (propax))
    ("2"
     (skosimp*)
     (expand "sigma" 1)
     (lemma "sum_derivable_fun[T]")
     (inst -1
      "(LAMBDA x:                       powerseq(a!1, x)(1 + j!1))"
      "(LAMBDA x:                       sigma(0, j!1, powerseq(a!1, x)))")
     (expand "+" -1)
     (assert)
     (hide 2)
     (inst?)
     (assert)
     (hide -1)
     (lemma "deriv_powerseq_lem")
     (inst?)
     (flatten))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n" 1)
   (("1"
     (skosimp*)
     (expand "sigma")
     (expand "sigma")
     (expand "powerseq")
     (expand "deriv_powerseq")
     (expand "^")
     (expand "expt")
     (lemma "deriv_const_fun[T]")
     (expand "const_fun")
     (inst?))
    ("2"
     (skosimp*)
     (expand "sigma" 1)
     (lemma "deriv_sum_fun[T]")
     (inst -1
      "(LAMBDA x:                        powerseq(a!1, x)(1 + j!1))"
      "(LAMBDA x:                        sigma(0, j!1, powerseq(a!1, x)))")
     (("1"
       (expand "+" -1)
       (replace -1)
       (hide -1)
       (apply-extensionality 1 :hide? t)
       (("1"
         (inst?)
         (replace -1)
         (hide -1)
         (lemma "deriv_powerseq_lem")
         (inst?)
         (flatten)
         (replace -2)
         (hide -2)
         (expand "deriv_powerseq")
         (propax))
        ("2" (hide -1) (skosimp*) (rewrite "sigma_power_derivable"))
        ("3"
         (skosimp*)
         (hide -1)
         (lemma "deriv_powerseq_lem")
         (inst?)
         (flatten))))
      ("2" (hide -1 2) (rewrite "sigma_power_derivable"))
      ("3" (hide -1 2) (lemma "deriv_powerseq_lem") (inst?) (flatten))))
    ("3" (hide 2) (skosimp*) (rewrite "sigma_power_derivable"))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_powerseries_conv")
   (inst?)
   (replace -2)
   (assert)
   (inst -1 "x1!1")
   (lemma "deriv_sigma_power")
   (inst?)
   (case-replace
    "(LAMBDA (n: nat):
                             deriv(LAMBDA x: sigma(0, n, powerseq(a!1, x)))(x1!1)) =
                                (LAMBDA (n: nat):
                             (LAMBDA x: sigma(0, n, deriv_powerseq(a!1, x)))(x1!1))")
   (("1"
     (hide -1 -2)
     (expand "deriv_powerseq")
     (assert)
     (expand "series")
     (propax))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (("1"
       (inst?)
       (assert)
       (replace -1)
       (hide -1 -2)
       (expand "sigma")
       (propax))
      ("2" (hide -1 -2 2) (skosimp*) (rewrite "sigma_power_derivable"))))
    ("3" (hide -1 -2 2) (skosimp*) (rewrite "sigma_power_derivable"))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_powerseries_conv")
   (inst?)
   (replace -2)
   (assert)
   (expand "deriv_powerseq")
   (inst?)
   (expand "series")
   (propax))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (expand "sigma")
     (expand "deriv_powerseq")
     (expand "sigma")
     (skosimp*)
     (lemma "const_fun_continuous[T]")
     (expand "const_fun")
     (inst?))
    ("2"
     (skosimp*)
     (expand "sigma" 1)
     (lemma "sum_fun_continuous[T]")
     (inst -1
      "(LAMBDA x:                        deriv_powerseq(a!1, x)(1 + j!1))"
      "(LAMBDA x: sigma(0, j!1, deriv_powerseq(a!1, x)))")
     (("1" (expand "+" -1) (propax)) ("2" (hide 2) (inst?))
      ("3"
       (hide 2)
       (hide -1)
       (name-replace "J1" "j!1+1")
       (expand "deriv_powerseq")
       (case "J1 > 0")
       (("1"
         (assert)
         (lemma "prod_fun_continuous[T]")
         (inst -1 "(LAMBDA x: a!1(J1)*J1)" "(LAMBDA x: x ^ (J1-1))")
         (("1"
           (ground)
           (lemma "const_fun_continuous[T]")
           (expand "const_fun")
           (inst?)
           (expand "*")
           (case-replace
            "(LAMBDA x:
                                       IF J1 = 1 THEN a!1(1) ELSE a!1(J1) * x ^ (J1 - 1) * J1 ENDIF) = (LAMBDA (x_1: T): a!1(J1) * x_1 ^ (J1 - 1) * J1)")
           (hide 2)
           (apply-extensionality 1 :hide? t)
           (lift-if)
           (ground)
           (replace -1)
           (assert))
          ("2" (hide 2) (lemma "x_to_n_continuous[T]") (inst?))
          ("3"
           (lemma "const_fun_continuous[T]")
           (expand "const_fun")
           (inst?))))
        ("2" (hide 2) (reveal -1) (assert))))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "series")
   (case-replace
    "(LAMBDA (n: nat): sigma(0, n, deriv_powerseq(a!1, x!1))) =
             (LAMBDA (n: nat): sigma(1, n, deriv_powerseq(a!1, x!1)))")
   (hide 2)
   (apply-extensionality 1 :hide? t)
   (lemma "sigma_first")
   (inst?)
   (assert)
   (case "x!2 = 0")
   (("1"
     (replace -1)
     (expand "sigma")
     (expand "deriv_powerseq")
     (propax))
    ("2"
     (assert)
     (replace -1)
     (hide -1)
     (expand "deriv_powerseq")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "connected_domain")
   (lemma "connected_deriv_domain[T]")
   (lemma "not_one_element")
   (assert))


proof_type: t_proof
decl_type: tcc
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_powerseries_conv")
   (inst?)
   (replace -2)
   (assert)
   (expand "deriv_powerseq")
   (inst?))


proof_type: t_proof
decl_type: tcc
library: series
theory: power_series_derivseq
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_powerseries_conv")
   (inst?)
   (assert)
   (inst?)
   (lemma "end_series_conv")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "connected_domain")
   (lemma "not_one_element")
   (lemma "connected_deriv_domain[T]")
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "nonempty?")
   (expand "empty?")
   (expand "member")
   (lemma "mean_value[T]")
   (("1"
     (inst - "x!1" "x!1 + h!1" "(LAMBDA (x:T): x^k!1)")
     (("1"
       (assert)
       (lemma "deriv_x_to_n[T]")
       (("1"
         (inst - "k!1" "1")
         (assert)
         (flatten)
         (assert)
         (split -3)
         (("1"
           (skosimp*)
           (inst -6 "c!1")
           (("1"
             (assert)
             (case-replace
              "(LAMBDA (x: T): 1 * x ^ k!1) = (LAMBDA (x: T): x ^ k!1)")
             (("1"
               (hide -1)
               (case "deriv(LAMBDA (x: T): x ^ k!1)(c!1) =
                                               (LAMBDA (x: T): x ^ (k!1 - 1) * k!1)(c!1)")
               (("1" (expand "deriv" -1) (replace -1) (assert))
                ("2" (hide 2) (assert) (replace -5) (assert))))
              ("2" (apply-extensionality 1 :hide? t))))
            ("2" (assert))))
          ("2"
           (assert)
           (lemma "mean_value[T]")
           (inst - "x!1+h!1" "x!1" "(LAMBDA (x:T): x^k!1)")
           (("1"
             (assert)
             (skosimp*)
             (inst -6 "c!1")
             (("1"
               (assert)
               (case-replace
                "(LAMBDA (x: T): 1 * x ^ k!1) = (LAMBDA (x: T): x ^ k!1)")
               (("1"
                 (hide -1)
                 (case "deriv(LAMBDA (x: T): x ^ k!1)(c!1) =
                                                                  (LAMBDA (x: T): x ^ (k!1 - 1) * k!1)(c!1)")
                 (("1" (expand "deriv" -1) (replace -1) (assert))
                  ("2" (hide 2) (assert) (replace -5) (assert))))
                ("2" (apply-extensionality 1 :hide? t))))
              ("2" (assert))))
            ("2" (typepred "h!1") (expand "A") (propax))))))
        ("2" (lemma "deriv_domain[T]") (propax))))
      ("2" (assert) (typepred "h!1") (expand "A") (propax))))
    ("2" (lemma "not_one_element") (propax))
    ("3" (lemma "connected_domain") (propax))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conv_series_shift")
   (inst?)
   (("1"
     (inst - "2")
     (assert)
     (hide 2)
     (lemma "derivseq_conv")
     (inst - "a!1" "_")
     (replace -2)
     (lemma "derivseq_conv")
     (inst - "derivseq(a!1)" "_")
     (case-replace "conv_powerseries?(derivseq(a!1))")
     (("1"
       (expand "derivseq")
       (expand "powerseq")
       (lemma "powerseries_abs_conv")
       (expand "powerseries")
       (expand "powerseq")
       (name "NP2NP1" "(LAMBDA n: (n+2)*(n+1))")
       (inst - "(LAMBDA n: NP2NP1(n)*a!1(2 + n))")
       (expand "abs" -2)
       (split -2)
       (("1"
         (inst - "x!1")
         (assert)
         (case-replace
          "(LAMBDA (n: nat): abs(NP2NP1(n) * a!1(2 + n) * x!1 ^ n))
                            = (LAMBDA n:
                                                    abs(a!1(2 + n)) * abs(x!1 ^ n) * abs(1 + n) *
                                                     abs(2 + n))")
         (apply-extensionality 1 :hide? t)
         (("1"
           (hide 2)
           (replace -2 + rl)
           (assert)
           (hide -1)
           (rewrite "abs_mult" :dir rl)
           (rewrite "abs_mult" :dir rl)
           (rewrite "abs_mult" :dir rl)
           (assert))
          ("2"
           (hide 2)
           (skosimp*)
           (replace -2 + rl)
           (assert)
           (hide -)
           (rewrite "abs_mult" :dir rl)
           (rewrite "abs_mult" :dir rl)
           (rewrite "abs_mult" :dir rl)
           (assert))))
        ("2"
         (hide 2)
         (skosimp*)
         (hide -4)
         (inst -3 "x!2")
         (case-replace
          "(LAMBDA (k: nat):
                                    2 * (a!1(2 + k) * x!2 ^ k) +
                                     3 * (k * a!1(2 + k) * x!2 ^ k)
                                     + k * k * a!1(2 + k) * x!2 ^ k)
                               = (LAMBDA (k: nat): NP2NP1(k) * a!1(2 + k) * x!2 ^ k
                                            )")
         (hide 2)
         (apply-extensionality 1 :hide? t)
         (replace -1 + rl)
         (hide -)
         (assert))))
      ("2"
       (hide 2)
       (expand "conv_powerseries?")
       (skosimp*)
       (hide -1)
       (expand "powerseries")
       (inst?))))
    ("2" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "powerseq")
   (case-replace
    "abs(LAMBDA (k: nat): a!1(k) * x!1 ^ k) =
                              (LAMBDA (k: nat): abs(a!1(k) * x!1 ^ k))")
   (("1"
     (hide -1)
     (case-replace
      "(LAMBDA (k_1: nat): abs(a!1)(k_1) * abs(x!1) ^ k_1) =
           (LAMBDA (k_1: nat): abs(a!1(k_1)) * abs(x!1^ k_1))")
     (("1"
       (hide -1)
       (apply-extensionality 1 :hide? t)
       (("1" (rewrite "abs_mult"))
        ("2" (skosimp*) (assert) (rewrite "abs_mult" :dir rl) (assert))))
      ("2"
       (hide 2)
       (apply-extensionality 1 :hide? t)
       (expand "abs" 1 1)
       (assert)
       (lemma "abs_expt")
       (expand "^")
       (inst?)
       (replace -1 :dir rl)
       (propax))))
    ("2"
     (hide 2)
     (expand "abs")
     (apply-extensionality 1 :hide? t)
     (("1"
       (lift-if)
       (ground)
       (("1" (expand "abs") (propax)) ("2" (expand "abs") (propax))))
      ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: asdf
script:
  (""
   (skosimp*)
   (name "ALPH" "max(abs(x!1), abs(xp!1))")
   (case "ALPH /= 0")
   (("1"
     (case "T_pred(ALPH)")
     (("1"
       (flatten)
       (expand "A2seq")
       (replace -2)
       (hide -2)
       (lemma "conv_derivseq")
       (inst - "derivseq(a!1)")
       (split -1)
       (("1"
         (lemma "conv_series_shift")
         (inst - "2"
          "(LAMBDA (k):
                                                                                      IF k < 2 THEN k
                                                                                      ELSE abs(k) * abs(k - 1) *
                                                                                            abs(a!1(k) * ALPH ^ (k - 2))
                                                                                      ENDIF)")
         (("1"
           (assert)
           (lemma "end_series_conv")
           (inst?)
           (assert)
           (hide 1 5)
           (lemma "end_series_conv")
           (inst?)
           (assert)
           (hide 1 5)
           (inst -1 "3")
           (lemma "powerseries_abs_conv")
           (inst - "fseq(a!1)")
           (split -1)
           (("1"
             (inst - "ALPH")
             (case-replace
              "abs(powerseq(fseq(a!1),ALPH)) = powerseq((LAMBDA n:
                                                   abs(1 + n) * abs(2 + n) * abs(a!1(2 + n))),
                                                   abs(ALPH))")
             (("1"
               (hide -1)
               (case-replace "abs(ALPH) = ALPH")
               (("1"
                 (rewrite "apow_rew")
                 (expand "apowerseq")
                 (assert)
                 (case-replace
                  "(LAMBDA (k: nat):
                                                                                                                                                                            IF k = 0 THEN abs(1) * abs(2) * abs(a!1(2))
                                                                                                                                                                            ELSE abs(a!1(2 + k)) * abs(1 + k) * abs(2 + k) *
                                                                                                                                                                                  ALPH ^ k
                                                                                                                                                                            ENDIF)
                                                                                                                                                                     = (LAMBDA n:
                                                                                                                                                                            abs(1 + n) * abs(2 + n) *
                                                                                                                                                                             abs(a!1(2 + n) * ALPH ^ n))")
                 (("1"
                   (hide -1)
                   (lemma "end_series_conv")
                   (inst?)
                   (assert))
                  ("2"
                   (hide 2)
                   (apply-extensionality 1 :hide? t)
                   (lift-if)
                   (ground)
                   (("1" (replace -1) (assert))
                    ("2"
                     (hide -2 -3 -4)
                     (rewrite "abs_mult")
                     (assert)
                     (rewrite "abs_hat")
                     (case-replace "abs(ALPH) = ALPH")
                     (assert))))))
                ("2"
                 (reveal -8)
                 (hide -2 -3 -4 -5 2 4)
                 (replace -1 * rl)
                 (grind))))
              ("2"
               (hide -1 -2 -3 2)
               (expand "fseq")
               (rewrite "A2_conv_scaf")
               (case-replace
                "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = (LAMBDA n: abs(1 + n) * abs(2 + n) * abs(a!1(2 + n)))")
               (("1" (hide 2) (assert))
                ("2"
                 (hide 2)
                 (case-replace
                  "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = abs(fseq(a!1))")
                 (("1"
                   (hide -1)
                   (apply-extensionality 1 :hide? t)
                   (expand "abs" 1 1)
                   (assert)
                   (expand "fseq")
                   (case-replace
                    "(2 * a!1(2 + x!2) + 3 * (a!1(2 + x!2) * x!2) +
                                                                   a!1(2 + x!2) * x!2 * x!2) = a!1(2 + x!2) * (1 + x!2) * (2 + x!2)")
                   (("1"
                     (rewrite "abs_mult")
                     (hide -1)
                     (case-replace
                      "a!1(2 + x!2) + a!1(2 + x!2) * x!2 = (1+x!2)*a!1(2 + x!2)")
                     (("1" (rewrite "abs_mult") (assert))
                      ("2" (assert))))
                    ("2" (assert))))
                  ("2" (hide 2) (expand "fseq") (propax))))))))
            ("2"
             (skosimp*)
             (hide 2)
             (expand "conv_powerseries?")
             (inst?)
             (expand "derivseq")
             (expand "fseq")
             (assert))))
          ("2" (skosimp*))))
        ("2"
         (assert)
         (hide 4)
         (lemma "conv_derivseq")
         (inst - "a!1")
         (assert))))
      ("2"
       (lemma "ball")
       (inst - "x!1")
       (lemma "ball")
       (inst - "xp!1")
       (hide -5 3)
       (grind))))
    ("2" (flatten) (assert) (hide -3 2) (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (expand "Gseq")
   (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
   (("1"
     (lemma "comparison_test_gen")
     (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
     (lemma "end_series_conv")
     (inst?)
     (("1"
       (assert)
       (hide 2)
       (assert)
       (inst -
        "(LAMBDA (k):
                                                                      IF k < 2 THEN k * a!1(k)
                                                                      ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                                            k * a!1(k) * x!1 ^ (k - 1)
                                                                      ENDIF)"
        "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
       (("1"
         (assert)
         (hide 1)
         (split +)
         (("1"
           (hide -1 -2)
           (case-replace
            "(LAMBDA (k):
                                                           IF k < 2 THEN 0
                                                           ELSE abs(k - 1) * abs(a!1(k) * ALPH ^ (k - 2)) *
                                                                 abs(h!1 * k)
                                                           ENDIF) =
                                                 (LAMBDA (k): abs(h!1)*
                                                           IF k < 2 THEN 0
                                                           ELSE abs(k)*abs(k - 1) * abs(a!1(k)) * abs(ALPH ^ (k - 2))
                                                           ENDIF)")
           (("1"
             (hide -1)
             (lemma "conv_scaf0")
             (inst?)
             (inst - "ALPH")
             (("1"
               (assert)
               (lemma "conv_series_scal")
               (inst?)
               (inst - "abs(h!1)")
               (assert)
               (rewrite "series_scal"))
              ("2"
               (assert)
               (reveal -4)
               (replace -1 * rl)
               (hide -1 -2 2)
               (typepred "h!1")
               (expand "A")
               (assert)
               (lemma "ball")
               (inst - "(h!1 + x!1)")
               (lemma "ball")
               (inst - "(x!1)")
               (grind))))
            ("2"
             (hide 2)
             (apply-extensionality 1 :hide? t)
             (lift-if)
             (rewrite "abs_mult")
             (rewrite "abs_mult")
             (ground))))
          ("2"
           (inst 1 "3")
           (skosimp*)
           (lift-if)
           (ground)
           (inst -3 "n!1")
           (name "TK" "GET_tk(x!1, h!1, n!1)")
           (case "(EXISTS (PKM1: between[T](x!1,TK)):
                                                                                                                            abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                                                                                                               abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
           (("1"
             (skosimp*)
             (replace -2)
             (case "abs(PKM1!1) <= abs(ALPH)")
             (("1"
               (case "abs(a!1(n!1) * TK ^(n!1 - 1) * n!1 -
                                                                                                                               a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
                                                                                                                            abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
               (("1"
                 (replace -1)
                 (hide -1)
                 (rewrite "abs_mult")
                 (rewrite "abs_mult")
                 (auto-rewrite "abs_0")
                 (case-replace "ALPH = 0")
                 (("1" (hide-all-but -6) (grind))
                  ("2"
                   (div-by 3 "abs(n!1)*abs(n!1-1)")
                   (("1"
                     (field 3)
                     (lemma "abs_neg")
                     (inst - "(x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1))")
                     (assert)
                     (replace -1)
                     (replace -5)
                     (div-by 3 "abs(n!1-1)")
                     (field 3)
                     (hide -1 -3-6 -7 -10)
                     (lemma "both_sides_expt_pos_ge")
                     (inst - "(n!1-2)" "abs(ALPH)" "abs(PKM1!1)")
                     (("1"
                       (assert)
                       (rewrite "abs_hat" :dir rl)
                       (div-by 3 "abs(a!1(n!1))")
                       (field 3)
                       (case-replace "PKM1!1 = 0")
                       (("1" (assert))
                        ("2"
                         (assert)
                         (case "abs(PKM1!1) /= 0")
                         (("1"
                           (flatten)
                           (rewrite "abs_hat" :dir rl)
                           (div-by 4 "abs(a!1(n!1))")
                           (field 4)
                           (mult-ineq -2 -8)
                           (("1" (assert))
                            ("2" (auto-rewrite "abs_abs") (assert))))
                          ("2"
                           (lemma "abs_eq_0")
                           (inst - "PKM1!1")
                           (assert))))))
                      ("2"
                       (assert)
                       (case "abs(PKM1!1) /= 0")
                       (("1" (flatten) (rewrite "abs_eq_0"))
                        ("2"
                         (flatten)
                         (case-replace "PKM1!1 = 0")
                         (("1" (case-replace "PKM1!1 = 0") (assert))
                          ("2"
                           (lemma "abs_eq_0")
                           (inst - "PKM1!1")
                           (assert))))))))
                    ("2"
                     (assert)
                     (hide-all-but (1 3))
                     (mult-cases 1))))))
                ("2"
                 (hide 3)
                 (hide-all-but 1)
                 (case-replace
                  "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
                                                                                                             a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
                                                                                                             a!1(n!1) * n!1*(TK ^(n!1 - 1) - x!1^(n!1 - 1))")
                 (("1" (rewrite "abs_mult") (rewrite "abs_mult"))
                  ("2" (hide 2) (assert))))))
              ("2"
               (hide 3)
               (replace -4 * rl)
               (hide -4)
               (hide -1 -2)
               (hide -3)
               (case-replace
                "abs(max(abs(x!1), abs(h!1 + x!1))) = (max(abs(x!1), abs(h!1 + x!1)))")
               (("1"
                 (hide -1)
                 (hide -2)
                 (typepred "TK")
                 (hide -5)
                 (typepred "PKM1!1")
                 (grind))
                ("2" (hide 2) (grind))))))
            ("2"
             (hide 3)
             (lemma "mean_value[T]")
             (("1"
               (inst - "TK" "x!1" "(LAMBDA (x:T): x^(n!1-1))")
               (lemma "deriv_x_to_n[T]")
               (("1"
                 (inst - "(n!1-1)" "1")
                 (assert)
                 (flatten)
                 (case-replace
                  "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                 (("1"
                   (hide -1)
                   (assert)
                   (split -3)
                   (("1"
                     (skosimp*)
                     (inst + "c!1")
                     (("1"
                       (case-replace
                        "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                                         (n!1-1)*c!1^(n!1-2)")
                       (("1"
                         (factor -4 l)
                         (hide-all-but (-4 1))
                         (name-replace "NM1" "n!1-1")
                         (replace -1 * rl)
                         (rewrite "abs_mult")
                         (rewrite "abs_mult")
                         (assert))
                        ("2"
                         (hide 2)
                         (lemma "deriv_x_to_n[T]")
                         (assert)
                         (inst - "(n!1-1)" "1")
                         (flatten)
                         (case-replace
                          "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                         (("1"
                           (hide -1)
                           (replace -2)
                           (hide-all-but (-1 -2 1))
                           (assert)
                           (expand "deriv" -2)
                           (assert)
                           (case-replace
                            "(LAMBDA (x_1: T): deriv((LAMBDA (x: T): x ^ (n!1 - 1)), x_1))(c!1)
                                                                             =
                                                                                   (LAMBDA (x: T): (x ^ (n!1 - 2)) * n!1 - x ^ (n!1 - 2))(c!1)")
                           (("1" (assert))
                            ("2" (hide 2) (replace -2) (propax))
                            ("3" (lemma "not_one_element") (skosimp*))
                            ("4"
                             (skosimp*)
                             (lemma deriv_domain)
                             (propax))
                            ("5"
                             (hide -2 2)
                             (expand "derivable?" -1)
                             (skosimp*)
                             (inst?))))
                          ("2" (apply-extensionality 1 :hide? t))))))
                      ("2" (assert))))
                    ("2"
                     (case-replace "x!1 = TK")
                     (("1"
                       (assert)
                       (rewrite "abs_0")
                       (assert)
                       (typepred "TK")
                       (assert))
                      ("2"
                       (lemma "mean_value[T]")
                       (inst - "x!1" "TK" "(LAMBDA (x:T): x^(n!1-1))")
                       (assert)
                       (skosimp*)
                       (inst + "c!1")
                       (("1"
                         (case-replace
                          "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                                                                   (n!1-1)*c!1^(n!1-2)")
                         (("1"
                           (factor -4 l)
                           (hide-all-but (-4 1 2 3))
                           (name-replace "NM1" "n!1-1")
                           (lemma "abs_neg")
                           (inst - "(x!1 - TK)")
                           (replace -1 * rl)
                           (name-replace "TKMx" "(TK - x!1)")
                           (hide -1)
                           (case-replace
                            "abs(x!1 ^ NM1 - TK ^ NM1) = abs(TK ^ NM1 - x!1 ^ NM1) ")
                           (("1"
                             (replace -2 * rl)
                             (hide -1 -2)
                             (rewrite "abs_mult")
                             (rewrite "abs_mult")
                             (assert))
                            ("2"
                             (hide-all-but 1)
                             (expand "abs")
                             (lift-if)
                             (lift-if)
                             (ground)
                             (lift-if)
                             (ground))))
                          ("2"
                           (case-replace
                            "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) = deriv(LAMBDA (x: T): x ^ (n!1 - 1))(c!1)")
                           (("1" (replace -6) (assert))
                            ("2" (expand "deriv" 1 2) (propax))))))
                        ("2" (assert))))))))
                  ("2" (apply-extensionality 1 :hide? t))))
                ("2"
                 (lemma "connected_domain")
                 (lemma "connected_deriv_domain[T]")
                 (replace -2)
                 (lemma deriv_domain)
                 (propax))))
              ("2" (lemma "not_one_element") (propax))
              ("3" (lemma "connected_domain") (propax))))))))
        ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
        ("4" (skosimp*) (assert))))
      ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
      ("4" (skosimp*) (assert))))
    ("2"
     (hide 2)
     (skosimp*)
     (typepred "GET_tk(x!1, h!1, k!1)")
     (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
     (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_series?")
   (expand "Gseq")
   (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
   (("1"
     (lemma "comparison_test_gen")
     (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
     (lemma "end_series_conv")
     (inst?)
     (("1"
       (assert)
       (hide 2)
       (assert)
       (inst -
        "abs(LAMBDA (k):
                                                                                  IF k < 2 THEN k * a!1(k)
                                                                                  ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                                                        k * a!1(k) * x!1 ^ (k - 1)
                                                                                  ENDIF)"
        "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
       (("1"
         (assert)
         (hide 1)
         (split +)
         (("1"
           (hide -1 -2)
           (case-replace
            "(LAMBDA (k):
                                                                               IF k < 2 THEN 0
                                                                               ELSE abs(k - 1) * abs(a!1(k) * ALPH ^ (k - 2)) *
                                                                                     abs(h!1 * k)
                                                                               ENDIF) =
                                                                     (LAMBDA (k): abs(h!1)*
                                                                               IF k < 2 THEN 0
                                                                               ELSE abs(k)*abs(k - 1) * abs(a!1(k)) * abs(ALPH ^ (k - 2))
                                                                               ENDIF)")
           (("1"
             (hide -1)
             (lemma "conv_scaf0")
             (inst?)
             (inst - "ALPH")
             (("1"
               (assert)
               (lemma "conv_series_scal")
               (inst?)
               (inst - "abs(h!1)")
               (assert)
               (rewrite "series_scal"))
              ("2"
               (assert)
               (reveal -4)
               (replace -1 * rl)
               (hide -1 -2 2)
               (typepred "h!1")
               (expand "A")
               (assert)
               (lemma "ball")
               (inst - "(h!1 + x!1)")
               (lemma "ball")
               (inst - "(x!1)")
               (grind))))
            ("2"
             (hide 2)
             (apply-extensionality 1 :hide? t)
             (lift-if)
             (rewrite "abs_mult")
             (rewrite "abs_mult")
             (ground))))
          ("2"
           (inst 1 "3")
           (skosimp*)
           (lift-if)
           (ground)
           (inst -3 "n!1")
           (expand "abs" 2 2)
           (rewrite "abs_abs")
           (name "TK" "GET_tk(x!1, h!1, n!1)")
           (case "(EXISTS (PKM1: between[T](x!1,TK)):
                                                                                                                                                          abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                                                                                                                                             abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
           (("1"
             (skosimp*)
             (replace -2)
             (case "abs(PKM1!1) <= abs(ALPH)")
             (("1"
               (case "abs(a!1(n!1) * TK ^(n!1 - 1) * n!1 -
                                                                                                                                                                     a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
                                                                                                                                                                  abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
               (("1"
                 (replace -1)
                 (hide -1)
                 (rewrite "abs_mult")
                 (rewrite "abs_mult")
                 (auto-rewrite "abs_0")
                 (case-replace "ALPH = 0")
                 (("1" (hide-all-but -6) (grind))
                  ("2"
                   (div-by 3 "abs(n!1)*abs(n!1-1)")
                   (("1"
                     (field 3)
                     (lemma "abs_neg")
                     (inst - "(x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1))")
                     (assert)
                     (replace -1)
                     (replace -5)
                     (div-by 3 "abs(n!1-1)")
                     (field 3)
                     (hide -1 -3-6 -7 -10)
                     (lemma "both_sides_expt_pos_ge")
                     (inst - "(n!1-2)" "abs(ALPH)" "abs(PKM1!1)")
                     (("1"
                       (assert)
                       (rewrite "abs_hat" :dir rl)
                       (div-by 3 "abs(a!1(n!1))")
                       (field 3)
                       (case-replace "PKM1!1 = 0")
                       (("1" (assert))
                        ("2"
                         (lemma "abs_eq_0")
                         (inst - "PKM1!1")
                         (assert)
                         (rewrite "abs_hat" :dir rl)
                         (div-by 4 "abs(a!1(n!1))")
                         (field 4)
                         (mult-ineq -4 -11)
                         (("1" (assert))
                          ("2" (auto-rewrite "abs_abs") (assert))))))
                      ("2"
                       (lemma "abs_eq_0")
                       (inst - "PKM1!1")
                       (assert)
                       (flatten)
                       (case "PKM1!1 /= 0")
                       (("1" (flatten) (assert))
                        ("2" (flatten) (replace -1) (assert))))))
                    ("2"
                     (assert)
                     (hide-all-but (1 3))
                     (mult-cases 1))))))
                ("2"
                 (hide 3)
                 (hide-all-but 1)
                 (case-replace
                  "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
                                                                                                                                             a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
                                                                                                                                             a!1(n!1) * n!1*(TK ^(n!1 - 1) - x!1^(n!1 - 1))")
                 (("1" (rewrite "abs_mult") (rewrite "abs_mult"))
                  ("2" (hide 2) (assert))))))
              ("2"
               (hide 3)
               (replace -4 * rl)
               (hide -4)
               (hide -1 -2)
               (hide -3)
               (case-replace
                "abs(max(abs(x!1), abs(h!1 + x!1))) = (max(abs(x!1), abs(h!1 + x!1)))")
               (("1"
                 (hide -1)
                 (hide -2)
                 (typepred "TK")
                 (hide -5)
                 (typepred "PKM1!1")
                 (grind))
                ("2" (hide 2) (grind))))))
            ("2"
             (hide 3)
             (lemma "mean_value[T]")
             (("1"
               (inst - "TK" "x!1" "(LAMBDA (x:T): x^(n!1-1))")
               (lemma "deriv_x_to_n[T]")
               (("1"
                 (inst - "(n!1-1)" "1")
                 (assert)
                 (flatten)
                 (case-replace
                  "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                 (("1"
                   (hide -1)
                   (assert)
                   (split -3)
                   (("1"
                     (skosimp*)
                     (inst + "c!1")
                     (("1"
                       (case-replace
                        "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                                                                                   (n!1-1)*c!1^(n!1-2)")
                       (("1"
                         (factor -4 l)
                         (hide-all-but (-4 1))
                         (name-replace "NM1" "n!1-1")
                         (replace -1 * rl)
                         (rewrite "abs_mult")
                         (rewrite "abs_mult")
                         (assert))
                        ("2"
                         (hide 2)
                         (lemma "deriv_x_to_n[T]")
                         (assert)
                         (inst - "(n!1-1)" "1")
                         (flatten)
                         (case-replace
                          "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                         (("1"
                           (hide -1)
                           (replace -2)
                           (hide-all-but (-1 -2 1))
                           (assert)
                           (expand "deriv" -2)
                           (assert)
                           (case-replace
                            "(LAMBDA (x_1: T): deriv((LAMBDA (x: T): x ^ (n!1 - 1)), x_1))(c!1)
                                                                                                                               =
                                                                                                                                     (LAMBDA (x: T): (x ^ (n!1 - 2)) * n!1 - x ^ (n!1 - 2))(c!1)")
                           (("1" (assert))
                            ("2" (hide 2) (replace -2) (propax))
                            ("3" (lemma "not_one_element") (skosimp*))
                            ("4"
                             (skosimp*)
                             (lemma deriv_domain)
                             (propax))
                            ("5"
                             (hide -2 2)
                             (expand "derivable?" -1)
                             (skosimp*)
                             (inst?))))
                          ("2" (apply-extensionality 1 :hide? t))))))
                      ("2" (assert))))
                    ("2"
                     (case-replace "x!1 = TK")
                     (("1"
                       (assert)
                       (rewrite "abs_0")
                       (assert)
                       (typepred "TK")
                       (assert))
                      ("2"
                       (lemma "mean_value[T]")
                       (inst - "x!1" "TK" "(LAMBDA (x:T): x^(n!1-1))")
                       (assert)
                       (skosimp*)
                       (inst + "c!1")
                       (("1"
                         (case-replace
                          "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                                                                                                                 (n!1-1)*c!1^(n!1-2)")
                         (("1"
                           (factor -4 l)
                           (hide-all-but (-4 1 2 3))
                           (name-replace "NM1" "n!1-1")
                           (lemma "abs_neg")
                           (inst - "(x!1 - TK)")
                           (replace -1 * rl)
                           (name-replace "TKMx" "(TK - x!1)")
                           (hide -1)
                           (case-replace
                            "abs(x!1 ^ NM1 - TK ^ NM1) = abs(TK ^ NM1 - x!1 ^ NM1) ")
                           (("1"
                             (replace -2 * rl)
                             (hide -1 -2)
                             (rewrite "abs_mult")
                             (rewrite "abs_mult")
                             (assert))
                            ("2"
                             (hide-all-but 1)
                             (expand "abs")
                             (lift-if)
                             (lift-if)
                             (ground)
                             (lift-if)
                             (ground))))
                          ("2"
                           (case-replace
                            "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) = deriv(LAMBDA (x: T): x ^ (n!1 - 1))(c!1)")
                           (("1" (replace -6) (assert))
                            ("2" (expand "deriv" 1 2) (propax))))))
                        ("2" (assert))))))))
                  ("2" (apply-extensionality 1 :hide? t))))
                ("2" (lemma "deriv_domain") (propax))))
              ("2" (lemma "not_one_element") (propax))
              ("3" (lemma "connected_domain") (propax))))))))
        ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
        ("4" (skosimp*) (assert))))
      ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
      ("4" (skosimp*) (assert))))
    ("2"
     (hide 2)
     (skosimp*)
     (typepred "GET_tk(x!1, h!1, k!1)")
     (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
     (grind))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "inf_sum_triangle")
   (inst?)
   (lemma "abs_Gseq_conv")
   (inst?)
   (assert)
   (inst?)
   (assert)
   (inst?)
   (assert)
   (expand "conv_series?")
   (hide 2)
   (lemma "end_series_conv")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deriv_powerseries_conv")
   (inst?)
   (assert)
   (lemma "Gseq_conv")
   (inst?)
   (assert)
   (expand "Gseq")
   (expand "deriv_powerseq")
   (inst - "x!1")
   (inst - "h!1")
   (inst - "x!1")
   (expand "conv_series?")
   (lemma "end_series_conv")
   (inst -
    "(LAMBDA k:
                              IF k = 0 THEN 0
                              ELSIF k = 1 THEN a!1(1)
                              ELSE k * a!1(k) * x!1 ^ (k - 1)
                              ENDIF)"
    "2")
   (("1"
     (assert)
     (hide -3)
     (lemma "convergent_sum")
     (inst?)
     (("1"
       (inst -
        "series(LAMBDA (k):
                                  IF k < 2 THEN k * a!1(k)
                                  ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                        k * a!1(k) * x!1 ^ (k - 1)
                                  ENDIF,
                                2)")
       (("1"
         (assert)
         (hide -2 -3)
         (rewrite "series_m_sum")
         (("1"
           (expand "+")
           (lemma "series_m_eq")
           (inst?)
           (("1"
             (inst -
              "(LAMBDA k:
                                        IF k < 2 THEN k * a!1(k)
                                        ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1)
                                        ENDIF)")
             (("1"
               (assert)
               (split -1)
               (("1"
                 (replace -1)
                 (hide -1)
                 (lemma "end_series_conv")
                 (inst?)
                 (("1"
                   (assert)
                   (hide -2)
                   (lemma "end_series_conv")
                   (inst?)
                   (("1" (assert)) ("2" (skosimp*) (assert))
                    ("3" (skosimp*) (assert))))
                  ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))
                ("2" (hide 2) (skosimp*) (lift-if) (lift-if) (ground))))
              ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))
            ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
            ("4" (skosimp*) (assert)) ("5" (skosimp*) (assert))))
          ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
          ("4" (skosimp*) (assert)) ("5" (skosimp*) (assert))))
        ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
        ("4" (skosimp*) (assert))))
      ("2" (skosimp*) (assert))))
    ("2" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "conv_powerseries?")
   (inst-cp - "x!1")
   (inst - "x!1+h!1")
   (("1"
     (expand "powerseries")
     (expand "powerseq")
     (lemma "convergent_diff")
     (inst?)
     (inst - "series(LAMBDA (k: nat): a!1(k) * x!1 ^ k)")
     (assert)
     (hide -2 -3)
     (rewrite "series_diff")
     (expand "-")
     (propax))
    ("2" (typepred "h!1") (expand "A") (propax))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conv_scaf1")
   (inst?)
   (inst?)
   (assert)
   (inst - "h!1")
   (assert)
   (expand "conv_series?")
   (lemma "end_series_conv")
   (inst -
    "(LAMBDA (k: nat):  a!1(k) * (h!1 + x!1) ^ k - a!1(k) * x!1 ^ k)"
    "1")
   (assert)
   (hide -2)
   (lemma "convergent_scal")
   (inst?)
   (inst - "1/h!1")
   (assert)
   (rewrite "series_m_scal")
   (expand "*")
   (hide -2)
   (assert))


proof_type: t_proof
decl_type: tcc
library: series
theory: power_series_deriv_scaf
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst +
    "(LAMBDA (d: [x: T, (A[T](x)), posnat]):
                            choose({tk: between[T](d`1, d`1 + d`2) |
                                          ((d`1 + d`2) ^ d`3 - d`1 ^ d`3) / d`2 =
                                           d`3 * tk ^ (d`3 - 1)}))")
   (("1" (skosimp*) (lemma "GET_tk_prep") (inst?))
    ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))
    ("4" (skosimp*) (assert))
    ("5" (skosimp*) (lemma "not_one_element") (inst?))
    ("6" (skosimp*) (lemma "connected_domain") (inst?) (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: series
theory: power_series_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "not_one_element")
   (lemma "connected_domain")
   (lemma "deriv_powerseries_conv")
   (inst?)
   (assert)
   (expand "conv_powerseries?")
   (lemma "deriv_fun_def[T]")
   (("1"
     (inst?)
     (inst - "(LAMBDA x: limit(series(deriv_powerseq(a!1, x))))")
     (split -1)
     (("1" (flatten) (assert))
      ("2"
       (hide 2)
       (skosimp*)
       (name "FA" "(LAMBDA x: limit(powerseries(a!1)(x)))")
       (("1"
         (replace -1)
         (name "FG" "(LAMBDA x: limit(series(deriv_powerseq(a!1, x))))")
         (("1"
           (case-replace
            "limit(series(deriv_powerseq(a!1, x!1))) = FG(x!1)")
           (("1"
             (lemma "derivative_squeeze_delta[T]")
             (("1"
               (inst?)
               (assert)
               (hide 2)
               (case-replace
                "(LAMBDA (h: (A[T](x!1))): (NQ(FA, x!1)(h) - FG(x!1))) =
                                                                                                                                                                                                                                                                                                                        (LAMBDA (h: (A[T](x!1))): inf_sum(2,Gseq(a!1,x!1,h)))")
               (("1"
                 (case "EXISTS xp: abs(xp) > abs(x!1) AND (xp >= 0 IFF x!1 >= 0)")
                 (("1"
                   (skosimp*)
                   (hide -2 -3)
                   (case "xp!1 /= 0")
                   (("1"
                     (flatten)
                     (inst +
                      "(LAMBDA (h: (A[T](x!1))): abs(h)*inf_sum(2,A2seq(a!1,x!1,xp!1)))")
                     (("1"
                       (split +)
                       (("1"
                         (name-replace "LL"
                          "inf_sum(2, A2seq(a!1, x!1, xp!1))")
                         (("1"
                           (lemma "cv_scal[(A[T](x!1))]")
                           (inst - "0" "LL"
                            "(LAMBDA (h: (A[T](x!1))): abs(h))" "0")
                           (expand "*")
                           (assert)
                           (hide 2)
                           (hide-all-but 1)
                           (lemma "cv_abs[(A[T](x!1))]")
                           (inst?)
                           (("1"
                             (expand "restrict")
                             (expand "abs")
                             (propax))
                            ("2"
                             (expand "adh")
                             (lemma "deriv_domain")
                             (expand "deriv_domain?")
                             (skosimp*)
                             (inst?)
                             (inst - x!1)
                             (skosimp*)
                             (inst + y!1)
                             (("1" (hide 2) (grind))
                              ("2" (hide 2) (typepred "y!1") (grind))))))
                          ("2"
                           (hide 2)
                           (expand "conv_series?")
                           (lemma "A2_conv[T]")
                           (inst - "a!1" "x!1" "xp!1")
                           (assert))
                          ("3" (assert))))
                        ("2"
                         (inst + "abs(xp!1 - x!1)")
                         (("1"
                           (skosimp*)
                           (hide -4 -5 -6 -7 -10)
                           (case "(LAMBDA (h: (A[T](x!1))): (NQ(FA, x!1)(h) - FG(x!1)))(h!1) =
                                                                                                                                                                                                                                                                                                                                                             (LAMBDA (h: (A[T](x!1))): inf_sum(2, Gseq(a!1, x!1, h)))(h!1)")
                           (("1"
                             (assert)
                             (replace -1)
                             (hide -1)
                             (lemma "inf_sum_scal")
                             (inst?)
                             (lemma "A2_conv[T]")
                             (inst?)
                             (assert)
                             (replace -2)
                             (hide -2)
                             (lemma "inf_sum_le")
                             (inst - "abs(Gseq(a!1, x!1, h!1))"
                              "abs(h!1)*A2seq(a!1, x!1, xp!1)" "2")
                             (split -1)
                             (("1"
                               (lemma "inf_sum_Gseq_abs[T]")
                               (inst?)
                               (inst - "x!1")
                               (assert)
                               (inst?)
                               (assert))
                              ("2"
                               (hide 2)
                               (skosimp*)
                               (expand "Gseq")
                               (case-replace
                                "abs(abs(LAMBDA (k):
                                                                                                                                                                                                                                                                                                                                                                  IF k < 2 THEN k * a!1(k)
                                                                                                                                                                                                                                                                                                                                                                  ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                                                                                                                                                                                                                                                                                                                                        k * a!1(k) * x!1 ^ (k - 1)
                                                                                                                                                                                                                                                                                                                                                                  ENDIF)
                                                                                                                                                                                                                                                                                                                                                               (n!1)) =
                                                                                                                                                                                                                                                                                                                                                                  IF n!1 < 2 THEN abs(n!1 * a!1(n!1))
                                                                                                                                                                                                                                                                                                                                                                  ELSE abs(n!1) * abs(a!1(n!1)) * abs(GET_tk(x!1, h!1, n!1) ^ (n!1 - 1) -  x!1 ^ (n!1 - 1))
                                                                                                                                                                                                                                                                                                                                                                  ENDIF")
                               (("1"
                                 (expand "A2seq")
                                 (assert)
                                 (hide -1 -2 -5)
                                 (expand "*")
                                 (name-replace
                                  "TK"
                                  "GET_tk(x!1, h!1, n!1)")
                                 (rewrite "abs_mult")
                                 (case-replace
                                  "abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1)) <=
                                                                                                                                                                                                                                                                                                                                                                                 abs(max(abs(x!1), abs(xp!1)) ^ (n!1 - 2)) * abs(n!1 - 1) * abs(h!1)")
                                 (("1"
                                   (mult-by -1 "abs(a!1(n!1))*abs(n!1)")
                                   (assert))
                                  ("2"
                                   (hide 2)
                                   (name
                                    "MAX"
                                    "max(abs(x!1), abs(xp!1))")
                                   (replace -1)
                                   (lemma "mean_value_abs[T]")
                                   (inst
                                    -
                                    "TK"
                                    "x!1"
                                    "(LAMBDA (x:T): x^(n!1-1))")
                                   (lemma "deriv_x_to_n[T]")
                                   (inst - "(n!1-1)" "1")
                                   (assert)
                                   (flatten)
                                   (case-replace
                                    "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                   (("1"
                                     (hide -1)
                                     (assert)
                                     (case-replace "TK = x!1")
                                     (("1"
                                       (assert)
                                       (rewrite "abs_0")
                                       (assert))
                                      ("2"
                                       (assert)
                                       (skosimp*)
                                       (case-replace
                                        "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (n!1-1)*c!1^(n!1-2)")
                                       (("1"
                                         (hide -1 -2 -3)
                                         (lemma "abs_neg")
                                         (inst
                                          -
                                          "x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1)")
                                         (replace -1 - rl)
                                         (replace -4 + rl)
                                         (rewrite "abs_mult")
                                         (name-replace
                                          "NM1"
                                          "abs((n!1 - 1))")
                                         (hide -1 -4 -8 -9)
                                         (case-replace
                                          "abs(c!1 ^ (n!1 - 2)) <= abs(MAX ^ (n!1 - 2))")
                                         (("1"
                                           (case-replace
                                            "abs(x!1 - TK) <= abs(h!1)")
                                           (("1"
                                             (mult-ineq -1 -2)
                                             (("1"
                                               (mult-by -1 "NM1")
                                               (assert))
                                              ("2"
                                               (prop)
                                               (("1"
                                                 (hide-all-but (-1 1))
                                                 (grind))
                                                ("2"
                                                 (hide-all-but (-2 1))
                                                 (grind))))))
                                            ("2"
                                             (hide -1 -2 -3 3)
                                             (reveal -16)
                                             (typepred
                                              "GET_tk(x!1, h!1, n!1)")
                                             (grind))))
                                          ("2"
                                           (hide 3)
                                           (typepred "TK")
                                           (reveal -27 -28)
                                           (case "abs(c!1) <= abs(MAX)")
                                           (("1"
                                             (lemma
                                              "both_sides_expt_pos_ge")
                                             (case-replace "n!1 = 2")
                                             (("1" (assert))
                                              ("2"
                                               (case-replace "c!1 = 0")
                                               (("1"
                                                 (lemma "zero_hat")
                                                 (inst?)
                                                 (("1"
                                                   (replace -1)
                                                   (expand "abs" 2)
                                                   (assert))
                                                  ("2" (assert))))
                                                ("2"
                                                 (inst
                                                  -
                                                  "(n!1 - 2)"
                                                  "abs(MAX)"
                                                  "abs(c!1)")
                                                 (("1"
                                                   (assert)
                                                   (rewrite "abs_hat")
                                                   (rewrite "abs_hat")
                                                   (assert))
                                                  ("2"
                                                   (lemma "abs_eq_0")
                                                   (inst?)
                                                   (assert))
                                                  ("3"
                                                   (lemma "abs_eq_0")
                                                   (inst?)
                                                   (assert))
                                                  ("4" (assert))))))))
                                            ("2"
                                             (hide 2)
                                             (grind :exclude "^"))))))
                                        ("2"
                                         (hide 3)
                                         (expand "deriv" -2)
                                         (assert)
                                         (case-replace
                                          "(LAMBDA (x_1: T): deriv((LAMBDA (x: T): x ^ (n!1 - 1)), x_1))(c!1) =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (LAMBDA (x: T): (x ^ (n!1 - 2)) * n!1 - x ^ (n!1 - 2))(c!1)")
                                         (("1" (assert))
                                          ("2" (replace -2) (propax))
                                          ("3"
                                           (expand "derivable?" -1)
                                           (inst?)
                                           (lemma "not_one_element")
                                           (skosimp*)
                                           (lemma "deriv_domain")
                                           (propax))
                                          ("4"
                                           (lemma "open")
                                           (skosimp*)
                                           (lemma "deriv_domain")
                                           (inst?)
                                           (expand "deriv_domain?")
                                           (hide -1 -2 -3)
                                           (expand "derivable?" -1)
                                           (inst?))))))))
                                    ("2"
                                     (apply-extensionality
                                      1
                                      :hide?
                                      t))))))
                                ("2"
                                 (hide-all-but 1)
                                 (expand "abs" 1 2)
                                 (name-replace
                                  "GG"
                                  "GET_tk(x!1, h!1, n!1) ^ (n!1 - 1)")
                                 (name-replace "XX" "x!1 ^ (n!1 - 1)")
                                 (case-replace
                                  "a!1(n!1) * GG * n!1 - a!1(n!1) * XX * n!1 =
                                                                                                                                                                                                                                                                                                                                                                                                                            a!1(n!1) * n!1 *(GG - XX)")
                                 (("1"
                                   (hide -1)
                                   (rewrite "abs_mult")
                                   (rewrite "abs_mult")
                                   (rewrite "abs_mult")
                                   (rewrite "abs_mult")
                                   (rewrite "abs_abs")
                                   (rewrite "abs_abs")
                                   (rewrite "abs_abs")
                                   (assert))
                                  ("2" (assert))))
                                ("3" (assert) (skosimp*) (assert))
                                ("4" (assert) (skosimp*) (assert))
                                ("5" (assert) (skosimp*) (assert))))
                              ("3"
                               (hide 2)
                               (lemma "convergent_scal")
                               (inst - "abs(h!1)"
                                "series(A2seq(a!1, x!1, xp!1), 2)")
                               (assert)
                               (lemma "series_m_scal")
                               (inst?)
                               (assert))))
                            ("2" (replace -3) (propax))
                            ("3"
                             (lemma "Gseq_conv[T]")
                             (inst?)
                             (inst - "x!1")
                             (assert)
                             (skosimp*)
                             (inst?))
                            ("4"
                             (skosimp*)
                             (lemma "deriv_domain")
                             (propax))))
                          ("2" (hide-all-but (-1 1)) (grind))))))
                      ("2"
                       (skosimp*)
                       (lemma "A2_conv[T]")
                       (inst?)
                       (assert)
                       (expand "conv_series?")
                       (propax))
                      ("3" (skosimp*))))
                    ("2" (hide-all-but (-1 1)) (grind))))
                  ("2"
                   (hide 2)
                   (hide -)
                   (case "x!1 >= 0")
                   (("1"
                     (lemma "open")
                     (inst - "x!1")
                     (skosimp*)
                     (inst + "x!1 + delta!1/2")
                     (("1" (grind)) ("2" (inst?) (assert) (grind))))
                    ("2"
                     (lemma "open")
                     (inst - "x!1")
                     (skosimp*)
                     (inst + "x!1 - delta!1/2")
                     (("1" (grind))
                      ("2"
                       (inst - "x!1 - delta!1/2")
                       (assert)
                       (grind))))))))
                ("2"
                 (hide 2)
                 (apply-extensionality 1 :hide? t)
                 (("1"
                   (expand "NQ")
                   (expand "inf_sum")
                   (replace -2 * rl)
                   (case-replace
                    "(FA(x!1 + x!2) - FA(x!1)) / x!2 =
                                                                                                                                                                                                                                                                                                                                                                                                                          inf_sum(1,(LAMBDA k:
                                                                                                                                                                                                                                                                                                                                                                                                                                a!1(k)*(((x!1+x!2)^k - x!1^k)/x!2)))")
                   (("1"
                     (lemma "inf_sum_eq")
                     (inst?)
                     (inst -
                      "(LAMBDA k: IF k < 2 THEN k*a!1(k) ELSE a!1(k)*k*GET_tk(x!1,x!2,k)^(k-1) ENDIF)")
                     (("1"
                       (assert)
                       (assert)
                       (split -1)
                       (("1"
                         (assert)
                         (replace -1)
                         (assert)
                         (rewrite "lim_deriv_alt" +)
                         (expand "inf_sum")
                         (hide -1 -2)
                         (rewrite "limit_diff" :dir rl)
                         (("1"
                           (rewrite "series_m_diff")
                           (("1"
                             (case-replace
                              "series((LAMBDA k:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IF k < 2 THEN k* a!1(k)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ELSE k* a!1(k)* GET_tk(x!1, x!2,k) ^ (k - 1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ENDIF)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - deriv_powerseq(a!1, x!1),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             1) = series((LAMBDA k:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IF k < 2 THEN k* a!1(k)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ELSE k * a!1(k)*GET_tk(x!1, x!2,k) ^ (k - 1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ENDIF)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - deriv_powerseq(a!1, x!1),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             2)")
                             (("1"
                               (hide -1)
                               (lemma "limit_eq_rew")
                               (inst?)
                               (("1"
                                 (split -1)
                                 (("1" (propax))
                                  ("2"
                                   (hide 2)
                                   (lemma "series_m_diff")
                                   (inst?)
                                   (("1"
                                     (replace -1 * rl)
                                     (hide -1)
                                     (lemma "convergent_diff")
                                     (inst?)
                                     (("1"
                                       (assert)
                                       (hide 2)
                                       (lemma
                                        "deriv_powerseries_conv[T]")
                                       (inst?)
                                       (assert)
                                       (inst?)
                                       (prop)
                                       (("1"
                                         (lemma "conv_scaf2[T]")
                                         (inst?)
                                         (inst -1 "x!1")
                                         (assert)
                                         (inst?)
                                         (assert)
                                         (lemma "end_series_conv")
                                         (inst?)
                                         (("1"
                                           (assert)
                                           (hide -2)
                                           (lemma "end_series_conv")
                                           (inst?)
                                           (("1" (assert))
                                            ("2" (skosimp*) (assert))
                                            ("3" (skosimp*) (assert))))
                                          ("2" (skosimp*) (assert))
                                          ("3" (skosimp*) (assert))))
                                        ("2"
                                         (lemma "end_series_conv")
                                         (inst?)
                                         (assert))))
                                      ("2" (skosimp*) (assert))
                                      ("3" (skosimp*) (assert))))
                                    ("2" (skosimp*) (assert))
                                    ("3" (skosimp*) (assert))))
                                  ("3"
                                   (hide 2)
                                   (lemma "Gseq_conv[T]")
                                   (inst?)
                                   (inst - "x!1")
                                   (assert)
                                   (expand "conv_series?")
                                   (inst?))
                                  ("4"
                                   (hide 2)
                                   (rewrite "series_m_eq")
                                   (("1"
                                     (hide 2)
                                     (skosimp*)
                                     (expand "-")
                                     (expand "deriv_powerseq")
                                     (expand "Gseq")
                                     (assert))
                                    ("2" (skosimp*) (assert))
                                    ("3" (skosimp*) (assert))))))
                                ("2" (skosimp*) (assert))
                                ("3" (skosimp*) (assert))))
                              ("2"
                               (hide 2)
                               (expand "series")
                               (apply-extensionality 1 :hide? t)
                               (("1"
                                 (rewrite "sigma_first")
                                 (("1"
                                   (assert)
                                   (expand "deriv_powerseq")
                                   (assert)
                                   (expand "-")
                                   (propax))
                                  ("2"
                                   (case-replace "x!3 = 0")
                                   (("1" (expand "sigma") (propax))
                                    ("2" (assert))))
                                  ("3" (skosimp*) (assert))
                                  ("4" (skosimp*) (assert))))
                                ("2" (skosimp*) (assert))
                                ("3" (skosimp*) (assert))))
                              ("3" (skosimp*) (assert))
                              ("4" (skosimp*) (assert))))
                            ("2" (skosimp*) (assert))
                            ("3" (skosimp*) (assert))))
                          ("2"
                           (hide 2)
                           (inst? -3)
                           (("1"
                             (assert)
                             (lemma "end_series_conv")
                             (inst?)
                             (assert)
                             (skosimp*)
                             (assert))
                            ("2" (assert) (skosimp*) (assert))))
                          ("3"
                           (hide 2)
                           (lemma "conv_scaf2[T]")
                           (inst?)
                           (inst - "x!1")
                           (assert)
                           (inst?)
                           (("1" (skosimp*) (assert))
                            ("2" (assert) (skosimp*) (assert))))))
                        ("2"
                         (skosimp*)
                         (assert)
                         (hide 2)
                         (lift-if)
                         (ground)
                         (case-replace "k!1 = 1")
                         (("1" (assert)) ("2" (assert))))
                        ("3"
                         (hide 2)
                         (lemma "conv_scaf3[T]")
                         (inst?)
                         (inst?)
                         (assert)
                         (inst?)
                         (assert))
                        ("4"
                         (hide 2)
                         (expand "conv_series?")
                         (lemma "conv_scaf2[T]")
                         (inst?)
                         (inst - "x!1")
                         (assert)
                         (inst?))))
                      ("2" (skosimp*) (assert))
                      ("3" (skosimp*) (assert))))
                    ("2"
                     (hide 2)
                     (replace -3 * rl)
                     (expand "inf_sum")
                     (expand "powerseries")
                     (rewrite "limit_diff" :dir rl)
                     (rewrite "series_diff")
                     (expand "powerseq")
                     (expand "-")
                     (case-replace
                      "(LAMBDA (x: nat):
                                                                                                                                                                                                                                                                                                                                                                                                                                   IF x = 0 THEN a!1(0)
                                                                                                                                                                                                                                                                                                                                                                                                                                   ELSE a!1(x) * (x!1 + x!2) ^ x
                                                                                                                                                                                                                                                                                                                                                                                                                                   ENDIF
                                                                                                                                                                                                                                                                                                                                                                                                                                    - IF x = 0 THEN a!1(0) ELSE a!1(x) * x!1 ^ x ENDIF) =
                                                                                                                                                                                                                                                                                                                                                                                                                                   (LAMBDA (x: nat):
                                                                                                                                                                                                                                                                                                                                                                                                                                   IF x = 0 THEN 0
                                                                                                                                                                                                                                                                                                                                                                                                                                   ELSE a!1(x) * (x!1 + x!2) ^ x - a!1(x) * x!1 ^ x ENDIF)")
                     (("1"
                       (hide -1)
                       (hide -)
                       (lemma "limit_scal")
                       (inst?)
                       (inst - "1/x!2")
                       (replace -1 * rl)
                       (hide -1)
                       (rewrite "series_scal")
                       (rewrite "series_first" +)
                       (("1" (assert))
                        ("2"
                         (hide 2)
                         (case-replace
                          "(LAMBDA (x_1: nat):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     1 / x!2 *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IF x_1 = 0 THEN 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ELSE a!1(x_1) * (x!1 + x!2) ^ x_1 -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            a!1(x_1) * x!1 ^ x_1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ENDIF) = (LAMBDA k:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       a!1(k) * (((x!1 + x!2) ^ k - x!1 ^ k) / x!2))")
                         (("1"
                           (hide -1)
                           (lemma "conv_scaf3[T]")
                           (inst?)
                           (expand "conv_series?")
                           (assert)
                           (inst - "x!1")
                           (inst - "x!2")
                           (lemma "end_series_conv")
                           (inst?)
                           (assert))
                          ("2"
                           (hide 2)
                           (apply-extensionality 1 :hide? t)
                           (lift-if)
                           (ground)
                           (replace -1)
                           (assert))))))
                      ("2"
                       (hide 2)
                       (apply-extensionality 1 :hide? t)
                       (lift-if)
                       (ground))))
                    ("3"
                     (hide 2)
                     (hide -1 -2 -3)
                     (expand "conv_series?")
                     (lemma "conv_scaf3[T]")
                     (inst?)
                     (inst - "x!1")
                     (assert)
                     (inst - "x!2")
                     (expand "conv_series?")
                     (propax))))
                  ("2"
                   (skosimp*)
                   (lemma "Gseq_conv[T]")
                   (inst?)
                   (inst?)
                   (assert))
                  ("3"
                   (lemma "not_one_element")
                   (skosimp*)
                   (lemma "deriv_domain")
                   (propax))))
                ("3"
                 (hide 2)
                 (lemma "deriv_domain")
                 (expand "deriv_domain?")
                 (skosimp*)
                 (lemma "Gseq_conv")
                 (inst - "a!1" "x!1")
                 (assert)
                 (inst?))
                ("4"
                 (hide 2)
                 (lemma "Gseq_conv")
                 (inst?)
                 (assert)
                 (skosimp*)
                 (lemma "deriv_domain")
                 (propax))))
              ("2" (expand "not_one_element?") (propax))))
            ("2" (replace -1 * rl) (assert))))
          ("2" (propax))))
        ("2" (propax))))))
    ("2" (lemma "deriv_domain") (propax))))


