# Proofs

proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (n: nat):
                                             n >= 12 IMPLIES sin_term(pi_lbn(n+1))(2 * n + 2) < sin(pi_lbn(n+1))")
   (("1"
     (skeep)
     (inst - "n")
     (assert)
     (case "n = 11")
     (("1"
       (replace -1)
       (assert)
       (lemma "sin_bounds")
       (inst - "pi_lbn(12)" "14")
       (flatten)
       (invoke (case "%1 < %2") (! 2 1) (! -1 1))
       (("1" (assert)) ("2" (hide-all-but 1) (eval-formula))))
      ("2" (assert))))
    ("2"
     (hide 2)
     (case "FORALL (n: nat):
                                                                                                                             n >= 20 IMPLIES sin_term(pi_lbn(n+1))(2 * n + 2) < sin(pi_lbn(n+1))")
     (("1"
       (case "FORALL (nnn: subrange(12,20)):
                                                                                                                                                           sin_term(pi_lbn(nnn+1))(2 * nnn + 2) < sin_lb(pi_lbn(nnn+1),nnn)")
       (("1"
         (skeep)
         (inst -2 "n")
         (assert)
         (inst - "n")
         (lemma "sin_bounds")
         (inst - "pi_lbn(n+1)" "n")
         (flatten)
         (assert))
        ("2" (hide-all-but 1) (eval-formula))))
      ("2"
       (hide 2)
       (lemma "sin_px")
       (skosimp*)
       (lemma "sin_pi_minus")
       (inst?)
       (replace -1 :dir rl)
       (inst?)
       (("1"
         (split -)
         (("1"
           (lemma "pi_bounds")
           (inst - "n!1+1+1")
           (flatten)
           (lemma "pi_lbn_lt")
           (inst - "n!1+1")
           (case "pi-pi_lbn(n!1+1) >= pi_lbn(n!1+1+1)-pi_lbn(n!1+1)")
           (("1"
             (mult-by -1 "(1 - 1 / 1500000)")
             (name "KZ" "pi_lbn(n!1+1+1)-pi_lbn(n!1+1)")
             (case "sin_term(pi_lbn(n!1+1))(2 * n!1 + 2) <= (1 - 1 / 1500000)*KZ")
             (("1" (assert))
              ("2"
               (lemma "pi_lb_diff_bounds")
               (inst?)
               (assert)
               (flatten)
               (case "FORALL (nn:nat): nn>=20 IMPLIES sin_term(pi_lbn(nn+1))(2 + 2 * nn) < (1-1/1500000  )*14 * (1 / 5) ^ (10 + 5 * nn)")
               (("1" (inst - "n!1") (assert))
                ("2"
                 (hide-all-but 1)
                 (induct "nn")
                 (("1" (assert))
                  ("2"
                   (skeep)
                   (case "j < 19")
                   (("1" (assert))
                    ("2"
                     (case "j = 19")
                     (("1" (replace -1) (hide-all-but 2) (eval-formula))
                      ("2"
                       (case "NOT j>=20")
                       (("1" (assert))
                        ("2"
                         (hide (1 2))
                         (name "M" "1-1 / 1500000")
                         (replaces -1)
                         (assert)
                         (expand "sin_term")
                         (case "FORALL (k:nat): (-1)^(2*k) = 1")
                         (("1"
                           (inst-cp - "1+j")
                           (inst - "2+j")
                           (assert)
                           (replaces -1)
                           (replaces -1)
                           (assert)
                           (case "FORALL (aa:real): 1*aa = aa")
                           (("1"
                             (rewrite -1)
                             (rewrite -1)
                             (hide -1)
                             (lemma "pi_lb_quot_bounds")
                             (inst - "j+1")
                             (skoletin -1 :old? t)
                             (flatten)
                             (name "disepsi"
                                   "(1 - 14.5 * (1 / 5) ^ (4 * j + 7))")
                             (case "disepsi > 0")
                             (("1"
                               (name "epsi" "1/(disepsi)")
                               (("1"
                                 (replace -3)
                                 (case "epsi > 1")
                                 (("1"
                                   (case
                                    "((epsi*pi_lbn(j+1)) ^ (9 + 4 * j)) / factorial(9 + 4 * j) <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     14 * (((1 / 5) ^ (15 + 5 * j)) * M)")
                                   (("1"
                                     (case
                                      "pi_lbn(2+ j) <= epsi*pi_lbn(1+j)")
                                     (("1"
                                       (lemma
                                        "both_sides_expt_pos_lt_aux")
                                       (inst
                                        -
                                        "8+4*j"
                                        "pi_lbn(2 + j)"
                                        "epsi * pi_lbn(1+j)")
                                       (("1"
                                         (assert)
                                         (mult-by
                                          -1
                                          "1/factorial(9+4*j)")
                                         (expand "^")
                                         (assert))
                                        ("2" (assert))))
                                      ("2"
                                       (hide -1)
                                       (expand "xquot" -6)
                                       (cross-mult -6)
                                       (expand "epsi" 1)
                                       (cross-mult 1))))
                                    ("2"
                                     (hide 2)
                                     (case
                                      "epsi^(9+4*j) * pi_lbn(j+1)^4/((9+4*j)*(8+4*j)*(7+4*j)*(6+4*j)) < (1/5)^5")
                                     (("1"
                                       (mult-ineq -1 -10)
                                       (invoke
                                        (case "%1 = %2")
                                        (! -1 1)
                                        (! 1 1))
                                       (("1"
                                         (invoke
                                          (case "%1 = %2")
                                          (! -2 2)
                                          (! 1 2))
                                         (("1"
                                           (replace -1 :dir rl)
                                           (replace -2)
                                           (propax))
                                          ("2"
                                           (hide (-1 -2 -3))
                                           (assert)
                                           (lemma "expt_plus")
                                           (inst - "10+5*j" "5" "1/5")
                                           (assert))))
                                        ("2"
                                         (case
                                          "((9 + 4 * j) * (8 + 4 * j) * (7 + 4 * j) * (6 + 4 * j))*factorial(5 + 4 * j) = factorial(9 + 4 * j)")
                                         (("1"
                                           (case
                                            "(epsi ^ (9 + 4 * j) * pi_lbn(j+1) ^ 4)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           * (pi_lbn(j+1) ^ (5 + 4 * j)) = (epsi * pi_lbn(j+1)) ^ (9 + 4 * j)")
                                           (("1" (assert))
                                            ("2"
                                             (hide (-1 -2 -3 2 3))
                                             (lemma "mult_expt")
                                             (inst
                                              -
                                              "9+4*j"
                                              "epsi"
                                              "pi_lbn(j+1)")
                                             (replaces -1)
                                             (hide -1)
                                             (lemma "expt_plus")
                                             (inst
                                              -
                                              "5+4*j"
                                              "4"
                                              "pi_lbn(j+1)")
                                             (assert))))
                                          ("2"
                                           (hide (-1 -2 2 3))
                                           (invoke
                                            (name "ej1" "%1")
                                            (! 1 1 1))
                                           (invoke
                                            (name "ej2" "%1")
                                            (! 1 1 2))
                                           (invoke
                                            (name "ej3" "%1")
                                            (! 1 1 3))
                                           (invoke
                                            (name "ej4" "%1")
                                            (! 1 1 4))
                                           (replace -1)
                                           (replace -2)
                                           (replace -3)
                                           (replace -4)
                                           (expand "factorial" + 2)
                                           (assert)
                                           (case "ej1 -1 = ej2")
                                           (("1"
                                             (replaces -1)
                                             (expand "factorial" + 2)
                                             (case "ej2 -1 = ej3")
                                             (("1"
                                               (replaces -1)
                                               (expand "factorial" + 2)
                                               (case "ej3-1 = ej4")
                                               (("1"
                                                 (replaces -1)
                                                 (expand "factorial" + 2)
                                                 (assert))
                                                ("2" (assert))))
                                              ("2" (assert))))
                                            ("2" (assert))))))))
                                      ("2"
                                       (hide 2)
                                       (case
                                        "epsi ^ (9 + 4 * j) * pi_lbn(j+1) ^ 4 <= 1.1*3.1415927^4")
                                       (("1"
                                         (mult-by
                                          -1
                                          "1/((9 + 4 * j) * (8 + 4 * j) * (7 + 4 * j) * (6 + 4 * j))")
                                         (invoke
                                          (case "%1 < %2")
                                          (! -1 2)
                                          (! 1 2))
                                         (("1" (assert))
                                          ("2"
                                           (hide 2)
                                           (hide -1)
                                           (name "RD" "j-18")
                                           (case "j = RD+18 AND RD>=0")
                                           (("1"
                                             (hide-all-but (-1 1))
                                             (flatten)
                                             (replace -1)
                                             (case
                                              "EXISTS (RD2:nat): RD2 = RD")
                                             (("1"
                                               (skeep -1)
                                               (replace -1 :dir rl)
                                               (hide -)
                                               (assert)
                                               (cross-mult 1)
                                               (grind))
                                              ("2" (inst + "RD"))))
                                            ("2" (assert))))))
                                        ("2"
                                         (hide 2)
                                         (invoke
                                          (case "%1 < %2 AND %3 < %4")
                                          (! 1 1 1)
                                          (! 1 2 1)
                                          (! 1 1 2)
                                          (! 1 2 2))
                                         (("1"
                                           (flatten)
                                           (mult-ineq -1 -2)
                                           (assert))
                                          ("2"
                                           (split 1)
                                           (("1"
                                             (hide-all-but (-8 1))
                                             (expand "epsi")
                                             (expand "disepsi")
                                             (name
                                              "egrange"
                                              "(1 - 14.5 * (1 / 5) ^ (7 + 4 * j))")
                                             (replace -1)
                                             (name
                                              "alpha"
                                              "14.5 * (1 / 5) ^ (7 + 4 * j)")
                                             (case "alpha < 1/3")
                                             (("1"
                                               (case
                                                "1/egrange < 1+2*alpha")
                                               (("1"
                                                 (case
                                                  "(1+2*alpha)^(9+4*j) < 1.1")
                                                 (("1"
                                                   (lemma
                                                    "both_sides_expt_pos_lt_aux")
                                                   (inst
                                                    -
                                                    "8+4*j"
                                                    "1/egrange"
                                                    "1+2*alpha")
                                                   (("1"
                                                     (expand "^")
                                                     (assert))
                                                    ("2"
                                                     (assert)
                                                     (case "egrange > 0")
                                                     (("1"
                                                       (split +)
                                                       (("1"
                                                         (cross-mult 1))
                                                        ("2"
                                                         (cross-mult
                                                          1))))
                                                      ("2"
                                                       (hide 2)
                                                       (case
                                                        "14.5*(1/5)^(7+4*j) < 1")
                                                       (("1" (assert))
                                                        ("2"
                                                         (rewrite
                                                          "div_expt"
                                                          1)
                                                         (case
                                                          "FORALL (nnm:nat): 1^nnm = 1")
                                                         (("1"
                                                           (rewrite -1)
                                                           (case
                                                            "FORALL (kkr:nat): 14.5 * (1 / 5 ^ (7 + kkr)) < 1")
                                                           (("1" (inst?))
                                                            ("2"
                                                             (hide-all-but
                                                              1)
                                                             (induct
                                                              "kkr")
                                                             (("1"
                                                               (grind))
                                                              ("2"
                                                               (skosimp*)
                                                               (assert)
                                                               (expand
                                                                "^")
                                                               (expand
                                                                "expt"
                                                                +
                                                                1)
                                                               (assert))))))
                                                          ("2"
                                                           (hide-all-but
                                                            1)
                                                           (induct "nnm")
                                                           (("1" (grind))
                                                            ("2"
                                                             (skosimp*)
                                                             (expand "^")
                                                             (expand
                                                              "expt"
                                                              +)
                                                             (assert))))))))))))
                                                  ("2"
                                                   (expand "alpha" 1)
                                                   (assert)
                                                   (name
                                                    "FF"
                                                    "LAMBDA (jj:nat): (1 + 2 * (14.5 * (1 / 5) ^ (jj))) ^ (jj+2)")
                                                   (case
                                                    "FORALL (jj:nat): jj>=83 IMPLIES FF(jj) < 1.1")
                                                   (("1"
                                                     (inst - "7+4*j")
                                                     (assert)
                                                     (expand "FF" -1)
                                                     (propax))
                                                    ("2"
                                                     (hide-all-but 1)
                                                     (induct "jj")
                                                     (("1" (assert))
                                                      ("2"
                                                       (skosimp*)
                                                       (case "j!1 = 82")
                                                       (("1"
                                                         (replace -1)
                                                         (eval-formula))
                                                        ("2"
                                                         (assert)
                                                         (hide 1)
                                                         (expand "FF" +)
                                                         (case
                                                          "FORALL (egv:nnreal): egv^(3+j!1) = egv^(2+j!1)*egv")
                                                         (("1"
                                                           (inst?)
                                                           (replace -1)
                                                           (hide -1)
                                                           (invoke
                                                            (case
                                                             "%1 < 1.0001 AND (%2-1) <= (1/5)*(FF(j!1)-1)")
                                                            (! 1 1 2)
                                                            (! 1 1 1))
                                                           (("1"
                                                             (flatten)
                                                             (both-sides
                                                              "+"
                                                              "1"
                                                              -2)
                                                             (mult-ineq
                                                              -1
                                                              -2)
                                                             (assert))
                                                            ("2"
                                                             (hide 2)
                                                             (split)
                                                             (("1"
                                                               (case
                                                                "FORALL (kkj:nat): kkj >= 75 IMPLIES (1 + 2 * (14.5 * (1 / 5) ^ (kkj))) < 1.0001")
                                                               (("1"
                                                                 (inst?)
                                                                 (assert))
                                                                ("2"
                                                                 (hide-all-but
                                                                  1)
                                                                 (induct
                                                                  "kkj")
                                                                 (("1"
                                                                   (assert))
                                                                  ("2"
                                                                   (skosimp*)
                                                                   (case
                                                                    "j!2 = 74")
                                                                   (("1"
                                                                     (replace
                                                                      -1)
                                                                     (hide
                                                                      -)
                                                                     (eval-formula))
                                                                    ("2"
                                                                     (assert)
                                                                     (expand
                                                                      "^")
                                                                     (expand
                                                                      "expt"
                                                                      +)
                                                                     (assert))))))))
                                                              ("2"
                                                               (expand
                                                                "FF")
                                                               (name
                                                                "K1"
                                                                "2 * (14.5 * (1 / 5) ^ (j!1))")
                                                               (replace
                                                                -1)
                                                               (case
                                                                "2 * (14.5 * (1 / 5) ^ (1+j!1)) = (1/5)*K1")
                                                               (("1"
                                                                 (replace
                                                                  -1)
                                                                 (name
                                                                  "pj"
                                                                  "2+j!1")
                                                                 (replace
                                                                  -1)
                                                                 (lemma
                                                                  "binomial_theorem")
                                                                 (inst-cp
                                                                  -
                                                                  "pj"
                                                                  "1"
                                                                  "(1/5)*K1")
                                                                 (inst
                                                                  -
                                                                  "pj"
                                                                  "1"
                                                                  "K1")
                                                                 (replaces
                                                                  -1)
                                                                 (replaces
                                                                  -1)
                                                                 (expand
                                                                  "sigma"
                                                                  +
                                                                  1)
                                                                 (assert)
                                                                 (case
                                                                  "C(pj, pj) * 1 ^ pj * ((1 / 5) * K1) ^ 0 = 1")
                                                                 (("1"
                                                                   (replaces
                                                                    -1)
                                                                   (assert)
                                                                   (expand
                                                                    "sigma"
                                                                    +
                                                                    2)
                                                                   (case
                                                                    "C(pj, pj) * 1 ^ pj * K1 ^ 0 = 1")
                                                                   (("1"
                                                                     (replaces
                                                                      -1)
                                                                     (assert)
                                                                     (rewrite
                                                                      "sigma_scal"
                                                                      :dir
                                                                      rl)
                                                                     (("1"
                                                                       (rewrite
                                                                        "sigma_le")
                                                                       (("1"
                                                                         (hide
                                                                          2)
                                                                         (skeep)
                                                                         (rewrite
                                                                          "mult_expt"
                                                                          +)
                                                                         (case
                                                                          "(1 / 5) ^ (pj - n) <= 1/5")
                                                                         (("1"
                                                                           (mult-by
                                                                            -1
                                                                            "C(pj, n) * 1 ^ n * K1 ^ (pj - n)")
                                                                           (assert))
                                                                          ("2"
                                                                           (case
                                                                            "FORALL (kkr:nat): (1/5)^(kkr+1) <= 1/5")
                                                                           (("1"
                                                                             (inst-cp
                                                                              -
                                                                              "pj-n-1")
                                                                             (assert))
                                                                            ("2"
                                                                             (hide-all-but
                                                                              1)
                                                                             (induct
                                                                              "kkr")
                                                                             (("1"
                                                                               (grind))
                                                                              ("2"
                                                                               (skosimp*)
                                                                               (expand
                                                                                "^")
                                                                               (expand
                                                                                "expt"
                                                                                +)
                                                                               (assert))))))))
                                                                        ("2"
                                                                         (skosimp*)
                                                                         (assert))))
                                                                      ("2"
                                                                       (skosimp*)
                                                                       (assert))))
                                                                    ("2"
                                                                     (hide-all-but
                                                                      1)
                                                                     (case
                                                                      "FORALL (e1,e2,e3:real): e1=1 AND e2=1 AND e3=1 IMPLIES e1*e2*e3=1")
                                                                     (("1"
                                                                       (rewrite
                                                                        -1)
                                                                       (("1"
                                                                         (hide-all-but
                                                                          1)
                                                                         (expand
                                                                          "C")
                                                                         (assert))
                                                                        ("2"
                                                                         (hide-all-but
                                                                          1)
                                                                         (case
                                                                          "FORALL (egv2:nat): 1^egv2 = 1")
                                                                         (("1"
                                                                           (inst?))
                                                                          ("2"
                                                                           (induct
                                                                            "egv2")
                                                                           (("1"
                                                                             (grind))
                                                                            ("2"
                                                                             (skosimp*)
                                                                             (expand
                                                                              "^")
                                                                             (expand
                                                                              "expt"
                                                                              1)
                                                                             (assert))))))
                                                                        ("3"
                                                                         (hide-all-but
                                                                          1)
                                                                         (grind))))
                                                                      ("2"
                                                                       (hide-all-but
                                                                        1)
                                                                       (grind))))))
                                                                  ("2"
                                                                   (hide-all-but
                                                                    1)
                                                                   (case
                                                                    "FORALL (e1,e2,e3:real): e1=1 AND e2=1 AND e3=1 IMPLIES e1*e2*e3=1")
                                                                   (("1"
                                                                     (rewrite
                                                                      -1)
                                                                     (("1"
                                                                       (hide-all-but
                                                                        1)
                                                                       (expand
                                                                        "C")
                                                                       (assert))
                                                                      ("2"
                                                                       (hide-all-but
                                                                        1)
                                                                       (case
                                                                        "FORALL (egv2:nat): 1^egv2 = 1")
                                                                       (("1"
                                                                         (inst?))
                                                                        ("2"
                                                                         (induct
                                                                          "egv2")
                                                                         (("1"
                                                                           (grind))
                                                                          ("2"
                                                                           (skosimp*)
                                                                           (expand
                                                                            "^")
                                                                           (expand
                                                                            "expt"
                                                                            1)
                                                                           (assert))))))
                                                                      ("3"
                                                                       (hide-all-but
                                                                        1)
                                                                       (grind))))
                                                                    ("2"
                                                                     (hide-all-but
                                                                      1)
                                                                     (grind))))))
                                                                ("2"
                                                                 (expand
                                                                  "^")
                                                                 (expand
                                                                  "expt"
                                                                  1)
                                                                 (assert))))))))
                                                          ("2"
                                                           (hide-all-but
                                                            1)
                                                           (skeep)
                                                           (expand "^")
                                                           (expand
                                                            "expt"
                                                            +
                                                            1)
                                                           (assert))))))))))))
                                                ("2"
                                                 (replace -2)
                                                 (replace -3 :dir rl)
                                                 (cross-mult 1)
                                                 (assert)
                                                 (case
                                                  "alpha > 2*sq(alpha)")
                                                 (("1"
                                                   (expand "sq")
                                                   (assert))
                                                  ("2"
                                                   (hide-all-but (-1 1))
                                                   (cross-mult -1)
                                                   (mult-by -1 "alpha")
                                                   (expand "sq")
                                                   (assert))))))
                                              ("2"
                                               (assert)
                                               (expand "alpha" +)
                                               (case
                                                "FORALL (kkp:nat): kkp>=70 IMPLIES 14.5 * (1 / 5) ^ (kkp) < 1 / 3")
                                               (("1" (inst?) (assert))
                                                ("2"
                                                 (induct "kkp")
                                                 (("1" (assert))
                                                  ("2"
                                                   (skosimp*)
                                                   (case "j!1 = 69")
                                                   (("1"
                                                     (replace -1)
                                                     (hide-all-but 1)
                                                     (eval-formula))
                                                    ("2"
                                                     (assert)
                                                     (expand "^")
                                                     (expand "expt" 2)
                                                     (assert))))))))))
                                            ("2"
                                             (lemma
                                              "both_sides_expt_pos_lt_aux")
                                             (inst
                                              -
                                              "3"
                                              "pi_lbn(j+1)"
                                              "3.1415927")
                                             (assert)
                                             (expand "^")
                                             (assert)
                                             (hide-all-but 1)
                                             (lemma "pi_bounds")
                                             (inst?)
                                             (flatten)
                                             (lemma "pi_bounds")
                                             (inst - "10")
                                             (flatten)
                                             (eval-expr "pi_ubn(10)")
                                             (assert))))))))))))
                                  ("2"
                                   (expand "epsi" +)
                                   (cross-mult 1)
                                   (assert))))
                                ("2" (assert))))
                              ("2"
                               (assert)
                               (case "FORALL (kkp:nat): kkp>=3 IMPLIES 14.5 * (1 / 5) ^ (kkp) < 1")
                               (("1" (inst?) (assert))
                                ("2"
                                 (induct "kkp")
                                 (("1" (assert))
                                  ("2"
                                   (skosimp*)
                                   (case "j!1 = 2")
                                   (("1"
                                     (replace -1)
                                     (hide-all-but 1)
                                     (grind))
                                    ("2"
                                     (assert)
                                     (expand "^")
                                     (expand "expt" +)
                                     (assert))))))))))
                            ("2" (assert))))
                          ("2"
                           (hide-all-but 1)
                           (induct "k")
                           (("1" (grind))
                            ("2"
                             (skosimp*)
                             (expand "^")
                             (expand "expt" +)
                             (expand "expt" +)
                             (assert))))))))))))))))))
            ("2" (lemma "pi_bounds") (inst - "n!1+1") (ground))))
          ("2"
           (case "FORALL (kkp:nat): kkp>=20 IMPLIES 1 / 500 > pi - pi_lbn(kkp)")
           (("1" (inst?) (assert))
            ("2"
             (hide-all-but 1)
             (induct "kkp")
             (("1" (assert))
              ("2"
               (skeep)
               (case "j = 19")
               (("1"
                 (replace -1)
                 (lemma "pi_bounds")
                 (inst - "19")
                 (flatten)
                 (case "1/500 > pi_ubn(19)-pi_lbn(20)")
                 (("1" (assert)) ("2" (hide-all-but 1) (eval-formula))))
                ("2"
                 (assert)
                 (lemma "pi_lbn_lt")
                 (inst - "j")
                 (lemma "pi_bounds")
                 (inst-cp - "j")
                 (inst - "1+j")
                 (ground))))))))))
        ("2" (assert) (lemma "pi_bounds") (inst - "n!1+1") (ground))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "sin_approx_sin")
   (case "pi_lbn(n+1) > 0")
   (("1"
     (expand "sin_lb")
     (assert)
     (inst?)
     (assert)
     (case "sin_term(pi_lbn(n+1))(2 + 2 * n) > 0")
     (("1"
       (expand "abs" - 2)
       (assert)
       (lemma "sin_term_pi_lb")
       (inst?)
       (assert))
      ("2"
       (expand "sin_term" +)
       (cross-mult 1)
       (assert)
       (lemma "posreal_times_posreal_is_posreal")
       (inst?)
       (("1" (assert))
        ("2"
         (case "FORALL (kn:nat): (-1)^(2*kn) = 1")
         (("1" (inst - "1+n") (assert))
          ("2"
           (hide-all-but 1)
           (induct "kn")
           (("1" (grind))
            ("2"
             (skosimp*)
             (expand "^")
             (expand "expt" +)
             (expand "expt" +)
             (assert))))))))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "sin_lb_pi_pos")
   (inst - "n")
   (case "n>=12")
   (("1" (assert) (expand "pi_lb_est") (propax))
    ("2"
     (case "FORALL (nn:below(12)): sin_lb(pi_lb_est(nn + 1), nn) > 0")
     (("1" (inst - "n") (assert))
      ("2" (hide-all-but 1) (eval-formula))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "NOT FORALL (pxx:posreal): pxx <= 1.8 IMPLIES sin_lb(pxx,n) > 0")
   (("1"
     (hide-all-but 1)
     (skeep)
     (case "sin_lb(pxx,0) > 0")
     (("1"
       (lemma "sin_lb_inc")
       (inst - "0" "n" "pxx")
       (("1"
         (assert)
         (lemma "sq_lt")
         (inst - "pxx" "1.8")
         (assert)
         (expand "sq" -1)
         (assert))
        ("2" (assert))))
      ("2"
       (case "1 > pxx^2/6")
       (("1" (mult-by -1 "pxx") (hide 2) (grind))
        ("2"
         (hide 2)
         (hide 2)
         (cross-mult 1)
         (lemma "sq_lt")
         (inst - "pxx" "1.8")
         (grind))))))
    ("2"
     (inst-cp - "px")
     (assert)
     (lemma "mean_value[nnreal]")
     (("1"
       (inst -2 "1.8")
       (assert)
       (inst - "px" "pi_lb_est(1+n)" "LAMBDA (x:nnreal): sin_lb(x,n)")
       (assert)
       (lemma "sin_lb_deriv")
       (inst?)
       (flatten)
       (assert)
       (lemma "sin_lb_pi_est_pos")
       (inst - "n")
       (assert)
       (skeep -4)
       (decompose-equality -3)
       (inst - "c")
       (expand "deriv" -1)
       (replace -1)
       (assert)
       (case "cos_lb(c,n) < 0")
       (("1" (mult-by -1 "pi_lb_est(n+1)-px") (assert))
        ("2"
         (lemma "cos_lb_nn_strict_decreasing")
         (inst - "n")
         (expand "strict_decreasing?")
         (inst - "1.8" "c")
         (assert)
         (case "cos_lb(1.8,n) < 0")
         (("1" (assert))
          ("2"
           (hide-all-but 1)
           (case "NOT FORALL (ii:below(10)): cos_lb(1.8,ii) < 0")
           (("1" (eval-formula))
            ("2"
             (case "n < 10")
             (("1" (inst - "n"))
              ("2"
               (assert)
               (hide -)
               (lemma "cos_bounds")
               (inst - "1.8" "n")
               (flatten)
               (lemma "cos_ub_dec")
               (inst - "8" "1.8" "n-8")
               (assert)
               (case "cos_ub(1.8,8) < 0")
               (("1" (assert)) ("2" (eval-formula))))))))))))
      ("2" (lemma "connected_nnreal") (propax))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "strict_decreasing?")
   (skosimp*)
   (typepred "x!1")
   (typepred "y!1")
   (expand ">=")
   (lemma "cos_ub_deriv")
   (inst - "n!1")
   (flatten)
   (lemma "mean_value[real]")
   (("1"
     (inst - "x!1" "y!1" "LAMBDA (xnn:real): cos_ub(xnn,n!1)")
     (assert)
     (skeep -1)
     (decompose-equality -5)
     (inst - "c")
     (assert)
     (expand "deriv" -1)
     (replaces -1)
     (hide -1)
     (lemma "sin_lb_pi_range_pos")
     (inst - "n!1-1" "c")
     (assert)
     (mult-by -1 "y!1 - x!1")
     (assert))
    ("2" (lemma "connected_real") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp)
   (lemma "cos_ub_nn_strict_decreasing" ("n" "n!1"))
   (assert)
   (expand "strict_decreasing?")
   (expand "strict_increasing?")
   (skosimp)
   (inst - "-y!1" "-x!1")
   (assert)
   (rewrite "cos_ub_neg")
   (rewrite "cos_ub_neg"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (n: nat):
                               strict_increasing?(LAMBDA (x:
                                                            {x: nnreal |
                                                             x <= pi_lb_est(n) / 2}):
                                                    sin_lb(x, n))")
   (("1"
     (case "FORALL (n: nat):
                                     strict_increasing?(LAMBDA (x:
                                                                  {x: nnreal |
                                                                   x <= pi_lb_est(n) / 2}):
                                                          sin_ub(x, n))")
     (("1"
       (skeep)
       (inst - "n")
       (inst - "n")
       (expand "strict_increasing?")
       (skeep)
       (case "x_1 >= 0")
       (("1" (inst -3 "x_1" "y") (("1" (assert)) ("2" (assert))))
        ("2"
         (case "y<=0")
         (("1"
           (inst - "-y" "-x_1")
           (("1"
             (assert)
             (rewrite "sin_ub_neg")
             (rewrite "sin_ub_neg")
             (assert))
            ("2" (assert)) ("3" (assert))))
          ("2"
           (assert)
           (hide (-1 -2))
           (case "sin_lb(x_1,n) <= 0 AND 0< sin_lb(y,n)")
           (("1" (ground))
            ("2"
             (hide 4)
             (split)
             (("1"
               (lemma "sin_bounds")
               (inst - "x_1" "n")
               (flatten)
               (lemma "sin_le_0")
               (inst - "x_1 + 2*pi")
               (assert)
               (lemma "sin_period")
               (inst - "x_1" "1")
               (assert)
               (case "-x_1 < pi")
               (("1" (assert)) ("2" (typepred "x_1") (assert))))
              ("2"
               (lemma "sin_lb_pi_range_pos")
               (inst - "n" "y")
               (assert)
               (typepred "y")
               (assert)
               (case "pi_lb_est(n) <= pi_lb_est(1+n)")
               (("1" (assert))
                ("2"
                 (case "n<=20")
                 (("1"
                   (case "FORALL (nn:below(23)): pi_lb_est(nn) <= pi_lb_est(1+nn)")
                   (("1" (inst - "n") (assert)) ("2" (eval-formula))))
                  ("2"
                   (expand "pi_lb_est" 2)
                   (assert)
                   (lemma "pi_lbn_lt")
                   (inst - "n")
                   (assert))))))))))))))
      ("2"
       (hide-all-but 1)
       (skosimp*)
       (expand "strict_increasing?")
       (skosimp*)
       (lemma "sin_ub_deriv")
       (inst - "n!1")
       (assert)
       (flatten)
       (lemma "mean_value[nnreal]")
       (("1"
         (inst - "x!1" "y!1" "LAMBDA (xnn:nnreal): sin_ub(xnn,n!1)")
         (assert)
         (skeep -1)
         (decompose-equality -5)
         (inst - "c")
         (assert)
         (expand "deriv" -1)
         (replaces -1)
         (case "cos_ub(c,n!1) > 0")
         (("1" (mult-by -1 "y!1-x!1") (assert))
          ("2"
           (lemma "cos_bounds")
           (inst - "c" "n!1")
           (flatten)
           (lemma "cos_gt_0")
           (inst - "c")
           (assert)
           (typepred "x!1")
           (typepred "y!1")
           (assert))))
        ("2" (lemma "connected_nnreal") (propax))))))
    ("2"
     (hide 2)
     (skosimp*)
     (expand "strict_increasing?")
     (skosimp*)
     (lemma "sin_lb_deriv")
     (inst - "n!1")
     (assert)
     (flatten)
     (lemma "mean_value[nnreal]")
     (("1"
       (inst - "x!1" "y!1" "LAMBDA (xnn:nnreal): sin_lb(xnn,n!1)")
       (assert)
       (skeep -1)
       (decompose-equality -5)
       (inst - "c")
       (assert)
       (expand "deriv" -1)
       (replaces -1)
       (case "cos_lb(c,n!1) > 0")
       (("1" (mult-by -1 "y!1-x!1") (assert))
        ("2"
         (lemma "cos_lb_pi2_pos")
         (case "FORALL (n: nat): cos_lb(pi_lb_est(n) / 2, n) > 0")
         (("1"
           (hide -2)
           (inst - "n!1")
           (lemma "cos_lb_nn_strict_decreasing")
           (inst - "n!1")
           (assert)
           (expand "strict_decreasing?")
           (inst - "c" "pi_lb_est(n!1)/2")
           (assert))
          ("2"
           (case "FORALL (egv1:below(12)): cos_lb(pi_lb_est(egv1)/2,egv1) > 0")
           (("1"
             (skeep)
             (case "n < 12")
             (("1" (inst - "n"))
              ("2"
               (inst -2 "n")
               (assert)
               (expand "pi_lb_est")
               (propax))))
            ("2" (eval-formula))))))))
      ("2" (lemma "connected_nnreal") (propax))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "FORALL (n: nat):
                                             strict_increasing?(LAMBDA (x:
                                                                          {x: nnreal |
                                                                           x <= pi_lb_est(n) / 2}):
                                                                  sin_ub(x, n))")
   (("1"
     (case "FORALL (n: nat):
                                                       strict_increasing?(LAMBDA (x:
                                                                                    {x: nnreal |
                                                                                     x <= pi_lb_est(n) / 2}):
                                                                            sin_lb(x, n))")
     (("1"
       (inst - "n")
       (inst - "n")
       (expand "strict_increasing?")
       (skeep)
       (case "x_1 >= 0")
       (("1" (inst -3 "x_1" "y") (("1" (assert)) ("2" (assert))))
        ("2"
         (case "y<=0")
         (("1"
           (inst - "-y" "-x_1")
           (("1"
             (assert)
             (rewrite "sin_lb_neg")
             (rewrite "sin_lb_neg")
             (assert))
            ("2" (assert)) ("3" (assert))))
          ("2"
           (assert)
           (hide (-1 -2))
           (case "sin_ub(x_1,n) <= 0 AND 0< sin_ub(y,n)")
           (("1" (ground))
            ("2"
             (hide 4)
             (split)
             (("1"
               (lemma "sin_gt_0")
               (inst - "-x_1")
               (assert)
               (lemma "sin_ub_neg")
               (inst - "-x_1" "n")
               (assert)
               (replace -1)
               (lemma "sin_lb_pi_range_pos")
               (inst - "n" "-x_1")
               (assert)
               (typepred "x_1")
               (assert)
               (assert)
               (case "pi_lb_est(n) < pi_lb_est(n+1)")
               (("1" (assert))
                ("2"
                 (hide-all-but 1)
                 (case "n < 12")
                 (("1"
                   (case "FORALL (nn:below(12)): pi_lb_est(nn) < pi_lb_est(nn+1)")
                   (("1" (inst?)) ("2" (eval-formula))))
                  ("2"
                   (expand "pi_lb_est")
                   (assert)
                   (lemma "pi_lbn_lt")
                   (inst?)
                   (assert))))))
              ("2"
               (lemma "sin_gt_0")
               (inst - "y")
               (assert)
               (lemma "sin_bounds")
               (inst?)
               (flatten)
               (assert)
               (typepred "y")
               (assert))))))))))
      ("2"
       (hide-all-but 1)
       (skosimp*)
       (expand "strict_increasing?")
       (skosimp*)
       (lemma "sin_lb_deriv")
       (inst - "n!1")
       (assert)
       (flatten)
       (lemma "mean_value[nnreal]")
       (("1"
         (inst - "x!1" "y!1" "LAMBDA (xnn:nnreal): sin_lb(xnn,n!1)")
         (assert)
         (skeep -1)
         (decompose-equality -5)
         (inst - "c")
         (assert)
         (expand "deriv" -1)
         (replaces -1)
         (case "cos_lb(c,n!1) > 0")
         (("1" (mult-by -1 "y!1-x!1") (assert))
          ("2"
           (lemma "cos_lb_nn_strict_decreasing")
           (inst - "n!1")
           (expand "strict_decreasing?")
           (inst - "c" "pi_lb_est(n!1)/2")
           (("1"
             (assert)
             (case "NOT FORALL (nn:subrange(0,12)): cos_lb(pi_lb_est(nn)/2,nn) > 0")
             (("1" (eval-formula))
              ("2"
               (case "n!1 < 12")
               (("1" (inst - "n!1") (("1" (assert)) ("2" (assert))))
                ("2"
                 (assert)
                 (lemma "cos_lb_pi2_pos")
                 (inst - "n!1")
                 (assert)
                 (expand "pi_lb_est" -3)
                 (assert))))))
            ("2" (assert)) ("3" (assert) (typepred "y!1") (assert))))))
        ("2" (lemma "connected_nnreal") (propax))))))
    ("2"
     (hide 2)
     (skosimp*)
     (expand "strict_increasing?")
     (skosimp*)
     (lemma "sin_ub_deriv")
     (inst - "n!1")
     (assert)
     (flatten)
     (lemma "mean_value[nnreal]")
     (("1"
       (inst - "x!1" "y!1" "LAMBDA (xnn:nnreal): sin_ub(xnn,n!1)")
       (assert)
       (skeep -1)
       (decompose-equality -5)
       (inst - "c")
       (assert)
       (expand "deriv" -1)
       (replaces -1)
       (case "cos_ub(c,n!1) > 0")
       (("1" (mult-by -1 "y!1-x!1") (assert))
        ("2"
         (lemma "cos_bounds")
         (inst - "c" "n!1")
         (flatten)
         (lemma "cos_gt_0")
         (inst - "c")
         (assert)
         (typepred "x!1")
         (typepred "y!1")
         (assert))))
      ("2" (lemma "connected_nnreal") (propax))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "strict_decreasing?")
   (skosimp*)
   (typepred "x!1")
   (typepred "y!1")
   (lemma "sin_lb_deriv")
   (inst - "n!1")
   (assert)
   (flatten)
   (lemma "mean_value[nnreal]")
   (("1"
     (inst - "x!1" "y!1" "LAMBDA (xnn:nnreal): sin_lb(xnn,n!1)")
     (assert)
     (skeep -1)
     (decompose-equality -5)
     (inst - "c")
     (assert)
     (expand "deriv" -1)
     (replaces -1)
     (case "cos_lb(c,n!1) < 0")
     (("1" (mult-by -1 "y!1-x!1") (assert))
      ("2"
       (hide (-3 -4 2))
       (lemma "cos_lt_0")
       (inst - "c")
       (lemma "cos_bounds")
       (inst - "c" "n!1")
       (ground))))
    ("2" (lemma "connected_nnreal") (propax))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (n:nat):
                              n>=10 IMPLIES -cos_term(pi_ubn(n) / 2)(2 * n + 1) < -cos(pi_ubn(n) / 2)")
   (("1"
     (skeep)
     (case "NOT FORALL (n: subrange(5,10)):
                             -cos_term(pi_ubn(n) / 2)(2 * n + 1) < -cos_ub(pi_ubn(n) / 2,n+4)")
     (("1" (hide 2) (eval-formula))
      ("2"
       (case "n >= 10")
       (("1" (inst -3 "n") (assert))
        ("2"
         (inst - "n")
         (("1"
           (lemma "cos_bounds")
           (inst - "pi_ubn(n)/2" "n+4")
           (ground))
          ("2" (ground))))))))
    ("2"
     (hide 2)
     (skeep)
     (lemma "sin_cos")
     (inst - "pi_ubn(n)/2-pi/2")
     (assert)
     (replace -1 :dir rl)
     (hide -1)
     (lemma "sin_px")
     (inst?)
     (("1"
       (name "M" "1-1 / 1500000")
       (replace -1)
       (name "pd" "pi_ubn(n) / 2 - pi / 2")
       (replace -1)
       (split -)
       (("1"
         (invoke (case "%1 < pd*M") (! 1 1))
         (("1" (assert))
          ("2"
           (hide (2 -1))
           (case "pd >= pi_ubn(n)/2 - pi_ubn(n+1)/2")
           (("1"
             (mult-by -1 "M")
             (lemma "pi_ub_diff_bounds")
             (inst - "n")
             (assert)
             (flatten)
             (invoke (case "%1 < 16 * M * (1 / 5) ^ (3 + 5 * n)")
              (! 1 1))
             (("1" (assert))
              ("2"
               (hide (-1 -2 -3 -4 -5))
               (hide 2)
               (expand "cos_term")
               (case "(-1)^(1+2*n) = -1")
               (("1"
                 (replace -1)
                 (assert)
                 (case "(2) ^ (2 + 4 * n) / factorial(2 + 4 * n) < 16 * ((1 / 5) ^ (3 + 5 * n) * M)")
                 (("1"
                   (assert)
                   (case "(pi_ubn(n) / 2) ^ (2 + 4 * n) < (2) ^ (2 + 4 * n)")
                   (("1" (mult-by -1 "1/factorial(2+4*n)") (assert))
                    ("2"
                     (hide 2)
                     (lemma "both_sides_expt_pos_lt_aux")
                     (inst - "1+4*n" "pi_ubn(n)/2" "2")
                     (expand "^")
                     (assert)
                     (case "FORALL (nn:nat): pi_ubn(nn+10) < 4")
                     (("1" (inst - "n-10") (assert))
                      ("2"
                       (hide-all-but 1)
                       (induct "nn")
                       (("1" (assert) (eval-formula))
                        ("2"
                         (skeep)
                         (assert)
                         (lemma "pi_ub_dec")
                         (inst - "11+j" "10+j")
                         (assert))))))))
                  ("2"
                   (hide 2)
                   (case "FORALL (kk:nat): (2) ^ (2 + 4 * (kk+10)) / factorial(2 + 4 * (kk+10)) <
                                                       16 * ((1 / 5) ^ (3 + 5 * (kk+10)) * M)")
                   (("1" (inst - "n-10") (assert))
                    ("2"
                     (hide-all-but 1)
                     (induct "kk")
                     (("1" (assert) (eval-formula))
                      ("2"
                       (skeep)
                       (assert)
                       (expand "^")
                       (name "eg3" "43+4*j")
                       (name "eg4" "44+4*j")
                       (name "eg5" "45+4*j")
                       (name "eg6" "46+4*j")
                       (case "factorial(46+4*j) = eg6*eg5*eg4*eg3*factorial(42+4*j)")
                       (("1"
                         (replaces -1)
                         (expand "expt" +)
                         (expand "expt" +)
                         (expand "expt" +)
                         (expand "expt" +)
                         (assert)
                         (expand "expt" + 2)
                         (assert)
                         (case "NOT 16/(eg3*eg4*eg5*eg6) < (1/3125)")
                         (("1"
                           (hide-all-but 1)
                           (expand "eg3")
                           (expand "eg4")
                           (expand "eg5")
                           (expand "eg6")
                           (cross-mult 1))
                          ("2" (mult-ineq -1 -6) (assert) (real-props))))
                        ("2"
                         (hide (-5 2))
                         (replace -1)
                         (expand "factorial" + 1)
                         (assert)
                         (case "eg5 = eg6-1")
                         (("1"
                           (replace -1 :dir rl)
                           (expand "factorial" + 1)
                           (assert)
                           (case "eg4 = eg5-1")
                           (("1"
                             (replace -1 :dir rl)
                             (expand "factorial" + 1)
                             (assert)
                             (case "eg3 = eg4-1")
                             (("1"
                               (replace -1 :dir rl)
                               (expand "factorial" + 1)
                               (assert))
                              ("2" (assert))))
                            ("2" (assert))))
                          ("2" (assert))))))))))))
                ("2"
                 (hide 2)
                 (expand "^")
                 (case "FORALL (kk:nat): (-1)^(2*kk+1)=-1")
                 (("1" (inst - "n") (assert) (expand "^") (propax))
                  ("2"
                   (hide-all-but 1)
                   (induct "kk")
                   (("1" (grind))
                    ("2"
                     (skeep)
                     (expand "^")
                     (expand "expt" +)
                     (expand "expt" +)
                     (assert))))))))))
            ("2" (lemma "pi_bounds") (inst - "n+1") (ground))))))
        ("2"
         (case "pi_ubn(n)/2 - pi_lbn(20)/2 < 1/500")
         (("1" (lemma "pi_bounds") (inst - "20") (ground))
          ("2"
           (case "FORALL (nn:nat): pi_ubn(nn+10) / 2 - pi_lbn(20) / 2 < 1 / 500")
           (("1" (inst - "n-10") (assert))
            ("2"
             (hide-all-but 1)
             (induct "nn")
             (("1" (assert) (eval-formula))
              ("2"
               (skeep)
               (assert)
               (lemma "pi_ub_dec")
               (inst - "11+j" "10+j")
               (assert))))))))))
      ("2" (assert) (lemma "pi_bounds") (inst - "n") (ground))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "cos_approx_cos")
   (expand "cos_ub")
   (inst?)
   (case "cos_term(pi_ubn(n) / 2)(2 * n + 1) < 0")
   (("1"
     (expand "abs" - 2)
     (assert)
     (lemma "cos_term_pi_ub")
     (inst - "n")
     (assert))
    ("2"
     (hide (-1 2))
     (expand "cos_term")
     (cross-mult 1)
     (assert)
     (case "FORALL (nn:nat): (-1)^(2*nn+1) = -1")
     (("1" (inst - "n") (assert))
      ("2"
       (hide-all-but 1)
       (induct "nn")
       (("1" (grind))
        ("2"
         (skeep)
         (expand "^")
         (assert)
         (expand "expt" +)
         (expand "expt" +)
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "strict_decreasing?")
   (skosimp*)
   (lemma "sin_ub_deriv")
   (inst - "n!1")
   (assert)
   (flatten)
   (lemma "mean_value[nnreal]")
   (("1"
     (inst - "x!1" "y!1" "LAMBDA (xnn:nnreal): sin_ub(xnn,n!1)")
     (("1"
       (assert)
       (skeep -1)
       (decompose-equality -5)
       (inst - "c")
       (assert)
       (expand "deriv" -1)
       (replaces -1)
       (case "cos_ub(c,n!1) < 0")
       (("1" (mult-by -1 "y!1-x!1") (assert))
        ("2"
         (typepred "x!1")
         (lemma "cos_ub_nn_strict_decreasing")
         (inst - "n!1")
         (assert)
         (expand "strict_decreasing?")
         (inst - "pi_ub_est(n!1)/2" "c")
         (assert)
         (case "n!1 >= 5")
         (("1"
           (lemma "cos_ub_pi2_neg")
           (inst - "n!1")
           (assert)
           (expand "pi_ub_est")
           (assert))
          ("2"
           (case "FORALL (nn:subrange(1,5)): cos_ub(pi_ub_est(nn) / 2, nn)<0")
           (("1" (inst - "n!1") (("1" (assert)) ("2" (assert))))
            ("2" (hide-all-but 1) (eval-formula))))))))
      ("2"
       (assert)
       (typepred "x!1")
       (expand "pi_ub_est")
       (lift-if)
       (ground))
      ("3"
       (assert)
       (typepred "x!1")
       (expand "pi_ub_est")
       (lift-if)
       (ground))))
    ("2" (lemma "connected_nnreal") (propax))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (assert)
   (split)
   (("1"
     (case "FORALL (nn:below(13)): pi_lbn(nn) - 2 / (1 + nn ^ 3) >= 0")
     (("1" (inst - "n")) ("2" (eval-formula))))
    ("2" (lemma "pi_bounds") (inst - "n") (ground))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "pi_bounds")
   (inst - "10")
   (case "n = 0 OR n = 1 OR n=2 OR n=3 OR n=4")
   (("1"
     (case "pi_ubn(n) + 1 / (n + 1) ^ 4 > pi_ubn(10) AND pi_ubn(n) + 1 / (n + 1) ^ 4 < 3 * pi_lbn(10) / 2")
     (("1" (hide -2) (ground))
      ("2"
       (hide -2)
       (hide 2)
       (split -)
       (("1" (replaces -1) (eval-formula))
        ("2" (replaces -1) (eval-formula))
        ("3" (replaces -1) (eval-formula))
        ("4" (replaces -1) (eval-formula))
        ("5" (replaces -1) (eval-formula))))))
    ("2" (ground))))


proof_type: t_proof
decl_type: tcc
library: trig_fnd
theory: trig_approx
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (n: nat): pi_ubn(n+5) < 3 * pi_lbn(10) / 2")
   (("1"
     (skeep)
     (split)
     (("1" (lemma "pi_bounds") (inst - "n") (ground))
      ("2"
       (inst - "n-5")
       (("1" (assert) (lemma "pi_bounds") (inst - "10") (ground))
        ("2" (assert))))))
    ("2"
     (hide 2)
     (induct "n")
     (("1" (assert) (eval-formula))
      ("2"
       (skeep)
       (assert)
       (lemma "pi_ub_dec")
       (inst - "6+j" "5+j")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: trig_degree
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "cosd")
   (expand "toRad")
   (case "cos(a * pi / 180) <= cos(a*pi_lb/180)")
   (("1"
     (case "cos(a * pi_lb / 180) <= cos_ub(a * pi_lb / 180,n)")
     (("1" (ground))
      ("2"
       (hide 2)
       (lemma "cos_bounds")
       (inst -1 "a * pi_lb / 180" "n")
       (ground))))
    ("2"
     (hide 2)
     (lemma "cos_decreasing")
     (inst -1 "a * pi / 180" "a * pi_lb / 180")
     (ground)
     (("1"
       (hide 2 3)
       (cross-mult 1)
       (case "a=0")
       (("1" (replace -1) (ground)) ("2" (cancel-by 2 "180*a"))))
      ("2" (hide 2) (cross-mult 1) (cancel-by 1 "pi"))
      ("3" (hide 2) (cross-mult 1) (typepred "pi") (grind-reals))
      ("4"
       (hide 2)
       (cross-mult)
       (typepred "pi")
       (swap-rel -3)
       (mult-ineq -3 -6)
       (assert))
      ("5" (hide 2) (cross-mult 1) (grind))))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: law_cosines
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (assert)
   (expand "sq")
   (rewrite "sqrt_0"))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: law_cosines
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (stop-rewrite "sq_sqrt")
   (skosimp*)
   (lemma "distance_trans" ("x2" "-x1!1" "y2" "-y1!1"))
   (inst-cp - "x1!1" "x0!1" "y1!1" "y0!1")
   (replace -2)
   (inst-cp - "x2!1" "x0!1" "y2!1" "y0!1")
   (replace -2)
   (inst - "x2!1" "x1!1" "y2!1" "y1!1")
   (replace -1)
   (hide-all-but 1)
   (name-replace "X0" "x0!1 - x1!1")
   (name-replace "Y0" "y0!1 - y1!1")
   (name-replace "X2" "x2!1 - x1!1")
   (name-replace "Y2" "y2!1 - y1!1")
   (assert)
   (expand "dist")
   (expand "sq_dist")
   (lemma "sq_neg")
   (inst-cp - "X0")
   (inst-cp - "Y0")
   (replace -2)
   (replace -3)
   (lemma "sqrt_times")
   (inst - "sq(X0) + sq(Y0)" "sq(X2) + sq(Y2)")
   (case "-1 * -x1!1 - x1!1 = 0")
   (("1"
     (simplify -2)
     (case "abs(X0 * X2 + Y0 * Y2) <= sqrt(sq(X0) + sq(Y0)) * sqrt(sq(X2) + sq(Y2))")
     (("1"
       (typepred
        "sqrt(sq(X0) * sq(X2) + sq(X0) * sq(Y2) +
                          (sq(X2) * sq(Y0) + sq(Y0) * sq(Y2)))")
       (expand ">=" -1)
       (expand "<=" -1)
       (split -1)
       (("1"
         (case "-1<= (X0 * X2 + Y0 * Y2)/sqrt(sq(X0) * sq(X2) + sq(X0) * sq(Y2) + sq(X2) * sq(Y0) +
                                         sq(Y0) * sq(Y2))")
         (("1"
           (case "(X0 * X2 + Y0 * Y2) /
                                        sqrt(sq(X0) * sq(X2) + sq(X0) * sq(Y2) + sq(X2) * sq(Y0) +
                                              sq(Y0) * sq(Y2)) <= 1")
           (("1"
             (name-replace "DEN"
              "sqrt(sq(X0) * sq(X2) + sq(X0) * sq(Y2) + sq(X2) * sq(Y0) +
                                        sq(Y0) * sq(Y2))")
             (name-replace "NUM" "X0 * X2 + Y0 * Y2")
             (inst + "acos(NUM/DEN)")
             (("1"
               (lemma "div_cancel4"
                ("y"
                 "cos(acos(NUM / DEN))"
                 "n0z"
                 "sqrt(sq(X0) + sq(Y0)) * sqrt(sq(X2) + sq(Y2))"
                 "x"
                 "NUM"))
               (("1"
                 (hide-all-but (-2 -3 -4 1))
                 (name-replace "K10" "NUM / DEN")
                 (hide -3)
                 (typepred "acos(K10)")
                 (expand "cos")
                 (case "floor(acos(K10) / (2 * pi))=0")
                 (("1"
                   (replace -1)
                   (simplify 1)
                   (expand "<=" -3)
                   (split -3)
                   (("1"
                     (hide -2)
                     (lemma "phase_cos_q1" ("x" "acos(K10)"))
                     (expand "cos_phase")
                     (expand ">=")
                     (replace -2)
                     (replace -3)
                     (flatten -1)
                     (replace -1)
                     (lemma "cos_value_acos" ("xa" "K10"))
                     (replaces -1)
                     (expand "K10")
                     (cross-mult 1)
                     (cancel-by 1 "NUM")
                     (expand "DEN" 2)
                     (both-sides-f 2 "sq")
                     (("1" (grind)) ("2" (rewrite "sq_eq"))))
                    ("2"
                     (replace -1)
                     (rewrite "cos_phase_pi")
                     (lemma "acos_bij")
                     (lemma "acos_minus1")
                     (expand "bijective?")
                     (expand "injective?")
                     (flatten -2)
                     (inst - "K10" "-1")
                     (assert)
                     (expand "K10")
                     (cross-mult -2)
                     (replaces -2)
                     (neg-formula 1)
                     (expand "DEN" 1)
                     (both-sides-f 1 "sq")
                     (("1" (grind)) ("2" (rewrite "sq_eq"))))))
                  ("2"
                   (name-replace "K11" "acos(K10)")
                   (hide -3 -4 2)
                   (lemma "floor_def" ("x" "K11 / (2 * pi)"))
                   (rewrite "div_mult_pos_lt1")
                   (rewrite "div_mult_pos_le2")
                   (flatten -1)
                   (name-replace "K12" "floor(K11 / (2 * pi))")
                   (case "K12>=1")
                   (("1"
                     (lemma "both_sides_times_pos_ge1"
                      ("x" "K12" "y" "1" "pz" "2*pi"))
                     (assert))
                    ("2"
                     (case "K12<=-1")
                     (("1"
                       (lemma "both_sides_times_pos_le1"
                        ("x" "K12" "y" "-1" "pz" "2*pi"))
                       (assert))
                      ("2" (assert))))))))
                ("2"
                 (case "NUM / DEN < 0")
                 (("1" (assert)) ("2" (assert))))))
              ("2"
               (expand "abs")
               (case "NUM / DEN < 0")
               (("1" (assert)) ("2" (assert))))))
            ("2"
             (hide -1 2)
             (rewrite "div_mult_pos_le1" 1)
             (expand "abs" -3)
             (case "X0 * X2 + Y0 * Y2 < 0")
             (("1" (assert)) ("2" (assert))))))
          ("2"
           (hide 2)
           (replace -5 -3 rl)
           (rewrite "div_mult_pos_le2" 1)
           (expand "abs" -3)
           (case "X0 * X2 + Y0 * Y2 < 0")
           (("1" (assert)) ("2" (assert))))
          ("3" (assert))))
        ("2"
         (replace -1 * rl)
         (inst + "0")
         (rewrite "cos_0")
         (replace -5 1 rl)
         (hide-all-but (-5 1))
         (lemma "zero_times3"
          ("x" "sqrt(sq(X0) + sq(Y0))" "y" "sqrt(sq(X2) + sq(Y2))"))
         (replace -2 -1 rl)
         (flatten -1)
         (hide -2)
         (split -1)
         (("1"
           (lemma "sqrt_eq" ("nny" "sq(X0) + sq(Y0)" "nnz" "0"))
           (rewrite "sqrt_0")
           (replace -2)
           (flatten)
           (hide -2)
           (lemma "sq_plus_eq_0" ("a" "X0" "b" "Y0"))
           (assert)
           (flatten -1)
           (assert))
          ("2"
           (lemma "sq_plus_eq_0" ("a" "X2" "b" "Y2"))
           (lemma "sqrt_eq" ("nny" "sq(X2) + sq(Y2)" "nnz" "0"))
           (rewrite "sqrt_0")
           (replace -3)
           (replace -1 -2 rl)
           (flatten -2)
           (assert))))))
      ("2"
       (hide 2)
       (rewrite "sq_le" :dir rl)
       (replace -2 1 rl)
       (rewrite "sq_sqrt")
       (case "FORALL (x:real): sq(abs(x)) = sq(x)")
       (("1"
         (inst - "X0 * X2 + Y0 * Y2")
         (rewrite "sq_plus")
         (rewrite "sq_times")
         (rewrite "sq_times")
         (simplify 1)
         (case "2*(X0 * X2 * Y0 * Y2) <= sq(X2) * sq(Y0) + sq(X0) * sq(Y2)")
         (("1" (assert))
          ("2"
           (hide 2)
           (rewrite "sq_times" :dir rl)
           (rewrite "sq_times" :dir rl)
           (lemma "sq_minus" ("a" "X2 * Y0" "b" "X0 * Y2"))
           (assert))))
        ("2"
         (hide-all-but 1)
         (expand "abs")
         (skosimp*)
         (rewrite "sq_neg")
         (case "x!1<0")
         (("1" (assert)) ("2" (assert))))))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: trig_fnd
theory: law_cosines
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (x,y:real): dist(0,0,0,1) <= dist(x,y,0,1) + dist(x,y,0,0)")
   (("1"
     (case "FORALL (x,y:real,pz:posreal): dist(0, 0, 0, pz) <= dist(x, y, 0, pz) + dist(x, y, 0, 0)")
     (("1"
       (hide -2)
       (case "FORALL (x,y,a,b:real): dist(0, 0, a,b) <= dist(x, y, a,b) + dist(x, y, 0, 0)")
       (("1"
         (hide -2)
         (skosimp*)
         (lemma "distance_trans" ("x2" "-x0!1" "y2" "-y0!1"))
         (inst-cp - "x0!1" "x1!1" "y0!1" "y1!1")
         (inst-cp - "x2!1" "x1!1" "y2!1" "y1!1")
         (inst - "x2!1" "x0!1" "y2!1" "y0!1")
         (inst - "x2!1-x0!1" "y2!1-y0!1" "x1!1-x0!1" "y1!1-y0!1")
         (assert))
        ("2"
         (hide 2)
         (skosimp*)
         (case "a!1=0")
         (("1"
           (replace -1)
           (lemma "trichotomy" ("x" "b!1"))
           (split -1)
           (("1" (inst - "x!1" "y!1" "b!1") (assert))
            ("2"
             (replace -1)
             (expand "dist")
             (expand "sq_dist")
             (rewrite "sq_0")
             (rewrite "sqrt_0")
             (assert))
            ("3"
             (inst - "x!1" "-y!1" "-b!1")
             (("1" (expand "dist") (expand "sq_dist") (sq-simp))
              ("2" (assert))))))
          ("2"
           (name "theta" "atan2(b!1,a!1)")
           (("1"
             (lemma "distance_rot" ("ac" "theta"))
             (lemma "sin_atan2" ("x" "b!1" "y" "a!1"))
             (lemma "cos_atan2" ("x" "b!1" "y" "a!1"))
             (assert)
             (replace -4)
             (inst-cp - "0" "a!1" "0" "b!1")
             (simplify -4)
             (case "cos(theta) * a!1 - sin(theta) * b!1 = 0")
             (("1"
               (case "cos(theta) * b!1 + sin(theta) * a!1 = sqrt(sq(a!1)+sq(b!1))")
               (("1"
                 (inst-cp - "x!1" "0" "y!1" "0")
                 (inst - "x!1" "a!1" "y!1" "b!1")
                 (replace -1)
                 (replace -2)
                 (replace -5)
                 (replace -6)
                 (replace -7)
                 (simplify 2)
                 (inst - "cos(theta) * x!1 - sin(theta) * y!1"
                  "cos(theta) * y!1 + sin(theta) * x!1"
                  "sqrt(sq(a!1) + sq(b!1))")
                 (hide -3 -4 -5 -6 -7 -8 3)
                 (lemma "sqrt_pos" ("px" "sq(a!1) + sq(b!1)"))
                 (("1" (propax))
                  ("2"
                   (hide -1 -2 2)
                   (lemma "sq_nz_pos" ("nz" "a!1"))
                   (assert))))
                ("2"
                 (hide -1 -4 -5 -6 -7 3)
                 (case "b!1=0")
                 (("1"
                   (replace -1)
                   (rewrite "sq_0")
                   (simplify 1)
                   (case "a!1>0")
                   (("1" (rewrite "sqrt_sq") (assert))
                    ("2"
                     (lemma "sq_neg" ("a" "a!1"))
                     (replace -1 2 rl)
                     (rewrite "sqrt_sq")
                     (assert))))
                  ("2"
                   (assert)
                   (case "1 + sq(a!1 / b!1) = (sq(a!1)+sq(b!1))/sq(b!1)")
                   (("1"
                     (replace -1)
                     (rewrite "sqrt_div")
                     (("1"
                       (case "b!1>0")
                       (("1"
                         (assert)
                         (rewrite "div_div1")
                         (rewrite "div_div1")
                         (lemma "div_cancel2" ("x" "a!1" "n0z" "b!1"))
                         (replace -1 -5)
                         (replace -4)
                         (replace -5)
                         (lemma "div_cancel3"
                          ("x"
                           "b!1*b!1+a!1*a!1"
                           "n0z"
                           "sqrt(sq(a!1) + sq(b!1))"
                           "y"
                           "sqrt(sq(a!1) + sq(b!1))"))
                         (replace -1 2)
                         (rewrite "sq_rew" 2)
                         (rewrite "sq_rew" 2)
                         (rewrite "sq_rew" 2)
                         (assert))
                        ("2"
                         (assert)
                         (rewrite "div_div1")
                         (rewrite "div_div1")
                         (lemma "sq_neg" ("a" "b!1"))
                         (replace -1 * rl)
                         (case "-((a!1 / b!1 * -b!1) / sqrt((sq(a!1) + sq(-b!1)))) = a!1/ sqrt((sq(a!1) + sq(-b!1)))")
                         (("1"
                           (replace -1)
                           (case "-1*-b!1=b!1")
                           (("1"
                             (replace -1)
                             (hide -1 -2 -4)
                             (replace -2)
                             (replace -3)
                             (replace -1)
                             (hide (-1 -2 -3))
                             (lemma "div_cancel3")
                             (inst - "sqrt(sq(a!1) + sq(b!1))"
                              "b!1*b!1+a!1*a!1"
                              "sqrt(sq(a!1) + sq(b!1))")
                             (replace -1 3)
                             (rewrite "sq_rew")
                             (rewrite "sq_rew")
                             (rewrite "sq_rew")
                             (assert))
                            ("2" (assert))))
                          ("2" (hide 4 -3 -4) (assert))))))
                      ("2" (lemma "sq_nz_pos" ("nz" "b!1")) (assert))))
                    ("2" (rewrite "sq_div") (assert))
                    ("3" (lemma "sq_nz_pos" ("nz" "b!1")) (assert))))))))
              ("2"
               (hide -3 -4 -5 -6 3)
               (case "b!1=0")
               (("1" (assert))
                ("2" (case "b!1>0") (("1" (assert)) ("2" (assert))))))))
            ("2" (case "b!1=0") (("1" (assert)) ("2" (assert))))))))))
      ("2"
       (hide 2)
       (skosimp*)
       (lemma "distance_scale" ("pz" "pz!1"))
       (inst-cp - "0" "0" "0" "1")
       (inst-cp - "x!1/pz!1" "0" "y!1/pz!1" "1")
       (inst - "x!1/pz!1" "0" "y!1/pz!1" "0")
       (inst - "x!1/pz!1" "y!1/pz!1")
       (lemma "both_sides_times_pos_le1"
        ("x"
         "dist(0, 0, 0, 1)"
         "y"
         "dist(x!1/pz!1, y!1/pz!1, 0, 1) + dist(x!1/pz!1, y!1/pz!1, 0, 0)"
         "pz"
         "pz!1"))
       (assert))))
    ("2"
     (hide 2)
     (skosimp*)
     (expand "dist")
     (expand "sq_dist")
     (rewrite "sq_0")
     (name-replace "K1" "sq(x!1)")
     (rewrite "sq_le" :dir rl)
     (rewrite "sq_plus")
     (rewrite "sq_minus")
     (lemma "trichotomy" ("x" "y!1"))
     (split -1)
     (("1"
       (case "sq(y!1) - 2 * y!1 + K1 + (sq(y!1) + K1) >=0")
       (("1" (assert))
        ("2"
         (case "y!1-sq(y!1)-K1 <= (sqrt(1 + sq(y!1) - 2 * y!1 + K1) * sqrt(sq(y!1) + K1))")
         (("1" (assert))
          ("2"
           (hide 3)
           (rewrite "sqrt_times" :dir rl)
           (rewrite "sq_le" :dir rl)
           (expand "sq" 1)
           (assert))
          ("3" (assert))))))
      ("2" (replace -1) (rewrite "sq_0") (assert)) ("3" (assert))))))


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


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvv?")
   (skeep)
   (typepred "ffvc")
   (typepred "ggvc")
   (expand "continuous_vvv?")
   (inst - "epsil/2" "s" "nzv")
   (inst - "epsil/2" "s" "nzv")
   (skosimp*)
   (inst + "min(ds!1,ds!2)" "min(dv!1,dv!2)")
   (skeep)
   (inst - "sp" "nzvp")
   (inst - "sp" "nzvp")
   (assert)
   (expand "sum_vvv")
   (lemma "norm_add_le")
   (inst - "ffvc(s,nzv) - ffvc(sp,nzvp)" "ggvc(s,nzv) - ggvc(sp,nzvp)")
   (grind :exclude ("norm" "min")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvr?")
   (skeep)
   (typepred "ffrc")
   (typepred "ggrc")
   (expand "continuous_vvr?")
   (inst - "epsil/2" "s" "nzv")
   (inst - "epsil/2" "s" "nzv")
   (skosimp*)
   (inst + "min(ds!1,ds!2)" "min(dv!1,dv!2)")
   (skeep)
   (inst - "sp" "nzvp")
   (inst - "sp" "nzvp")
   (assert)
   (expand "sum_vvr")
   (lemma "triangle")
   (inst - "ffrc(s,nzv) - ffrc(sp,nzvp)" "ggrc(s,nzv) - ggrc(sp,nzvp)")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvv?")
   (skeep)
   (typepred "ffvc")
   (typepred "ggvc")
   (expand "continuous_vvv?")
   (inst - "epsil/2" "s" "nzv")
   (inst - "epsil/2" "s" "nzv")
   (skosimp*)
   (inst + "min(ds!1,ds!2)" "min(dv!1,dv!2)")
   (skeep)
   (inst - "sp" "nzvp")
   (inst - "sp" "nzvp")
   (assert)
   (expand "diff_vvv")
   (lemma "norm_add_le")
   (inst - "ffvc(s,nzv) - ffvc(sp,nzvp)" "ggvc(sp,nzvp) - ggvc(s,nzv)")
   (lemma "norm_neg")
   (inst - "ggvc(sp, nzvp) - ggvc(s, nzv)")
   (grind :exclude ("norm" "min")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffvc")
   (expand "continuous_vvv?")
   (skosimp*)
   (inst - "epsil!1/(abs(c)+1)" "s!1" "nzv!1")
   (skosimp*)
   (inst + "ds!1" "dv!1")
   (skosimp*)
   (inst - "sp!1" "nzvp!1")
   (assert)
   (expand "scal_vvv")
   (lemma "norm_scal")
   (inst - "c" "ffvc(s!1, nzv!1) - ffvc(sp!1, nzvp!1)")
   (assert)
   (case "c * (ffvc(s!1, nzv!1) - ffvc(sp!1, nzvp!1))=c * ffvc(s!1, nzv!1) - c * ffvc(sp!1, nzvp!1)")
   (("1"
     (replace -1)
     (hide -1)
     (case "abs(c) * norm(ffvc(s!1, nzv!1) - ffvc(sp!1, nzvp!1)) < epsil!1")
     (("1" (assert)) ("2" (hide (-1 2)) (cross-mult -1) (assert))))
    ("2" (hide-all-but 1) (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvr?")
   (skosimp*)
   (typepred "ffvc")
   (typepred "ggvc")
   (expand "continuous_vvv?")
   (label "fcont" -2)
   (label "gcont" -1)
   (name "ep1" "epsil!1/(8*norm(ggvc(s!1,nzv!1))+1)")
   (name "ep2" "epsil!1/(8*(norm(ffvc(s!1,nzv!1)) + ep1))")
   (label "ep1name" -2)
   (label "ep2name" -1)
   (inst - "ep2" "s!1" "nzv!1")
   (inst - "ep1" "s!1" "nzv!1")
   (skosimp*)
   (inst + "min(ds!1,ds!2)" "min(dv!1,dv!2)")
   (skosimp*)
   (inst - "sp!1" "nzvp!1")
   (inst - "sp!1" "nzvp!1")
   (assert)
   (expand "dot_vvv")
   (lemma "triangle")
   (inst -
    "ffvc(s!1,nzv!1) * ggvc(s!1,nzv!1) - ffvc(sp!1,nzvp!1) * ggvc(s!1,nzv!1)"
    " ffvc(sp!1,nzvp!1) * ggvc(s!1,nzv!1) -
                                                                                                                                                                                                                                                           ffvc(sp!1,nzvp!1) * ggvc(sp!1,nzvp!1)")
   (assert)
   (lemma "schwarz")
   (inst - "ffvc(s!1,nzv!1)-ffvc(sp!1,nzvp!1)" "ggvc(s!1,nzv!1)")
   (assert)
   (lemma "schwarz")
   (inst - "ffvc(sp!1,nzvp!1)" "ggvc(s!1,nzv!1) - ggvc(sp!1,nzvp!1)")
   (assert)
   (rewrite "dot_sub_right")
   (rewrite "dot_sub_left")
   (case "norm(ffvc(s!1, nzv!1) - ffvc(sp!1, nzvp!1)) * norm(ggvc(s!1, nzv!1)) + norm(ffvc(sp!1, nzvp!1)) *
                               norm(ggvc(s!1, nzv!1) - ggvc(sp!1, nzvp!1))<epsil!1")
   (("1" (assert))
    ("2"
     (hide (-1 -2 -3 2))
     (case "norm(ffvc(sp!1,nzvp!1)) <= norm(ffvc(s!1,nzv!1)) + ep1")
     (("1"
       (replace "ep1name" - rl)
       (hide "ep1name")
       (replace "ep2name" - rl)
       (hide "ep2name")
       (name "A" "ffvc(s!1,nzv!1)")
       (name "B" "ffvc(sp!1,nzvp!1)")
       (name "X" "ggvc(s!1,nzv!1)")
       (name "Y" "ggvc(sp!1,nzvp!1)")
       (label "yname" -1)
       (label "xname" -2)
       (label "bname" -3)
       (label "aname" -4)
       (replace "aname")
       (replace "bname")
       (replace "xname")
       (replace "yname")
       (hide "aname")
       (hide "bname")
       (hide "xname")
       (hide "yname")
       (copy "gcont")
       (reveal "ep1name")
       (reveal "xname")
       (replace -1)
       (hide -1)
       (replace -1)
       (name "myvar" "norm(A) + epsil!1 / (1+8 * norm(X))")
       (label "namemyvar" -1)
       (case "norm(A - B) * norm(X) < epsil!1/2 AND norm(B) * norm(X - Y) <= epsil!1/2")
       (("1" (flatten) (assert))
        ("2"
         (hide 2)
         (split +)
         (("1"
           (case "ep1*norm(X) < epsil!1/2")
           (("1" (copy "fcont") (mult-by -1 "norm(X)") (assert))
            ("2" (hide 2) (replace "ep1name" + :dir rl) (cross-mult 1))))
          ("2"
           (copy -4)
           (mult-by -1 "norm(X-Y)")
           (copy -4)
           (cross-mult -1)
           (assert))))))
      ("2"
       (hide 2)
       (hide-all-but ("fcont" 1))
       (lemma "norm_add_le")
       (inst - "ffvc(s!1, nzv!1)-ffvc(sp!1, nzvp!1)" "-ffvc(s!1, nzv!1)")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "fffv" "LAMBDA (s,nzv): (# x:= ffrc(s,nzv), y:= 0 #)")
   (name "gggv" "LAMBDA (s,nzv): (# x:= ggrc(s,nzv), y:= 0 #)")
   (lemma "dot_vvv_cont")
   (inst - "fffv" "gggv")
   (("1"
     (hide -2 -3)
     (expand "dot_vvv")
     (expand "prod_vvr")
     (expand "gggv")
     (expand "fffv")
     (expand "*")
     (propax))
    ("2"
     (hide-all-but 1)
     (expand "continuous_vvv?")
     (typepred "ggrc")
     (expand "continuous_vvr?")
     (skosimp*)
     (inst - "epsil!1" "s!1" "nzv!1")
     (skosimp*)
     (inst + "ds!1" "dv!1")
     (skosimp*)
     (inst - "sp!1" "nzvp!1")
     (assert)
     (rewrite "sqrt_sqv_norm" 1 :dir rl)
     (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
     (("1"
       (rewrite -1)
       (expand "gggv" +)
       (expand "-" +)
       (rewrite "sq_0")
       (assert)
       (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
       (("1" (rewrite -1 1))
        ("2"
         (hide-all-but 1)
         (skeep)
         (case "aaa>=0")
         (("1" (grind))
          ("2"
           (lemma "sqrt_sq")
           (inst - "-aaa")
           (rewrite "sq_neg")
           (split -)
           (("1" (replace -1) (expand "abs") (assert))
            ("2" (assert))))))))
      ("2" (hide-all-but 1) (grind))))
    ("3"
     (hide-all-but 1)
     (expand "continuous_vvv?")
     (typepred "ffrc")
     (expand "continuous_vvr?")
     (skosimp*)
     (inst - "epsil!1" "s!1" "nzv!1")
     (skosimp*)
     (inst + "ds!1" "dv!1")
     (skosimp*)
     (inst - "sp!1" "nzvp!1")
     (assert)
     (rewrite "sqrt_sqv_norm" 1 :dir rl)
     (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
     (("1"
       (rewrite -1)
       (expand "fffv" +)
       (expand "-" +)
       (rewrite "sq_0")
       (assert)
       (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
       (("1" (rewrite -1 1))
        ("2"
         (hide-all-but 1)
         (skeep)
         (case "aaa>=0")
         (("1" (grind))
          ("2"
           (lemma "sqrt_sq")
           (inst - "-aaa")
           (rewrite "sq_neg")
           (split -)
           (("1" (replace -1) (expand "abs") (assert))
            ("2" (assert))))))))
      ("2" (hide-all-but 1) (grind))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvr?")
   (skosimp*)
   (inst + "1" "1")
   (skosimp*)
   (expand "const_vvr")
   (assert)
   (expand "abs")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "ggx" "LAMBDA (s,nzv): ggvc(s,nzv)`x")
   (name "ggy" "LAMBDA (s,nzv): ggvc(s,nzv)`y")
   (name "ggvy" "LAMBDA (s,nzv): (# x:= 0, y:= ggvc(s,nzv)`y #)")
   (name "ggvx" "LAMBDA (s,nzv): (# x:=ggvc(s,nzv)`x,y:=0 #)")
   (lemma "sum_vvv_cont")
   (inst - "scal_vvr_vvv(ffrc, ggvx)" "scal_vvr_vvv(ffrc,ggvy)")
   (("1"
     (hide-all-but (-1 1))
     (expand "sum_vvv")
     (expand "scal_vvr_vvv")
     (expand "ggvy")
     (expand "ggvx")
     (expand "*")
     (expand "+")
     (propax))
    ("2"
     (lemma "prod_vvr_cont")
     (inst - "ffrc" "ggy")
     (("1"
       (hide-all-but (-1 1))
       (expand "prod_vvr")
       (expand "scal_vvr_vvv")
       (expand "ggvy")
       (expand "*")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "s!1" "nzv!1")
       (skosimp*)
       (inst + "ds!1" "dv!1")
       (skosimp*)
       (inst - "sp!1" "nzvp!1")
       (assert)
       (expand "ggy")
       (expand "-")
       (rewrite "sqrt_sqv_norm" 1 :dir rl)
       (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
       (("1"
         (rewrite -1)
         (hide -1)
         (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
         (("1" (rewrite -1))
          ("2"
           (hide-all-but 1)
           (skeep)
           (expand "abs")
           (lift-if)
           (assert))))
        ("2" (hide-all-but 1) (grind))))
      ("2"
       (hide-all-but 1)
       (typepred "ggvc")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "s!1" "nzv!1")
       (skosimp*)
       (inst + "ds!1" "dv!1")
       (skosimp*)
       (inst - "sp!1" "nzvp!1")
       (assert)
       (expand "ggy")
       (lemma "norm_ge_comps")
       (inst?)
       (flatten)
       (grind :exclude "norm"))))
    ("3"
     (lemma "prod_vvr_cont")
     (inst - "ffrc" "ggx")
     (("1"
       (hide-all-but (-1 1))
       (expand "prod_vvr")
       (expand "scal_vvr_vvv")
       (expand "ggvx")
       (expand "*")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "s!1" "nzv!1")
       (skosimp*)
       (inst + "ds!1" "dv!1")
       (skosimp*)
       (inst - "sp!1" "nzvp!1")
       (assert)
       (expand "ggx")
       (expand "-")
       (rewrite "sqrt_sqv_norm" 1 :dir rl)
       (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
       (("1"
         (rewrite -1)
         (hide -1)
         (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
         (("1" (rewrite -1))
          ("2"
           (hide-all-but 1)
           (skeep)
           (expand "abs")
           (lift-if)
           (assert))))
        ("2" (hide-all-but 1) (grind))))
      ("2"
       (hide-all-but 1)
       (typepred "ggvc")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "s!1" "nzv!1")
       (skosimp*)
       (inst + "ds!1" "dv!1")
       (skosimp*)
       (inst - "sp!1" "nzvp!1")
       (assert)
       (expand "ggx")
       (lemma "norm_ge_comps")
       (inst?)
       (flatten)
       (grind :exclude "norm"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffrc")
   (expand "continuous_vvr?")
   (skosimp*)
   (inst - "epsil!1/(abs(c)+1)" "s!1" "nzv!1")
   (skosimp*)
   (inst + "ds!1" "dv!1")
   (skosimp*)
   (inst - "sp!1" "nzvp!1")
   (assert)
   (expand "scal_vvr")
   (lemma "abs_mult")
   (inst - "c" "ffrc(s!1, nzv!1) - ffrc(sp!1, nzvp!1)")
   (assert)
   (assert)
   (case "abs(c) * abs(ffrc(s!1, nzv!1) - ffrc(sp!1, nzvp!1)) < epsil!1")
   (("1" (assert)) ("2" (hide (-1 2)) (cross-mult -1))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "continuous_vvr?(div_vvr(LAMBDA (s,nzv): 1, ggnzc))")
   (("1"
     (lemma "prod_vvr_cont")
     (inst - "ffrc" "div_vvr(LAMBDA (s, nzv): 1, ggnzc)")
     (hide -2)
     (expand "prod_vvr")
     (expand "div_vvr")
     (assert))
    ("2"
     (hide 2)
     (name "gg" "ggnzc")
     (replace -1)
     (hide -1)
     (typepred "gg")
     (expand "continuous_vvr?")
     (skosimp*)
     (expand "continuous_nz_vvr?")
     (flatten)
     (expand "continuous_vvr?")
     (name "newep"
           "min(abs(gg(s!1,nzv!1))/2,sq(gg(s!1,nzv!1))*epsil!1/4)")
     (inst - "newep" "s!1" "nzv!1")
     (("1"
       (skosimp*)
       (inst + "ds!1" "dv!1")
       (skosimp*)
       (inst - "sp!1" "nzvp!1")
       (assert)
       (expand "div_vvr")
       (case "1 / gg(s!1, nzv!1) - 1 / gg(sp!1, nzvp!1) = (gg(sp!1,nzvp!1) - gg(s!1,nzv!1))/(gg(s!1,nzv!1)*gg(sp!1,nzvp!1))")
       (("1"
         (replace -1)
         (rewrite "abs_div")
         (hide -1)
         (case "abs((gg(s!1, nzv!1) * gg(sp!1, nzvp!1))) >= sq(gg(s!1, nzv!1))/2")
         (("1"
           (cross-mult 1)
           (typepred "newep")
           (mult-by -4 "epsil!1")
           (assert)
           (expand "abs")
           (lift-if)
           (ground))
          ("2"
           (hide 2)
           (rewrite "abs_mult")
           (case "abs(gg(sp!1, nzvp!1)) >= abs(gg(s!1,nzv!1))/2")
           (("1"
             (lemma "sq_abs")
             (inst - "gg(s!1,nzv!1)")
             (expand "sq" -1 1)
             (replace -1 :dir rl)
             (hide -1)
             (mult-by -1 "abs(gg(s!1, nzv!1))")
             (assert))
            ("2"
             (hide 2)
             (lemma "triangle")
             (inst - "gg(s!1, nzv!1) - gg(sp!1, nzvp!1)"
              "gg(sp!1, nzvp!1)")
             (assert))))))
        ("2" (hide 2) (field))
        ("3"
         (expand "nzero_vvr?")
         (inst-cp - "s!1" "nzv!1")
         (inst - "sp!1" "nzvp!1")
         (lemma "nzreal_times_nzreal_is_nzreal")
         (inst?))))
      ("2"
       (hide 2)
       (expand "nzero_vvr?")
       (inst - "s!1" "nzv!1")
       (assert)
       (flatten)
       (lemma "sq_eq_0")
       (inst?)
       (assert)
       (expand "min")
       (lift-if)
       (ground))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffrc")
   (typepred "ggrc")
   (expand "continuous_vvr?")
   (skosimp*)
   (inst - "epsil!1" "s!1" "nzv!1")
   (inst - "epsil!1" "s!1" "nzv!1")
   (skosimp*)
   (inst + "min(ds!1,ds!2)" "min(dv!1,dv!2)")
   (skosimp*)
   (inst - "sp!1" "nzvp!1")
   (inst - "sp!1" "nzvp!1")
   (assert)
   (hide (-3 -4))
   (expand "max_vvr")
   (grind))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_vect_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffvc")
   (expand "continuous_vvr?")
   (expand "continuous_vvv?")
   (skeep)
   (inst - "epsil" "s" "nzv")
   (skeep -1)
   (inst + "ds" "dv")
   (skeep)
   (inst - "sp" "nzvp")
   (assert)
   (expand "norm_vvv")
   (case "FORALL (vv,ww:Vect2): abs(norm(vv)-norm(ww))<=norm(vv-ww)")
   (("1" (inst?) (assert))
    ("2"
     (hide-all-but 1)
     (skeep)
     (lemma "vectors_2D.norm_add_le")
     (inst - "vv-ww" "ww")
     (assert)
     (lemma "vectors_2D.norm_add_le")
     (inst - "ww-vv" "vv")
     (assert)
     (lemma "vectors_2D.norm_neg")
     (inst - "ww-vv")
     (case "-(ww-vv) = vv-ww")
     (("1"
       (replace -1)
       (hide -1)
       (replace -1 :dir rl)
       (expand "abs")
       (lift-if)
       (ground))
      ("2" (hide-all-but 1) (grind))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_metric_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "metric_space?")
   (prop)
   (("1"
     (expand "space_zero?")
     (skosimp*)
     (lemma "dist_eq_0")
     (inst - "x!1" "y!1"))
    ("2"
     (expand "space_symmetric?")
     (skosimp*)
     (lemma "dist_sym")
     (inst - "x!1" "y!1"))
    ("3"
     (expand "space_triangle?")
     (skosimp*)
     (lemma "dist_triangle")
     (inst - "x!1" "y!1" "z!1"))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: vect2_metric_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "metric_space?")
   (prop)
   (("1"
     (expand "space_zero?")
     (skosimp*)
     (lemma "dist_eq_0")
     (inst - "x!1" "y!1"))
    ("2"
     (expand "space_symmetric?")
     (skosimp*)
     (lemma "dist_sym")
     (inst - "x!1" "y!1"))
    ("3"
     (expand "space_triangle?")
     (skosimp*)
     (lemma "dist_triangle")
     (inst - "x!1" "y!1" "z!1"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "curried_min_exists")
   (skosimp*)
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
   (prop)
   (("1"
     (inst - "y!1")
     (expand "fullset")
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (prop))
    ("2" (inst - "y!1") (expand "fullset") (assert))
    ("3" (inst - "y!1") (expand "fullset") (prop))
    ("4" (inst - "y!1") (expand "fullset") (prop))
    ("5"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("6"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("7"
     (expand "nonempty?")
     (expand "empty?")
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("8"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "(A!1 + B!1)/2")
     (assert))
    ("9"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("10"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (prop))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("11"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (assert))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("12"
     (hide 1)
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (prop))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("13"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("14"
     (lemma "curried_min_exists")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (assert)
     (prop)
     (("1" (inst - "y!1") (expand "fullset") (propax))
      ("2" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))
    ("15" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))
    ("16" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "curried_min_is_cont")
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
   (prop)
   (("1" (expand "continuous?" +) (expand "fullset") (propax))
    ("2" (lemma "closed_intervals_compact") (inst?))
    ("3"
     (hide 2)
     (expand "continuous?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (expand "continuous_at?")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta !1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (typepred "y!1")
       (inst - "y!1")
       (("1" (assert)) ("2" (hide -2 2) (grind))))
      ("2" (hide 2) (typepred "x!1") (grind))))
    ("4"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "(A!1 + B!1)/2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (skoletin 1)
   (("1"
     (skosimp*)
     (lemma "curried_min_is_cont_2D")
     (inst - "f!1" "A!1" "B!1")
     (prop)
     (("1"
       (assert)
       (replace -2 - rl)
       (expand "continuous?")
       (expand "continuous?")
       (inst - "y!1")
       (("1"
         (expand "continuous_at?")
         (inst - "epsilon!1")
         (expand "member")
         (expand "ball")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "q!1")
         (("1" (assert)) ("2" (expand "fullset") (propax))))
        ("2" (expand "fullset") (propax))))
      ("2"
       (hide 2)
       (lemma "product_cont_product_subset")
       (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
       (prop)
       (("1"
         (hide-all-but (-1 1))
         (expand "continuous?")
         (expand "continuous_at?")
         (expand "member")
         (expand "ball")
         (skosimp*)
         (inst - "x!1")
         (("1"
           (inst - "epsilon!2")
           (skosimp*)
           (inst + "delta!1")
           (skosimp*)
           (inst - "y!2")
           (("1" (assert))
            ("2"
             (expand "extend")
             (prop)
             (("1" (expand "fullset") (propax))
              ("2" (typepred "y!2") (expand "extend") (assert))
              ("3" (typepred "y!2") (expand "extend") (assert))
              ("4" (expand "fullset") (propax))))))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "x!1") (expand "extend") (assert))
            ("3" (typepred "x!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (skosimp*)
         (inst - "x!1" "y!2" "epsilon!2")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "z!1" "w!1")
         (assert))))))
    ("2"
     (hide 2)
     (hide -)
     (lemma "curried_min_is_cont_TCC1")
     (skosimp*)
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (case "nonempty?(LAMBDA (x: real): A!1 <= x AND x <= B!1)")
     (("1"
       (assert)
       (reveal -2)
       (label "cont_ed" -1)
       (label "nonempty" -2)
       (label "bigpred" -3)
       (prop)
       (("1" (inst - "y!1") (expand "fullset") (assert))
        ("2" (inst - "y!1") (expand "fullset") (assert))
        ("3" (inst - "y!1") (expand "fullset") (assert))
        ("4"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst - "f!1(A!1,y!1)")
         (inst + "A!1"))
        ("5"
         (lemma "product_cont_product_subset")
         (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
         (assert)
         (hide-all-but ("cont_ed" 1))
         (skosimp*)
         (inst - "x!1" "y!2" "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "z!1" "w!1")
         (assert))
        ("6"
         (lemma "product_cont_product_subset")
         (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
         (assert)
         (hide-all-but ("cont_ed" 1))
         (skosimp*)
         (inst - "x!1" "y!2" "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "z!1" "w!1")
         (assert))
        ("7"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst - "f!1(A!1,y!1)")
         (inst + "A!1"))
        ("8" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))
        ("9" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))
      ("2"
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (inst - "A!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "multiary_Heine")
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
   (assert)
   (prop)
   (("1" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))
    ("2"
     (expand "continuous?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "y!1")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!1") (expand "extend") (assert))
          ("3" (typepred "y!1") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "multiary_Heine_2D")
   (inst - "f!1" "A!1" "B!1")
   (expand "uniformly_continuous_in_first?")
   (prop)
   (("1"
     (inst - "y1!1" "epsilon!1")
     (("1"
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "x1!1" "x2!1" "y2!1")
       (("1" (assert)) ("2" (expand "fullset") (propax))))
      ("2" (expand "fullset") (propax))))
    ("2"
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 1))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!2")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!2")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "curried_min_exists")
   (skosimp*)
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
   (prop)
   (("1"
     (inst - "y!1")
     (expand "fullset")
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (prop))
    ("2" (inst - "y!1") (expand "fullset") (prop))
    ("3" (inst - "y!1") (expand "fullset") (assert))
    ("4"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("5"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("6"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("7"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("8"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (assert))
          ("3" (typepred "y!2") (expand "extend") (prop))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("9"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (assert))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("10"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("11"
     (lemma "curried_min_exists")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (assert)
     (prop)
     (("1" (inst - "y!1") (expand "fullset") (propax))
      ("2" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))
    ("12" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: vect2_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "curried_min_is_cont_2D_TCC1")
   (skosimp*)
   (inst - "f!1" "A!1" "B!1")
   (prop)
   (("1" (inst - "y1!1") (prop)) ("2" (inst - "y1!1") (prop))
    ("3" (inst - "y1!1") (prop))
    ("4"
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 2))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (hide-all-but (-1 1))
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))
    ("5"
     (hide 1)
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 1))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (hide-all-but (-1 1))
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))
    ("6"
     (hide 1)
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect2]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 1))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (hide-all-but (-1 1))
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvv?")
   (skeep)
   (typepred "ffvc")
   (typepred "ggvc")
   (expand "continuous_vvv?")
   (inst - "epsil/2" "so" "vo" "si" "vi")
   (inst - "epsil/2" "so" "vo" "si" "vi")
   (skosimp*)
   (inst + "min(dso!1,dso!2)" "min(dvo!1,dvo!2)" "min(dsi!1,dsi!2)"
    "min(dvi!1,dvi!2)")
   (skeep)
   (inst - "nso" "nvo" "nsi" "nvi")
   (inst - "nso" "nvo" "nsi" "nvi")
   (assert)
   (expand "sum_vvv")
   (lemma "norm_add_le")
   (inst - "ffvc(so,vo,si,vi) - ffvc(nso,nvo,nsi,nvi)"
    "ggvc(so,vo,si,vi)-ggvc(nso,nvo,nsi,nvi)")
   (grind :exclude ("norm" "min")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvr?")
   (skeep)
   (typepred "ffrc")
   (typepred "ggrc")
   (expand "continuous_vvr?")
   (inst - "epsil/2" "so" "vo" "si" "vi")
   (inst - "epsil/2" "so" "vo" "si" "vi")
   (skosimp*)
   (inst + "min(dso!1,dso!2)" "min(dvo!1,dvo!2)" "min(dsi!1,dsi!2)"
    "min(dvi!1,dvi!2)")
   (skeep)
   (inst - "nso" "nvo" "nsi" "nvi")
   (inst - "nso" "nvo" "nsi" "nvi")
   (assert)
   (expand "sum_vvr")
   (lemma "triangle")
   (inst - "ffrc(so,vo,si,vi) - ffrc(nso,nvo,nsi,nvi)"
    "ggrc(so,vo,si,vi)-ggrc(nso,nvo,nsi,nvi)")
   (grind :exclude ("norm" "min")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvv?")
   (skeep)
   (typepred "ffvc")
   (typepred "ggvc")
   (expand "continuous_vvv?")
   (inst - "epsil/2" "so" "vo" "si" "vi")
   (inst - "epsil/2" "so" "vo" "si" "vi")
   (skosimp*)
   (inst + "min(dso!1,dso!2)" "min(dvo!1,dvo!2)" "min(dsi!1,dsi!2)"
    "min(dvi!1,dvi!2)")
   (skeep)
   (inst - "nso" "nvo" "nsi" "nvi")
   (inst - "nso" "nvo" "nsi" "nvi")
   (assert)
   (expand "diff_vvv")
   (lemma "norm_add_le")
   (inst - "ffvc(so,vo,si,vi) - ffvc(nso,nvo,nsi,nvi)"
    "ggvc(nso,nvo,nsi,nvi)-ggvc(so,vo,si,vi)")
   (lemma "norm_neg")
   (inst - "ggvc(so, vo, si, vi) - ggvc(nso, nvo, nsi, nvi)")
   (case "forall (eg1,eg2:Vect2): -(eg1-eg2) = eg2-eg1")
   (("1" (rewrite -1) (hide -1) (grind :exclude ("norm" "min")))
    ("2" (hide-all-but 1) (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffvc")
   (expand "continuous_vvv?")
   (skeep)
   (inst - "epsil/(abs(c)+1)" "so" "vo" "si" "vi")
   (skeep -1)
   (inst + "dso" "dvo" "dsi" "dvi")
   (skeep)
   (inst - "nso" "nvo" "nsi" "nvi")
   (assert)
   (cross-mult -1)
   (name "l1" "norm(ffvc(so, vo, si, vi) - ffvc(nso, nvo, nsi, nvi))")
   (replace -1)
   (hide-all-but (-2 1))
   (typepred "l1")
   (expand "l1" -2 2)
   (expand "scal_vvv")
   (lemma "norm_scal")
   (inst - "c" "ffvc(so, vo, si, vi) - ffvc(nso, nvo, nsi, nvi)")
   (assert)
   (grind :exclude "norm"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvr?")
   (skosimp*)
   (typepred "ffvc")
   (typepred "ggvc")
   (expand "continuous_vvv?")
   (label "fcont" -2)
   (label "gcont" -1)
   (name "ep1" "epsil!1/(8*norm(ggvc(so!1,vo!1,si!1,vi!1))+1)")
   (name "ep2" "epsil!1/(8*(norm(ffvc(so!1,vo!1,si!1,vi!1)) + ep1))")
   (label "ep1name" -2)
   (label "ep2name" -1)
   (inst - "ep2" "so!1" "vo!1" "si!1" "vi!1")
   (inst - "ep1" "so!1" "vo!1" "si!1" "vi!1")
   (skosimp*)
   (inst + "min(dso!1,dso!2)" "min(dvo!1,dvo!2)" "min(dsi!1,dsi!2)"
    "min(dvi!1,dvi!2)")
   (skosimp*)
   (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
   (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
   (assert)
   (expand "dot_vvv")
   (lemma "triangle")
   (inst -
    "ffvc(so!1,vo!1,si!1,vi!1) * ggvc(so!1,vo!1,si!1,vi!1) - ffvc(nso!1,nvo!1,nsi!1,nvi!1) * ggvc(so!1,vo!1,si!1,vi!1)"
    " ffvc(nso!1,nvo!1,nsi!1,nvi!1) * ggvc(so!1,vo!1,si!1,vi!1) -
                                                                                                                                                                                                                                                             ffvc(nso!1,nvo!1,nsi!1,nvi!1) * ggvc(nso!1,nvo!1,nsi!1,nvi!1)")
   (assert)
   (lemma "schwarz")
   (inst - "ffvc(so!1,vo!1,si!1,vi!1)-ffvc(nso!1,nvo!1,nsi!1,nvi!1)"
    "ggvc(so!1,vo!1,si!1,vi!1)")
   (assert)
   (lemma "schwarz")
   (inst - "ffvc(nso!1,nvo!1,nsi!1,nvi!1)"
    "ggvc(so!1,vo!1,si!1,vi!1) - ggvc(nso!1,nvo!1,nsi!1,nvi!1)")
   (assert)
   (rewrite "dot_sub_right")
   (rewrite "dot_sub_left")
   (case "norm(ffvc(so!1,vo!1,si!1,vi!1) - ffvc(nso!1,nvo!1,nsi!1,nvi!1)) * norm(ggvc(so!1,vo!1,si!1,vi!1)) + norm(ffvc(nso!1,nvo!1,nsi!1,nvi!1)) *
                                      norm(ggvc(so!1,vo!1,si!1,vi!1) - ggvc(nso!1,nvo!1,nsi!1,nvi!1))<epsil!1")
   (("1" (assert))
    ("2"
     (hide (-1 -2 -3 2))
     (case "norm(ffvc(nso!1,nvo!1,nsi!1,nvi!1)) <= norm(ffvc(so!1,vo!1,si!1,vi!1)) + ep1")
     (("1"
       (replace "ep1name" - rl)
       (hide "ep1name")
       (replace "ep2name" - rl)
       (hide "ep2name")
       (name "A" "ffvc(so!1,vo!1,si!1,vi!1)")
       (name "B" "ffvc(nso!1,nvo!1,nsi!1,nvi!1)")
       (name "X" "ggvc(so!1,vo!1,si!1,vi!1)")
       (name "Y" "ggvc(nso!1,nvo!1,nsi!1,nvi!1)")
       (label "yname" -1)
       (label "xname" -2)
       (label "bname" -3)
       (label "aname" -4)
       (replace "aname")
       (replace "bname")
       (replace "xname")
       (replace "yname")
       (hide "aname")
       (hide "bname")
       (hide "xname")
       (hide "yname")
       (copy "gcont")
       (reveal "ep1name")
       (reveal "xname")
       (replace -1)
       (hide -1)
       (replace -1)
       (name "myvar" "norm(A) + epsil!1 / (1+8 * norm(X))")
       (label "namemyvar" -1)
       (case "norm(A - B) * norm(X) < epsil!1/2 AND norm(B) * norm(X - Y) <= epsil!1/2")
       (("1" (flatten) (assert))
        ("2"
         (hide 2)
         (split +)
         (("1"
           (case "ep1*norm(X) < epsil!1/2")
           (("1" (copy "fcont") (mult-by -1 "norm(X)") (assert))
            ("2" (hide 2) (replace "ep1name" + :dir rl) (cross-mult 1))))
          ("2"
           (copy -4)
           (mult-by -1 "norm(X-Y)")
           (copy -4)
           (cross-mult -1)
           (assert))))))
      ("2"
       (hide 2)
       (hide-all-but ("fcont" 1))
       (lemma "norm_add_le")
       (inst - "ffvc(so!1,vo!1,si!1,vi!1)-ffvc(nso!1,nvo!1,nsi!1,nvi!1)"
        "-ffvc(so!1,vo!1,si!1,vi!1)")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "fffv"
         "LAMBDA (so,vo,si,vi): (# x:= ffrc(so,vo,si,vi), y:= 0 #)")
   (name "gggv"
         "LAMBDA (so,vo,si,vi): (# x:= ggrc(so,vo,si,vi), y:= 0 #)")
   (lemma "dot_vvv_cont")
   (inst - "fffv" "gggv")
   (("1"
     (hide -2 -3)
     (expand "dot_vvv")
     (expand "prod_vvr")
     (expand "gggv")
     (expand "fffv")
     (expand "*")
     (propax))
    ("2"
     (hide-all-but 1)
     (expand "continuous_vvv?")
     (typepred "ggrc")
     (expand "continuous_vvr?")
     (skosimp*)
     (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
     (skosimp*)
     (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
     (skosimp*)
     (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
     (assert)
     (rewrite "sqrt_sqv_norm" 1 :dir rl)
     (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
     (("1"
       (rewrite -1)
       (expand "gggv" +)
       (expand "-" +)
       (rewrite "sq_0")
       (assert)
       (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
       (("1" (rewrite -1 1))
        ("2"
         (hide-all-but 1)
         (skeep)
         (case "aaa>=0")
         (("1" (grind))
          ("2"
           (lemma "sqrt_sq")
           (inst - "-aaa")
           (rewrite "sq_neg")
           (split -)
           (("1" (replace -1) (expand "abs") (assert))
            ("2" (assert))))))))
      ("2" (hide-all-but 1) (grind))))
    ("3"
     (hide-all-but 1)
     (expand "continuous_vvv?")
     (typepred "ffrc")
     (expand "continuous_vvr?")
     (skosimp*)
     (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
     (skosimp*)
     (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
     (skosimp*)
     (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
     (assert)
     (rewrite "sqrt_sqv_norm" 1 :dir rl)
     (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
     (("1"
       (rewrite -1)
       (expand "fffv" +)
       (expand "-" +)
       (rewrite "sq_0")
       (assert)
       (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
       (("1" (rewrite -1 1))
        ("2"
         (hide-all-but 1)
         (skeep)
         (case "aaa>=0")
         (("1" (grind))
          ("2"
           (lemma "sqrt_sq")
           (inst - "-aaa")
           (rewrite "sq_neg")
           (split -)
           (("1" (replace -1) (expand "abs") (assert))
            ("2" (assert))))))))
      ("2" (hide-all-but 1) (grind))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vvr?")
   (skosimp*)
   (expand "const_vvr")
   (assert)
   (expand "abs")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "ggx" "LAMBDA (so,vo,si,vi): ggvc(so,vo,si,vi)`x")
   (name "ggy" "LAMBDA (so,vo,si,vi): ggvc(so,vo,si,vi)`y")
   (name "ggvy"
         "LAMBDA (so,vo,si,vi): (# x:= 0, y:= ggvc(so,vo,si,vi)`y #)")
   (name "ggvx"
         "LAMBDA (so,vo,si,vi): (# x:=ggvc(so,vo,si,vi)`x,y:=0 #)")
   (lemma "sum_vvv_cont")
   (inst - "scal_vvr_vvv(ffrc, ggvx)" "scal_vvr_vvv(ffrc,ggvy)")
   (("1"
     (hide-all-but (-1 1))
     (expand "sum_vvv")
     (expand "scal_vvr_vvv")
     (expand "ggvy")
     (expand "ggvx")
     (expand "*")
     (expand "+")
     (propax))
    ("2"
     (lemma "prod_vvr_cont")
     (inst - "ffrc" "ggy")
     (("1"
       (hide-all-but (-1 1))
       (expand "prod_vvr")
       (expand "scal_vvr_vvv")
       (expand "ggvy")
       (expand "*")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
       (skosimp*)
       (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
       (skosimp*)
       (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
       (assert)
       (expand "ggy")
       (expand "-")
       (rewrite "sqrt_sqv_norm" 1 :dir rl)
       (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
       (("1"
         (rewrite -1)
         (hide -1)
         (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
         (("1" (rewrite -1))
          ("2"
           (hide-all-but 1)
           (skeep)
           (expand "abs")
           (lift-if)
           (assert))))
        ("2" (hide-all-but 1) (grind))))
      ("2"
       (hide-all-but 1)
       (typepred "ggvc")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
       (skosimp*)
       (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
       (skosimp*)
       (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
       (assert)
       (expand "ggy")
       (lemma "norm_ge_comps")
       (inst?)
       (flatten)
       (grind :exclude "norm"))))
    ("3"
     (lemma "prod_vvr_cont")
     (inst - "ffrc" "ggx")
     (("1"
       (hide-all-but (-1 1))
       (expand "prod_vvr")
       (expand "scal_vvr_vvv")
       (expand "ggvx")
       (expand "*")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
       (skosimp*)
       (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
       (skosimp*)
       (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
       (assert)
       (expand "ggx")
       (expand "-")
       (rewrite "sqrt_sqv_norm" 1 :dir rl)
       (case "FORALL (vvww:Vect2): sqv(vvww) = sq(vvww`x) + sq(vvww`y)")
       (("1"
         (rewrite -1)
         (hide -1)
         (case "FORALL (aaa:real): sqrt(sq(aaa)) = abs(aaa)")
         (("1" (rewrite -1))
          ("2"
           (hide-all-but 1)
           (skeep)
           (expand "abs")
           (lift-if)
           (assert))))
        ("2" (hide-all-but 1) (grind))))
      ("2"
       (hide-all-but 1)
       (typepred "ggvc")
       (expand "continuous_vvv?")
       (expand "continuous_vvr?")
       (skosimp*)
       (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
       (skosimp*)
       (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
       (skosimp*)
       (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
       (assert)
       (expand "ggx")
       (lemma "norm_ge_comps")
       (inst?)
       (flatten)
       (grind :exclude "norm"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffrc")
   (expand "continuous_vvr?")
   (skosimp*)
   (inst - "epsil!1/(abs(c)+1)" "so!1" "vo!1" "si!1" "vi!1")
   (skosimp*)
   (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
   (skosimp*)
   (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
   (assert)
   (expand "scal_vvr")
   (case "FORALL (e1,e2:real): c*e1-c*e2 = c*(e1-e2)")
   (("1"
     (inst?)
     (replace -1)
     (rewrite "abs_mult")
     (hide -1)
     (cross-mult -1)
     (hide-all-but (-1 1))
     (grind))
    ("2" (hide-all-but 1) (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "continuous_vvr?(div_vvr(LAMBDA (so,vo,si,vi): 1, ggnzc))")
   (("1"
     (lemma "prod_vvr_cont")
     (inst - "ffrc" "div_vvr(LAMBDA (so,vo,si,vi): 1, ggnzc)")
     (hide -2)
     (expand "prod_vvr")
     (expand "div_vvr")
     (assert))
    ("2"
     (hide 2)
     (name "gg" "ggnzc")
     (replace -1)
     (hide -1)
     (typepred "gg")
     (expand "continuous_vvr?")
     (skosimp*)
     (expand "continuous_nz_vvr?")
     (flatten)
     (expand "continuous_vvr?")
     (name "newep"
           "min(abs(gg(so!1,vo!1,si!1,vi!1))/2,sq(gg(so!1,vo!1,si!1,vi!1))*epsil!1/4)")
     (inst - "newep" "so!1" "vo!1" "si!1" "vi!1")
     (("1"
       (skosimp*)
       (inst + "dso!1" "dvo!1" "dsi!1" "dvi!1")
       (skosimp*)
       (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
       (assert)
       (expand "div_vvr")
       (case "1 / gg(so!1,vo!1,si!1,vi!1) - 1 / gg(nso!1,nvo!1,nsi!1,nvi!1) = (gg(nso!1,nvo!1,nsi!1,nvi!1) - gg(so!1,vo!1,si!1,vi!1))/(gg(so!1,vo!1,si!1,vi!1)*gg(nso!1,nvo!1,nsi!1,nvi!1))")
       (("1"
         (replace -1)
         (rewrite "abs_div")
         (hide -1)
         (case "abs((gg(so!1,vo!1,si!1,vi!1) * gg(nso!1,nvo!1,nsi!1,nvi!1))) >= sq(gg(so!1,vo!1,si!1,vi!1))/2")
         (("1"
           (cross-mult 1)
           (typepred "newep")
           (mult-by -4 "epsil!1")
           (assert)
           (expand "abs")
           (lift-if)
           (ground))
          ("2"
           (hide 2)
           (rewrite "abs_mult")
           (case "abs(gg(nso!1,nvo!1,nsi!1,nvi!1)) >= abs(gg(so!1,vo!1,si!1,vi!1))/2")
           (("1"
             (lemma "sq_abs")
             (inst - "gg(so!1,vo!1,si!1,vi!1)")
             (expand "sq" -1 1)
             (replace -1 :dir rl)
             (hide -1)
             (mult-by -1 "abs(gg(so!1,vo!1,si!1,vi!1))")
             (assert))
            ("2"
             (hide 2)
             (lemma "triangle")
             (inst -
              "gg(so!1,vo!1,si!1,vi!1) - gg(nso!1,nvo!1,nsi!1,nvi!1)"
              "gg(nso!1,nvo!1,nsi!1,nvi!1)")
             (assert))))))
        ("2" (hide 2) (field))
        ("3"
         (expand "nzero_vvr?")
         (lemma "nzreal_times_nzreal_is_nzreal")
         (inst?))))
      ("2"
       (hide 2)
       (expand "nzero_vvr?")
       (inst - "so!1" "vo!1" "si!1" "vi!1")
       (assert)
       (flatten)
       (lemma "sq_eq_0")
       (inst?)
       (assert)
       (expand "min")
       (lift-if)
       (ground))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_vvv?")
   (skosimp*)
   (inst + "epsil!1" "1" "1" "1")
   (assert)
   (skosimp*))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_vvv?")
   (skosimp*)
   (inst + "1" "epsil!1" "1" "1")
   (assert)
   (skosimp*))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_vvv?")
   (skosimp*)
   (inst + "1" "1" "epsil!1" "1")
   (assert)
   (skosimp*))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_vvv?")
   (skosimp*)
   (inst + "1" "1" "1" "epsil!1")
   (assert)
   (skosimp*))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffrc")
   (typepred "ggrc")
   (expand "continuous_vvr?")
   (skosimp*)
   (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
   (inst - "epsil!1" "so!1" "vo!1" "si!1" "vi!1")
   (skosimp*)
   (inst + "min(dso!1,dso!2)" "min(dvo!1,dvo!2)" "min(dsi!1,dsi!2)"
    "min(dvi!1,dvi!2)")
   (skosimp*)
   (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
   (inst - "nso!1" "nvo!1" "nsi!1" "nvi!1")
   (assert)
   (hide-all-but (-1 -2 1))
   (expand "max_vvr")
   (grind))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: four_vects_2D_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "ffvc")
   (expand "continuous_vvr?")
   (expand "continuous_vvv?")
   (skeep)
   (inst - "epsil" "so" "vo" "si" "vi")
   (skeep -1)
   (inst + "dso" "dvo" "dsi" "dvi")
   (skeep)
   (inst - "nso" "nvo" "nsi" "nvi")
   (assert)
   (expand "norm_vvv")
   (case "FORALL (vv,ww:Vect2): abs(norm(vv)-norm(ww))<=norm(vv-ww)")
   (("1" (inst?) (assert))
    ("2"
     (hide-all-but 1)
     (skeep)
     (lemma "vectors_2D.norm_add_le")
     (inst - "vv-ww" "ww")
     (assert)
     (lemma "vectors_2D.norm_add_le")
     (inst - "ww-vv" "vv")
     (assert)
     (lemma "vectors_2D.norm_neg")
     (inst - "ww-vv")
     (case "-(ww-vv) = vv-ww")
     (("1"
       (replace -1)
       (hide -1)
       (replace -1 :dir rl)
       (expand "abs")
       (lift-if)
       (ground))
      ("2" (hide-all-but 1) (grind))))))


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


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f1!1")
   (typepred "f2!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (lemma "sum_derivable")
   (split +)
   (("1"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): f1!1(a)`x)" "(LAMBDA (a): f2!1(a)`x)" "x!1")
     (expand "+ ")
     (assert)
     (hide 1)
     (split +)
     (("1" (inst -3 "x!1")) ("2" (inst -1 "x!1"))))
    ("2"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): f1!1(a)`y)" "(LAMBDA (a): f2!1(a)`y)" "x!1")
     (assert)
     (expand "+ ")
     (assert)
     (hide 1)
     (split +)
     (("1" (inst -4 "x!1")) ("2" (inst -2 "x!1"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f1!1")
   (typepred "f2!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (lemma "diff_derivable")
   (split +)
   (("1"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): f1!1(a)`x)" "(LAMBDA (a): f2!1(a)`x)" "x!1")
     (expand "- ")
     (assert)
     (hide 1)
     (split +)
     (("1" (inst -3 "x!1")) ("2" (inst -1 "x!1"))))
    ("2"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): f1!1(a)`y)" "(LAMBDA (a): f2!1(a)`y)" "x!1")
     (assert)
     (expand "- ")
     (assert)
     (hide 1)
     (split +)
     (("1" (inst -4 "x!1")) ("2" (inst -2 "x!1"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (lemma "neg_derivable")
   (split +)
   (("1"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): f!1(a)`x)" "x!1")
     (assert)
     (expand "-")
     (assert)
     (inst -1 "x!1"))
    ("2"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): f!1(a)`y)" "x!1")
     (assert)
     (expand "-")
     (assert)
     (inst -2 "x!1"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (typepred "h!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (lemma "prod_derivable")
   (split +)
   (("1"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): h!1(a))" "(LAMBDA (a): f!1(a)`x)" "x!1")
     (assert)
     (expand "*")
     (assert)
     (hide 1)
     (split +)
     (("1"
       (inst?)
       (assert)
       (case-replace "(LAMBDA (a): h!1(a)) = h!1")
       (apply-extensionality 1 :hide? t))
      ("2" (inst -2 "x!1"))))
    ("2"
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (a): h!1(a))" "(LAMBDA (a): f!1(a)`y)" "x!1")
     (assert)
     (expand "*")
     (assert)
     (hide 1)
     (split +)
     (("1"
       (inst?)
       (case-replace "(LAMBDA (a): h!1(a)) = h!1")
       (apply-extensionality 1 :hide? t))
      ("2" (inst -3 "x!1"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f1!1")
   (typepred "f2!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "*")
   (lemma "sum_derivable_fun")
   (inst -
    "(LAMBDA (x: T):
                       f1!1(x)`x * f2!1(x)`x)"
    "(LAMBDA (x: T):
                       f1!1(x)`y * f2!1(x)`y)")
   (assert)
   (expand "+")
   (hide 2)
   (lemma "prod_derivable_fun")
   (split +)
   (("1"
     (inst - "(LAMBDA (x: T): f1!1(x)`x )" "(LAMBDA (x: T): f2!1(x)`x)")
     (expand "*")
     (propax))
    ("2"
     (inst - "(LAMBDA (x: T): f1!1(x)`y )" "(LAMBDA (x: T): f2!1(x)`y)")
     (expand "*")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable_rv?")
   (lemma "const_derivable_fun")
   (expand "const_fun")
   (split +)
   (("1" (inst?)) ("2" (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (expand "derivable_rv?")
   (expand "*")
   (flatten)
   (lemma "scal_derivable_fun")
   (split +)
   (("1"
     (inst - "c!1" "(LAMBDA (a): f!1(a)`x)")
     (assert)
     (expand "*")
     (propax))
    ("2" (inst - "c!1" "(LAMBDA (a): f!1(a)`y)") (expand "*") (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "prod_derivable_rv")
   (("1" (rewrite "id_derivable_fun"))
    ("2" (rewrite "const_derivable_rv"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sum_derivable_rv")
   (inst - "f1!1" "f2!1")
   (typepred "f1!1")
   (typepred "f2!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (expand "deriv")
   (expand "deriv_rv")
   (apply-extensionality 1 :hide? t)
   (expand "+ ")
   (prop)
   (("1"
     (lemma "deriv_sum")
     (inst - "(LAMBDA (a): f1!1(a)`x)" "(LAMBDA (a): f2!1(a)`x)" "x!1")
     (split -1)
     (("1" (expand "+ ") (propax)) ("2" (hide 2) (inst -3 "x!1"))
      ("3" (hide 2) (inst?))))
    ("2"
     (lemma "deriv_sum")
     (inst - "(LAMBDA (a): f1!1(a)`y)" "(LAMBDA (a): f2!1(a)`y)" "x!1")
     (assert)
     (split -1)
     (("1" (assert) (expand "+ ") (propax))
      ("2" (hide 2) (inst -4 "x!1")) ("3" (hide 2) (inst -2 "x!1"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "diff_derivable_rv")
   (inst - "f1!1" "f2!1")
   (typepred "f1!1")
   (typepred "f2!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (expand "deriv")
   (expand "deriv_rv")
   (apply-extensionality 1 :hide? t)
   (expand "- ")
   (prop)
   (("1"
     (lemma "deriv_diff")
     (inst - "(LAMBDA (a): f1!1(a)`x)" "(LAMBDA (a): f2!1(a)`x)" "x!1")
     (split -1)
     (("1" (expand "- ") (propax)) ("2" (hide 2) (inst -3 "x!1"))
      ("3" (hide 2) (inst?))))
    ("2"
     (lemma "deriv_diff")
     (inst - "(LAMBDA (a): f1!1(a)`y)" "(LAMBDA (a): f2!1(a)`y)" "x!1")
     (assert)
     (split -1)
     (("1" (assert) (expand "- ") (propax))
      ("2" (hide 2) (inst -4 "x!1")) ("3" (hide 2) (inst -2 "x!1"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (expand "deriv")
   (expand "deriv_rv")
   (apply-extensionality 1 :hide? t)
   (("1"
     (expand "-")
     (prop)
     (("1"
       (lemma "deriv_neg")
       (inst - "(LAMBDA (a): f!1(a)`x)" "x!1")
       (split -1)
       (("1" (expand "-") (propax)) ("2" (hide 2) (inst -1 "x!1"))))
      ("2"
       (lemma "deriv_neg")
       (inst - "(LAMBDA (a): f!1(a)`y)" "x!1")
       (split -1)
       (("1" (expand "-") (propax)) ("2" (hide 2) (inst -2 "x!1"))))))
    ("2"
     (skosimp*)
     (lemma "neg_derivable")
     (inst - "(LAMBDA (a): f!1(a)`y)" "r!1")
     (expand "-")
     (assert)
     (hide 2)
     (inst -2 "r!1"))
    ("3"
     (skosimp*)
     (lemma "neg_derivable")
     (inst - "(LAMBDA (a): f!1(a)`x)" "r!1")
     (assert)
     (expand "-")
     (assert)
     (inst -1 "r!1"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h!1")
   (typepred "f!1")
   (lemma "prod_derivable_rv")
   (inst - "f!1" "h!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (expand "deriv")
   (expand "deriv_rv")
   (expand "*")
   (expand "*")
   (expand "+")
   (apply-extensionality 1 :hide? t)
   (prop)
   (("1"
     (lemma "deriv_prod")
     (inst - "(LAMBDA (a): h!1(a))" "(LAMBDA (a): f!1(a)`x)" "x!1")
     (assert)
     (split -1)
     (("1"
       (expand "*")
       (replace -1)
       (hide -1)
       (case-replace "(LAMBDA (a): h!1(a)) = h!1")
       (("1" (assert)) ("2" (apply-extensionality 1 :hide? t))))
      ("2"
       (hide 2)
       (inst -5 "x!1")
       (case-replace "(LAMBDA (a): h!1(a)) = h!1")
       (assert)
       (apply-extensionality 1 :hide? t))
      ("3" (hide 2) (inst -3 "x!1"))))
    ("2"
     (lemma "deriv_prod")
     (inst - "(LAMBDA (a): h!1(a))" "(LAMBDA (a): f!1(a)`y)" "x!1")
     (assert)
     (split -1)
     (("1"
       (expand "*")
       (replace -1)
       (hide -1)
       (assert)
       (case-replace "(LAMBDA (a): h!1(a)) = h!1")
       (("1" (assert)) ("2" (apply-extensionality 1 :hide? t))))
      ("2"
       (hide 2)
       (inst -5 "x!1")
       (case-replace "(LAMBDA (a): h!1(a)) = h!1")
       (apply-extensionality 1 :hide? t))
      ("3" (inst -4 "x!1"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f1!1")
   (typepred "f2!1")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?")
   (expand "*")
   (expand "+")
   (lemma "deriv_sum_fun")
   (inst -
    "(LAMBDA (x: T):
                           f1!1(x)`x * f2!1(x)`x)"
    "(LAMBDA (x: T):
                           f1!1(x)`y * f2!1(x)`y)")
   (("1"
     (expand "+")
     (replace -1)
     (hide -1)
     (apply-extensionality 1 :hide? t)
     (("1"
       (expand "deriv")
       (expand "deriv_rv")
       (lemma "deriv_prod")
       (inst-cp - "(LAMBDA (x: T): f1!1(x)`x )"
        "(LAMBDA (x: T): f2!1(x)`x)" "x!1")
       (inst - "(LAMBDA (x: T): f1!1(x)`y )" "(LAMBDA (x: T): f2!1(x)`y)"
        "x!1")
       (split -1)
       (("1"
         (split -2)
         (("1" (assert) (expand "*") (assert))
          ("2" (hide -1 2) (inst -3 "x!1"))
          ("3" (hide -1 2) (inst -1 "x!1"))))
        ("2" (hide -1 2) (inst -4 "x!1"))
        ("3" (hide -1 2) (inst -2 "x!1"))))
      ("2"
       (skosimp*)
       (lemma "prod_derivable_fun")
       (inst - "(LAMBDA (x: T): f1!1(x)`y )"
        "(LAMBDA (x: T): f2!1(x)`y)")
       (assert)
       (expand "*")
       (hide 2)
       (split +)
       (("1" (expand "derivable?" 1) (propax))
        ("2" (expand "derivable?" 1) (propax))))
      ("3"
       (skosimp*)
       (lemma "prod_derivable_fun")
       (inst - "(LAMBDA (x: T): f1!1(x)`x )"
        "(LAMBDA (x: T): f2!1(x)`x)")
       (assert)
       (expand "*")
       (hide 2)
       (expand "derivable?" 1)
       (split +)
       (("1" (propax)) ("2" (propax))))))
    ("2"
     (hide 2)
     (lemma "prod_derivable_fun")
     (inst - "(LAMBDA (x: T): f1!1(x)`y )" "(LAMBDA (x: T): f2!1(x)`y)")
     (expand "*")
     (assert)
     (hide 2)
     (expand "derivable?")
     (split +)
     (("1" (assert)) ("2" (assert))))
    ("3"
     (hide 2)
     (lemma "prod_derivable_fun")
     (inst - "(LAMBDA (x: T): f1!1(x)`x )" "(LAMBDA (x: T): f2!1(x)`x)")
     (expand "*")
     (split -1)
     (("1" (propax)) ("2" (hide 2) (expand "derivable?" 1) (propax))
      ("3" (hide 2) (expand "derivable?" 1) (propax))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sqv")
   (lemma "deriv_dot_vfun")
   (inst?)
   (assert)
   (replace -1)
   (hide -1)
   (apply-extensionality 1 :hide? t)
   (expand "+")
   (assert)
   (lemma "dot_comm")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deriv")
   (lemma "deriv_const")
   (expand "const_fun")
   (apply-extensionality 1 :hide? t)
   (("1"
     (expand "zero")
     (expand "deriv_rv")
     (split +)
     (("1" (inst?)) ("2" (inst?))))
    ("2" (skosimp*) (lemma "const_derivable_rv") (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (lemma "scal_derivable_rv")
   (inst - "c!1" "f!1")
   (expand "derivable_rv?" -2)
   (flatten)
   (expand "derivable?")
   (expand "deriv")
   (expand "deriv_rv")
   (expand "*")
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_scal")
     (split +)
     (("1" (inst?) (assert) (expand "*") (hide 1) (inst - "x!1"))
      ("2" (inst?) (expand "*") (assert) (hide 1) (inst -3 "x!1"))))
    ("2"
     (skosimp*)
     (expand "derivable_rv?")
     (flatten)
     (assert)
     (expand "derivable?" -2)
     (inst?))
    ("3"
     (skosimp*)
     (expand "derivable_rv?")
     (flatten)
     (hide -3 -4)
     (expand "derivable?" -)
     (inst -1 "r!1"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "deriv_prod_vfun")
   (("1"
     (apply-extensionality 1 :hide? t)
     (("1"
       (expand "*")
       (rewrite "deriv_id_fun")
       (assert)
       (rewrite "deriv_const_vfun")
       (assert))
      ("2" (skosimp*) (rewrite "const_derivable_rv"))
      ("3" (skosimp*) (rewrite "id_derivable_fun"))))
    ("2" (rewrite "id_derivable_fun"))
    ("3" (rewrite "const_derivable_rv"))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "V")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (inst - "r"))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: deriv_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "V")
   (expand "derivable_rv?")
   (flatten)
   (expand "derivable?" -)
   (inst - "r")
   (inst - "r"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_deriv_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "detsv")
   (expand "det")
   (lemma "derivable_diff")
   (inst - "(lambda (r): s`x * V(r)`y)" "(lambda (r): s`y * V(r)`x)")
   (("1" (expand "-[T]" -) (propax))
    ("2"
     (lemma "derivable_scal")
     (inst - "s`y" "(LAMBDA (r): V(r)`x)")
     (("1" (expand "*" -) (propax))
      ("2" (typepred "V") (expand "derivable_rv?") (assert))))
    ("3"
     (lemma "derivable_scal")
     (inst - "s`x" "(LAMBDA (r): V(r)`y)")
     (("1" (expand "*" -) (propax))
      ("2" (typepred "V") (expand "derivable_rv?") (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_deriv_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "detsv")
   (expand "det")
   (expand "deriv_rv")
   (expand "deriv" 1 1)
   (case "derivable?(lambda(a): V(a)`y) AND derivable?(lambda(a): V(a)`x)")
   (("1"
     (case "derivable?(LAMBDA (r): s`x * V(r)`y) AND derivable?(LAMBDA (r): s`y * V(r)`x)")
     (("1"
       (case "derivable?(LAMBDA (r): s`x * V(r)`y - s`y * V(r)`x)")
       (("1"
         (label "diffderiv" -1)
         (hide -1)
         (label "constderiv" -1)
         (hide -1)
         (flatten)
         (label "yderiv" -1)
         (label "xderiv" -2)
         (case "deriv(LAMBDA (r): s`x * V(r)`y - s`y * V(r)`x) =
                                               s`x * deriv(LAMBDA (a): V(a)`y) -
                                                s`y * deriv(LAMBDA (a): V(a)`x)")
         (("1"
           (assert)
           (decompose-equality)
           (("1"
             (inst - "r")
             (expand "deriv" -)
             (expand "*" -)
             (expand "-" -)
             (propax))
            ("2" (hide 2) (hide (-1 -2 2)) (reveal -4) (propax))))
          ("2"
           (hide (-1 -2 2))
           (lemma "deriv_diff_fun")
           (inst - "LAMBDA (r): s`x * V(r)`y" "LAMBDA (r): s`y * V(r)`x")
           (("1"
             (lemma "deriv_scal_fun")
             (inst - "s`x" "lambda (r): V(r)`y")
             (("1"
               (expand "*" -1 1)
               (lemma "deriv_scal_fun")
               (inst - "s`y" "lambda (r): V(r)`x")
               (("1"
                 (expand "*" -1 1)
                 (expand "-" -3 1)
                 (replace -3)
                 (assert))
                ("2" (reveal "xderiv") (propax))))
              ("2" (reveal "yderiv") (propax))))
            ("2" (reveal "constderiv") (assert))
            ("3" (reveal "constderiv") (assert))))
          ("3" (propax)) ("4" (propax))
          ("5" (reveal "diffderiv") (propax))))
        ("2"
         (lemma "derivable_diff")
         (inst - "LAMBDA (r): s`x * V(r)`y" "LAMBDA (r): s`y * V(r)`x")
         (("1" (expand "-" -1) (propax)) ("2" (assert))
          ("3" (assert))))))
      ("2"
       (lemma "derivable_scal")
       (ground)
       (("1"
         (inst - "s`x" "LAMBDA (r): V(r)`y")
         (expand "*" -1)
         (propax))
        ("2"
         (inst - "s`y" "LAMBDA (r): V(r)`x")
         (expand "*" -1)
         (propax))))))
    ("2" (typepred "V") (expand "derivable_rv?") (ground))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_deriv_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "sqv")
   (expand "*")
   (case "derivable?((LAMBDA (r): V(r)`x)) AND derivable?((LAMBDA (r): V(r)`y))")
   (("1"
     (flatten)
     (lemma "derivable_sum")
     (inst - "LAMBDA (r): V(r)`x * V(r)`x" "LAMBDA (r): V(r)`y * V(r)`y")
     (("1" (expand "+" -1) (propax))
      ("2"
       (lemma "derivable_prod")
       (inst - "LAMBDA (r): V(r)`y" "LAMBDA (r): V(r)`y")
       (expand "*" -1)
       (propax))
      ("3"
       (lemma "derivable_prod")
       (inst - "LAMBDA (r): V(r)`x" "LAMBDA (r): V(r)`x")
       (expand "*" -1)
       (propax))))
    ("2" (typepred "V") (expand "derivable_rv?") (propax))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_deriv_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "derivable?(lambda(a): V(a)`y) AND derivable?(lambda(a): V(a)`x)")
   (("1"
     (case "derivable?(LAMBDA (a): V(a)`y*V(a)`y) AND derivable?(LAMBDA (a): V(a)`x*V(a)`x)")
     (("1"
       (case "derivable?(LAMBDA (a): V(a)`x * V(a)`x + V(a)`y * V(a)`y)")
       (("1"
         (flatten)
         (label "totderiv" -1)
         (label "ypderiv" -2)
         (label "xpderiv" -3)
         (label "yderiv" -4)
         (label "xderiv" -5)
         (expand "sqv")
         (expand "*")
         (expand "deriv_rv")
         (lemma "deriv_sum")
         (inst - "LAMBDA (r): V(r)`x * V(r)`x"
          "LAMBDA (r): V(r)`y * V(r)`y" "r1")
         (copy "ypderiv")
         (copy "xpderiv")
         (expand "derivable?" -1)
         (expand "derivable?" -2)
         (inst - "r1")
         (inst - "r1")
         (assert)
         (hide -1)
         (hide -1)
         (expand "deriv" + 1)
         (expand "+" -1)
         (replace -1)
         (hide -1)
         (lemma "deriv_prod")
         (inst-cp - "LAMBDA (r): V(r)`x" "LAMBDA (r): V(r)`x" "r1")
         (expand "*" -2)
         (inst - "LAMBDA (r): V(r)`y" "LAMBDA (r): V(r)`y" "r1")
         (assert)
         (copy "yderiv")
         (copy "xderiv")
         (expand "derivable?" -1)
         (expand "derivable?" -2)
         (inst - "r1")
         (inst - "r1")
         (assert)
         (hide -1)
         (hide -1)
         (expand "*" -)
         (assert))
        ("2"
         (lemma "derivable_sum")
         (inst - "LAMBDA (a): V(a)`x * V(a)`x"
          "LAMBDA (a): V(a)`y * V(a)`y")
         (("1" (expand "+" -1) (propax)) ("2" (assert))
          ("3" (assert))))))
      ("2"
       (lemma "derivable_prod")
       (inst-cp -1 "LAMBDA (a): V(a)`y" "LAMBDA (a): V(a)`y")
       (("1"
         (inst - "LAMBDA (a): V(a)`x" "LAMBDA (a): V(a)`x")
         (("1" (expand "*" -) (assert)) ("2" (assert))))
        ("2" (assert))))))
    ("2" (typepred "V") (expand "derivable_rv?") (flatten) (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_chain_rule
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable_rv?")
   (flatten)
   (split +)
   (("1"
     (hide -3)
     (lemma "composition_derivable[T1,T2]")
     (("1"
       (expand "derivable?" 1)
       (skosimp*)
       (inst - "f!1" "(LAMBDA (a: T2): g!1(a)`x)" "x!1")
       (expand "o ")
       (assert)
       (hide 2)
       (expand derivable? -)
       (inst?)
       (inst?)
       (assert))
      ("2" (lemma "not_one_element2") (propax))
      ("3" (lemma "deriv_domain2") (expand "deriv_domain?") (propax))
      ("4" (lemma "not_one_element1") (propax))
      ("5" (lemma "deriv_domain1") (expand "deriv_domain?") (propax))))
    ("2"
     (hide -2)
     (lemma "composition_derivable[T1,T2]")
     (("1"
       (expand "derivable?" 1)
       (skosimp*)
       (inst - "f!1" "(LAMBDA (a: T2): g!1(a)`y)" "x!1")
       (expand "o ")
       (assert)
       (hide 2)
       (expand derivable? -)
       (inst?)
       (inst?)
       (assert))
      ("2" (lemma "not_one_element2") (propax))
      ("3" (lemma "deriv_domain2") (expand "deriv_domain?") (propax))
      ("4" (lemma "not_one_element1") (propax))
      ("5" (lemma "deriv_domain1") (expand "deriv_domain?") (propax))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_chain_rule
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (expand "*" 1)
   (lemma "composition_derivable_vfun")
   (inst?)
   (assert)
   (expand "deriv")
   (apply-extensionality 1 :hide? t)
   (("1"
     (expand "deriv_rv")
     (expand "o ")
     (expand "*")
     (split +)
     (("1"
       (lemma "deriv_composition[T1,T2]")
       (("1"
         (inst?)
         (assert)
         (split -1)
         (("1" (expand "o ") (replace -1) (hide -1) (assert))
          ("2" (hide 2) (expand "derivable?" -2) (inst?))
          ("3"
           (hide 2)
           (expand "derivable_rv?")
           (flatten)
           (expand "derivable?" -)
           (inst -4 "ff!1(x!1)"))))
        ("2" (lemma "not_one_element2") (propax))
        ("3" (lemma "deriv_domain2") (propax))
        ("4" (lemma "not_one_element1") (propax))
        ("5" (lemma "deriv_domain1") (propax))))
      ("2"
       (lemma "deriv_composition[T1,T2]")
       (("1"
         (inst?)
         (assert)
         (split -1)
         (("1" (expand "o ") (replace -1) (hide -1) (assert))
          ("2" (hide 2) (expand "derivable?" -2) (inst?))
          ("3"
           (hide 2)
           (expand "derivable_rv?")
           (flatten)
           (expand "derivable?" -)
           (inst -5 "ff!1(x!1)"))))
        ("2" (lemma "not_one_element2") (propax))
        ("3" (lemma "deriv_domain2") (propax))
        ("4" (lemma "not_one_element1") (propax))
        ("5" (lemma "deriv_domain1") (propax))))))
    ("2" (lemma "not_one_element1") (skosimp*))
    ("3"
     (skosimp*)
     (lemma "deriv_domain1")
     (expand "deriv_domain?")
     (inst?))
    ("4" (expand "derivable?" -2) (propax))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-" "sigma") :if-match nil)
   (case "norm(l1!1 - l2!1) = 0")
   (("1"
     (hide -2 -3 -4)
     (lemma "norm_eq_0")
     (inst?)
     (assert)
     (lemma "add_move_right")
     (inst?)
     (inst -1 "zero")
     (assert))
    ("2"
     (name "eps" "norm(l1!1 - l2!1)")
     (replace -1)
     (inst -3 "eps/2")
     (("1"
       (inst -4 "eps/2")
       (("1"
         (skosimp*)
         (case " EXISTS (x: T): a!1 /= x AND abs(x - a!1) < delta!1 AND abs(x - a!1) < delta!2")
         (("1"
           (skosimp*)
           (inst?)
           (inst?)
           (lemma "dist_triangle")
           (inst - "l1!1" "f!1(x!1)" "l2!1")
           (rewrite "dist_norm")
           (rewrite "dist_norm")
           (rewrite "dist_norm")
           (case-replace "norm(l1!1 - l2!1) > 0")
           (("1"
             (assert)
             (lemma "norm_sym")
             (inst - "l1!1" "f!1(x!1)")
             (assert))
            ("2" (lemma "norm_eq_0") (inst?) (assert))))
          ("2"
           (name "DEL" "min(delta!1,delta!2)")
           (inst - "a!1")
           (inst - "a!1")
           (assert)
           (lemma "norm_triangle")
           (inst?)
           (inst - "f!1(a!1)")
           (assert)
           (lemma "norm_sym")
           (inst - "l1!1" "f!1(a!1)")
           (assert))))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (case "norm(l!1 - f!1(x!1)) = 0")
   (("1" (lemma "norm_eq_0") (inst?) (assert) (rewrite "sub_eq_zero"))
    ("2"
     (inst - "norm(l!1 - f!1(x!1))")
     (("1" (skosimp*) (inst?) (assert) (rewrite "norm_sym") (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind :exclude ("abs" "norm" "+" "-") :if-match nil)
   (inst - "epsilon!1/4")
   (inst - "epsilon!1/4")
   (skosimp*)
   (inst 1 "min(delta!1, delta!2)")
   (skosimp*)
   (inst?)
   (inst?)
   (assert)
   (lemma "norm_add_le")
   (inst - "f1(x!1) - l1" "f2(x!1)-l2")
   (case-replace
    "norm(f1(x!1) - l1 + (f2(x!1) - l2)) = norm((f1 + f2)(x!1) - (l1 + l2))")
   (("1" (assert)) ("2" (hide-all-but 1) (grind :exclude "norm"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (inst - "epsilon!1")
   (skolem!)
   (inst + "delta!1")
   (skosimp)
   (inst?)
   (assert)
   (case-replace "norm((-f)(x!1) - -l) = norm(f(x!1) -l)")
   (assert)
   (hide-all-but 1)
   (lemma "norm_neg")
   (inst - "f(x!1) - l")
   (grind :exclude "norm"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "f1!1 - f2!1 = f1!1 + (-f2!1)")
   (("1"
     (lemma "cv_sum")
     (inst?)
     (inst - "(-f2!1)" "-l2!1")
     (assert)
     (hide 2)
     (lemma "cv_neg")
     (inst?)
     (assert))
    ("2" (hide-all-but 1) (grind) (apply-extensionality 1 :hide? t))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (";;; Proof cv_const-1 for formula limit_real_vect2.cv_const"
   ";;; developed with shostak decision procedures"
   (expand "convergence")
   (skosimp*)
   (expand "const_vfun")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "b = 0")
   (("1"
     (assert)
     (lemma "cv_const")
     (inst - "a" "zero")
     (expand "const_vfun")
     (propax))
    ("2"
     (expand "convergence")
     (skosimp*)
     (inst - "epsilon!1/abs(b)")
     (("1"
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst?)
       (assert)
       (cross-mult -1)
       (lemma "norm_scal")
       (inst - "b" "f(x!1)-l")
       (rewrite "scal_sub_right")
       (expand "*" 2 1)
       (assert))
      ("2"
       (hide 3)
       (case "epsilon!1 / abs(b) > 0")
       (("1" (assert)) ("2" (cross-mult 1) (assert))
        ("3" (lemma "abs_eq_0") (inst?) (assert))))
      ("3" (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (name-replace "ll" "lim(f!1, x0!1)" :hide? nil)
   (expand "lim" -)
   (typepred "choose(LAMBDA l: convergence(f!1, x0!1, l))")
   (("1" (assert))
    ("2"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst?)
     (assert))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: limit_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "nonempty?")
   (expand "empty?")
   (expand "member")
   (typepred "x0!1")
   (expand "convergent?")
   (skosimp*)
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (split +)
   (("1" (expand "continuous_rv?") (expand "convergence") (flatten))
    ("2"
     (flatten)
     (expand "convergence")
     (expand "continuous_rv?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (split +)
   (("1"
     (flatten)
     (expand "continuous?")
     (expand "continuous_rv?")
     (split +)
     (("1"
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + delta!1)
       (skosimp*)
       (inst?)
       (assert)
       (hide -1)
       (lemma "norm_ge_comps")
       (inst?)
       (expand "-")
       (assert))
      ("2"
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + delta!1)
       (skosimp*)
       (inst?)
       (assert)
       (hide -1)
       (lemma "norm_ge_comps")
       (inst?)
       (flatten)
       (hide -1)
       (expand "-")
       (assert))))
    ("2"
     (flatten)
     (expand "continuous_rv?")
     (expand "continuous?")
     (skosimp*)
     (inst -1 "epsilon!1/sqrt(2)")
     (inst -2 "epsilon!1/sqrt(2)")
     (skosimp*)
     (inst + "min(delta!1,delta!2)")
     (skeep)
     (inst - "x")
     (inst - "x")
     (assert)
     (lemma "sq_lt")
     (inst - "norm(f!1(x) - f!1(a!1))" "epsilon!1")
     (assert)
     (hide 2)
     (lemma "sq_lt")
     (inst - "abs(f!1(x)`x - f!1(a!1)`x)" "epsilon!1 / sqrt(2)")
     (assert)
     (hide -2)
     (lemma "sq_lt")
     (inst - "abs(f!1(x)`y - f!1(a!1)`y)" "epsilon!1 / sqrt(2)")
     (assert)
     (hide -3)
     (add-formulas -1 -2)
     (case-replace "2 * sq(epsilon!1 / sqrt(2)) = sq(epsilon!1)")
     (("1"
       (case "sq(norm(f!1(x) - f!1(a!1))) = sq(f!1(x)`x - f!1(a!1)`x) + sq(f!1(x)`y - f!1(a!1)`y)")
       (("1" (assert)) ("2" (hide - 2) (rewrite "sq_norm") (grind))))
      ("2" (hide-all-but 1) (grind) (field 1))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (split +)
   (("1"
     (flatten)
     (expand "continuous?")
     (expand "continuous_rv?")
     (expand "continuous_rv?")
     (expand "continuous?")
     (split +)
     (("1"
       (skeep)
       (skosimp*)
       (inst - x0)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + delta!1)
       (skosimp*)
       (inst?)
       (assert)
       (hide -1)
       (lemma "norm_ge_comps")
       (inst?)
       (expand "-")
       (assert))
      ("2"
       (skeep)
       (skosimp*)
       (inst - x0)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + delta!1)
       (skosimp*)
       (inst?)
       (assert)
       (hide -1)
       (lemma "norm_ge_comps")
       (inst?)
       (flatten)
       (hide -1)
       (expand "-")
       (assert))))
    ("2"
     (flatten)
     (expand "continuous_rv?")
     (expand "continuous?")
     (expand "continuous_rv?")
     (expand "continuous?")
     (skeep)
     (skosimp*)
     (inst - x0)
     (inst -2 x0)
     (inst -1 "epsilon!1/sqrt(2)")
     (inst -2 "epsilon!1/sqrt(2)")
     (skosimp*)
     (inst + "min(delta!1,delta!2)")
     (skeep)
     (inst - "x")
     (inst - "x")
     (assert)
     (lemma "sq_lt")
     (inst - "norm(f!1(x) - f!1(x0))" "epsilon!1")
     (assert)
     (hide 2)
     (lemma "sq_lt")
     (inst - "abs(f!1(x)`x - f!1(x0)`x)" "epsilon!1 / sqrt(2)")
     (assert)
     (hide -2)
     (lemma "sq_lt")
     (inst - "abs(f!1(x)`y - f!1(x0)`y)" "epsilon!1 / sqrt(2)")
     (assert)
     (hide -3)
     (add-formulas -1 -2)
     (case-replace "2 * sq(epsilon!1 / sqrt(2)) = sq(epsilon!1)")
     (("1"
       (case "sq(norm(f!1(x) - f!1(x0))) = sq(f!1(x)`x - f!1(x0)`x) + sq(f!1(x)`y - f!1(x0)`y)")
       (("1" (assert)) ("2" (hide - 2) (rewrite "sq_norm") (grind))))
      ("2" (hide-all-but 1) (grind) (field 1))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "continuity_def2")
   (lemma "const_fun_convergent")
   (expand "const_vfun")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_rv?")
   (skosimp*)
   (case "abs(a) = 0")
   (("1"
     (case-replace "a = 0")
     (("1"
       (inst + "100")
       (skosimp*)
       (hide -)
       (case-replace "(0 * f)(x!1) - (0 * f)(x0) = zero")
       (("1" (assert))
        ("2" (hide 2) (grind) (apply-extensionality 1 :hide? t))))
      ("2" (hide -2 2) (lemma "abs_eq_0") (inst?) (assert))))
    ("2"
     (inst - "epsilon!1/abs(a)")
     (("1"
       (skosimp*)
       (inst + delta!1)
       (skosimp*)
       (inst - x!1)
       (assert)
       (cross-mult -1)
       (assert)
       (expand "*")
       (lemma "norm_scal")
       (inst - a "f(x!1) - f(x0)")
       (assert)
       (replace -1 * rl)
       (hide -1)
       (grind :exclude "norm"))
      ("2"
       (assert)
       (hide 2)
       (case "epsilon!1 / abs(a) > 0")
       (("1" (assert)) ("2" (hide 2) (cross-mult 1) (assert))))
      ("3" (case "abs(a) = 0") (("1" (propax)) ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "continuous_iff_comps")
   (inst - "x0!1" "hh!1 * f!1")
   (assert)
   (hide 2)
   (lemma "continuous_iff_comps")
   (inst?)
   (assert)
   (hide -3)
   (flatten)
   (lemma prod_continuous)
   (inst - "(LAMBDA (t: T): hh!1(t))" "(LAMBDA (t: T): f!1(t)`x)" "x0!1")
   (expand "*" -1)
   (assert)
   (split -1)
   (("1"
     (assert)
     (expand "*" 1)
     (expand "*")
     (hide -1 -2)
     (lemma prod_continuous)
     (inst - "(LAMBDA (t: T): hh!1(t))" "(LAMBDA (t: T): f!1(t)`y)"
      "x0!1")
     (expand "*" -1)
     (case-replace "(LAMBDA (t: T): hh!1(t)) = hh!1")
     (("1" (assert)) ("2" (apply-extensionality 1 :hide? t))))
    ("2"
     (case-replace "(LAMBDA (t: T): hh!1(t)) = hh!1")
     (apply-extensionality 1 :hide? t))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (inst?)
   (lemma "sum_continuous_rv")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "diff_continuous_rv"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_rv?")
   (skosimp*)
   (lemma "const_continuous_rv")
   (inst?)
   (expand "const_vfun")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_rv?")
   (skosimp*)
   (lemma "scal_continuous_rv")
   (inst?)
   (assert)
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "cont_rv_iff_comps")
   (inst - "hh!1 * f!1")
   (assert)
   (hide 2)
   (lemma "cont_rv_iff_comps")
   (inst?)
   (assert)
   (hide -3)
   (flatten)
   (lemma prod_cont_fun)
   (inst - "(LAMBDA (t: T): hh!1(t))" "(LAMBDA (t: T): f!1(t)`x)")
   (expand "*" -1)
   (assert)
   (split -1)
   (("1"
     (assert)
     (expand "*" 1)
     (expand "*")
     (hide -1 -2)
     (lemma prod_cont_fun)
     (inst - "(LAMBDA (t: T): hh!1(t))" "(LAMBDA (t: T): f!1(t)`y)")
     (expand "*" -1)
     (case-replace "(LAMBDA (t: T): hh!1(t)) = hh!1")
     (("1" (assert)) ("2" (apply-extensionality 1 :hide? t))))
    ("2"
     (case-replace "(LAMBDA (t: T): hh!1(t)) = hh!1")
     (apply-extensionality 1 :hide? t))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (rewrite "neg_continuous_rv"))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "(LAMBDA (x: T): zero)")
   (expand "continuous_rv?")
   (skosimp*)
   (expand "continuous_rv?")
   (skosimp*)
   (inst + "1")
   (skosimp*)
   (assert))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "sum_continuous_rv"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "diff_continuous_rv"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_real_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h!1")
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (rewrite "neg_continuous_rv"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-" "sigma") :if-match nil)
   (case "norm(l1!1 - l2!1) = 0")
   (("1"
     (lemma "norm_eq_0")
     (inst?)
     (assert)
     (lemma "add_move_right")
     (inst?)
     (inst -1 "zero")
     (assert))
    ("2"
     (name "eps" "norm(l1!1 - l2!1)")
     (replace -1)
     (inst -3 "eps/2")
     (("1"
       (inst -2 "eps/2")
       (("1"
         (skosimp*)
         (case " EXISTS (x: Vect2): norm(x - a!1) < delta!1 AND norm(x - a!1) < delta!2")
         (("1"
           (skosimp*)
           (inst?)
           (inst?)
           (lemma "norm_triangle")
           (inst - "l1!1" "f!1(x!1)" "l2!1")
           (case-replace "norm(l1!1 - l2!1) > 0")
           (("1"
             (assert)
             (lemma "norm_sym")
             (inst - "l1!1" "f!1(x!1)")
             (assert))
            ("2" (lemma "norm_eq_0") (inst?) (assert))))
          ("2"
           (name "DEL" "min(delta!1,delta!2)")
           (inst + "a!1")
           (assert))))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (name-replace "ll" "lim(f!1, x0!1)" :hide? nil)
   (expand "lim" -)
   (typepred "x0!1")
   (expand "convergent?")
   (skosimp*)
   (assert))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: limit_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "x0")
   (expand "nonempty?")
   (expand "empty?")
   (expand "convergent?")
   (skosimp*)
   (expand "member")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :defs nil :rewrites
    ("continuity_def2" "const_fun_convergent" "adherence_fullset")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vv?")
   (expand "convergence")
   (skosimp*)
   (inst + "epsilon!1")
   (skosimp*))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (inst?)
   (lemma "sum_continuous_vv")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "diff_continuous_vv"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (rewrite "neg_continuous_vv"))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "(LAMBDA (x: Vect2): zero)")
   (expand "continuous_vv?")
   (skosimp*)
   (expand "continuous_vv?")
   (skosimp*)
   (inst + "1")
   (skosimp*)
   (assert))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "sum_continuous_vv"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "diff_continuous_vv"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_vect2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h!1")
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (rewrite "neg_continuous_vv"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (rewrite "abs_diff_0")
   (name "eps" "abs(l1!1 - l2!1)")
   (replace -1)
   (inst -4 "eps/2")
   (("1"
     (inst -5 "eps/2")
     (("1"
       (assert)
       (skosimp*)
       (case " EXISTS (x: Vect2): a!1 /= x AND norm(x - a!1) < delta!1 AND norm(x - a!1) < delta!2")
       (("1"
         (skosimp*)
         (inst?)
         (inst?)
         (assert)
         (case "0 < norm(x!1 - a!1)")
         (("1"
           (assert)
           (lemma "triangle2")
           (inst - "eps/2" "eps/2" "l1!1" "f!1(x!1)" "l2!1")
           (assert))
          ("2"
           (lemma "norm_eq_0")
           (inst?)
           (assert)
           (replace -1 * lr)
           (assert)
           (rewrite "sub_eq_zero"))))
        ("2"
         (hide -4 -5)
         (name "DEL" "min(delta!1,delta!2)")
         (inst + "(a!1`x + DEL/2, a!1`y)")
         (grind))))
      ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (rewrite "abs_diff_0")
   (inst - "abs(l!1 - f!1(x!1))")
   (("1"
     (skosimp*)
     (inst?)
     (assert)
     (rewrite "abs_diff_commute" -)
     (assert))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (inst - "epsilon!1/2")
   (inst - "epsilon!1/2")
   (skosimp*)
   (inst 1 "min(delta!1, delta!2)")
   (skosimp*)
   (inst?)
   (inst?)
   (assert)
   (lemma "triangle" ("x" "f1!1(x!1) - l1!1" "y" "f2!1(x!1) - l2!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (inst - "epsilon!1")
   (skolem!)
   (inst + "delta!1")
   (skosimp)
   (inst?)
   (assert)
   (expand "-")
   (lemma "abs_neg")
   (inst - "f!1(x!1) - l!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "diff_function")
   (lemma "cv_sum")
   (inst?)
   (inst - "(-f2!1)" "-l2!1")
   (assert)
   (hide 2)
   (lemma "cv_neg")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (lemma "prod_epsilon" ("y1" "l1!1" "y2" "l2!1" "e" "epsilon!1"))
   (skosimp*)
   (inst - "e1!1")
   (inst - "e2!1")
   (skosimp*)
   (inst 1 "min(delta!1, delta!2)")
   (skosimp*)
   (inst?)
   (inst?)
   (assert)
   (lemma "prod_bound")
   (inst -1 "e1!1" "e2!1" "f1!1(x!1)" "f2!1(x!1)" "l1!1" "l2!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (lemma "inv_epsilon" ("y1" "l!1" "e" "epsilon!1"))
   (assert)
   (skosimp)
   (inst? -)
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst?)
   (assert)
   (lemma "inv_bound" ("e1" "e1!1" "x1" "g!1(x!1)" "y1" "l!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "div_function")
   (assert)
   (use "cv_prod" ("l2" "1/l2!1"))
   (assert)
   (rewrite "cv_inv"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (case "l2!1 < l1!1")
   (("1"
     (case "l2!1 < l1!1")
     (("1"
       (name "eps" "(l1!1 - l2!1)/2")
       (assert)
       (inst - "eps")
       (inst - "eps")
       (skosimp*)
       (inst?)
       (inst?)
       (inst?)
       (assert)
       (grind))
      ("2" (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "cv_const")
   (inst - "b!1" "a!1")
   (use "convergence_order" ("f2" "f!1"))
   (assert)
   (skosimp*)
   (expand "const_fun")
   (assert)
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "cv_const")
   (inst - "b!1" "a!1")
   (assert)
   (use "convergence_order" ("f1" "f!1"))
   (expand "const_fun")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (name-replace "ll" "lim(f!1, a!1)" :hide? nil)
   (rewrite "lim_fun_def")
   (use "convergence_upper_bound")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (name-replace "ll" "lim(f!1, a!1)" :hide? nil)
   (rewrite "lim_fun_def")
   (use "convergence_lower_bound" ("b" "b!1"))
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (name-replace "ll1" "lim(f1!1, a!1)" :hide? nil)
   (name-replace "ll2" "lim(f2!1, a!1)" :hide? nil)
   (rewrite "lim_fun_def")
   (rewrite "lim_fun_def")
   (use "convergence_order" ("l1" "ll1" "l2" "ll2"))
   (ground))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "continuity_def")
   (rewrite "continuity_def")
   (rewrite "continuity_def")
   (grind :exclude "convergence" :rewrites ("cv_div")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "continuity_def")
   (rewrite "continuity_def")
   (grind :exclude "convergence" :rewrites ("cv_inv")))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("f" "_" "x0"))
   (induct "n")
   (("1"
     (flatten)
     (lemma "const_continuous_vr" ("u" "1"))
     (inst - "x0")
     (expand "const_fun")
     (lemma "extensionality_postulate"
      ("f" "LAMBDA (x: Vect2): 1" "g" "f^0"))
     (flatten)
     (hide -2)
     (split -1)
     (("1" (assert))
      ("2"
       (hide-all-but 1)
       (skosimp)
       (expand "^")
       (expand "^")
       (expand "expt")
       (propax))))
    ("2"
     (skosimp)
     (assert)
     (lemma "prod_continuous_vr" ("x0" "x0" "f1" "f" "f2" "f^j!1"))
     (assert)
     (lemma "extensionality_postulate"
      ("f" "f * f ^ j!1" "g" "f^(1+j!1)"))
     (flatten)
     (hide -2)
     (split -1)
     (("1" (assert))
      ("2"
       (hide-all-but 1)
       (skosimp)
       (expand "*")
       (expand "^")
       (expand "^")
       (expand "expt" 1 2)
       (propax))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (lemma "sum_continuous_vr")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "diff_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "prod_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst -1 "x0!1")
   (rewrite "scal_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (rewrite "neg_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "div_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst -1 "x0!1")
   (rewrite "inv_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (rewrite "expt_continuous_vr")
   (hide 2)
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h3!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (rewrite "inv_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst - "x0!1")
   (lemma "expt_continuous_vr")
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "(LAMBDA (x: Vect2): 0)")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst + "1")
   (skosimp*)
   (assert))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "sum_continuous_vr"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "diff_continuous_vr"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h1!1")
   (typepred "h2!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "prod_continuous_vr"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (rewrite "scal_continuous_vr"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (rewrite "neg_continuous_vr"))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect2_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "h!1")
   (typepred "h3!1")
   (expand "continuous_vr?")
   (skosimp*)
   (inst?)
   (inst?)
   (rewrite "div_continuous_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_dot
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vv1")
   (typepred "vv2")
   (expand "continuous_vv")
   (expand "continuous_vr")
   (expand "continuous_vr?")
   (expand "continuous_vv?")
   (skeep)
   (expand "continuous_vr?")
   (expand "continuous_vv?")
   (skosimp*)
   (inst - "x0")
   (inst -2 "x0")
   (inst-cp -2 "1")
   (skosimp*)
   (case "FORALL (x: Vect2): norm(x - x0) < delta!1 IMPLIES norm(vv1(x)) < 1 + norm(vv1(x0))")
   (("1"
     (hide -4)
     (name "r" "1 + norm(vv1(x0))")
     (inst -3 "epsilon!1/(2*r)")
     (skosimp*)
     (case "norm(vv2(x0)) = 0")
     (("1"
       (lemma "norm_eq_0")
       (inst?)
       (assert)
       (replace -1 * lr)
       (hide -1)
       (assert)
       (hide -5)
       (inst + "min(delta!1,delta!2)")
       (skosimp*)
       (inst - "x!1")
       (inst - "x!1")
       (assert)
       (lemma "schwarz")
       (inst?)
       (replace -3)
       (mult-ineq -3 -4)
       (assert)
       (case-replace "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
       (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))
      ("2"
       (inst -4 "epsilon!1/(2*norm(vv2(x0)))")
       (("1"
         (skosimp*)
         (inst + "min(min(delta!1,delta!2),delta!3)")
         (skosimp*)
         (inst - "x!1")
         (inst - "x!1")
         (inst - "x!1")
         (case "abs(vv1(x!1) * vv2(x!1) - vv1(x0) * vv2(x0)) <= norm(vv2(x0)) * norm((vv1(x!1) - vv1(x0))) + norm(vv1(x!1)) * norm((vv2(x!1) - vv2(x0)))")
         (("1"
           (assert)
           (case "norm(vv1(x!1)) * norm((vv2(x!1) - vv2(x0))) <epsilon!1/2")
           (("1"
             (case "norm(vv2(x0)) * norm((vv1(x!1) - vv1(x0))) < epsilon!1/2")
             (("1" (assert))
              ("2"
               (hide 2)
               (hide -1 -2 -3 -5 2)
               (cross-mult -2)
               (assert))))
            ("2"
             (hide -1 3)
             (replace -1)
             (mult-ineq -2 -3)
             (assert)
             (case "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
             (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))))
          ("2"
           (hide 3)
           (lemma "triangle")
           (inst -1 "vv1(x!1) * (vv2(x!1) - vv2(x0))"
            "vv2(x0)*(vv1(x!1) - vv1(x0))")
           (assert)
           (lemma "schwarz")
           (inst-cp -1 "vv1(x!1)" "(vv2(x!1) - vv2(x0))")
           (inst - "vv2(x0)" "(vv1(x!1) - vv1(x0))")
           (assert)
           (hide -4 -5 -6 -7 -8)
           (grind :exclude ("norm" "abs")))))
        ("2"
         (hide -2 -3 3)
         (case "epsilon!1 / (2 * norm(vv2(x0))) > 0")
         (("1" (assert)) ("2" (hide 2) (cross-mult 1) (assert))
          ("3" (flatten) (assert))))
        ("3" (flatten) (assert))))))
    ("2"
     (hide 2)
     (hide -1 -2)
     (skosimp*)
     (inst?)
     (assert)
     (hide -1)
     (lemma "norm_sub_ge")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_dot
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "rv1")
   (typepred "rv2")
   (expand "continuous?")
   (skeep)
   (rewrite "continuous_functions[T].continuity_def")
   (expand "continuous_rv?")
   (expand "convergence")
   (expand "convergence")
   (split +)
   (("1"
     (hide -)
     (expand "fullset")
     (expand "adh")
     (skosimp*)
     (inst?)
     (assert))
    ("2"
     (skosimp*)
     (expand "fullset")
     (inst - "x0")
     (inst -2 "x0")
     (expand "continuous_rv?")
     (inst-cp -2 "1")
     (skosimp*)
     (case "FORALL x: abs(x - x0) < delta!1 IMPLIES norm(rv1(x)) < 1 + norm(rv1(x0))")
     (("1"
       (hide -4)
       (name "r" "1 + norm(rv1(x0))")
       (inst -3 "epsilon!1/(2*r)")
       (skosimp*)
       (case "norm(rv2(x0)) = 0")
       (("1"
         (lemma "norm_eq_0")
         (inst?)
         (assert)
         (replace -1 * lr)
         (hide -1)
         (assert)
         (hide -5)
         (inst + "min(delta!1,delta!2)")
         (skosimp*)
         (inst - "x!1")
         (inst - "x!1")
         (assert)
         (lemma "schwarz")
         (inst?)
         (replace -3)
         (mult-ineq -3 -5)
         (assert)
         (case-replace "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
         (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))
        ("2"
         (inst -4 "epsilon!1/(2*norm(rv2(x0)))")
         (("1"
           (skosimp*)
           (inst + "min(min(delta!1,delta!2),delta!3)")
           (skosimp*)
           (inst - "x!1")
           (inst - "x!1")
           (inst - "x!1")
           (case "abs(rv1(x!1) * rv2(x!1) - rv1(x0) * rv2(x0)) <= norm(rv2(x0)) * norm((rv1(x!1) - rv1(x0))) + norm(rv1(x!1)) * norm((rv2(x!1) - rv2(x0)))")
           (("1"
             (assert)
             (case "norm(rv1(x!1)) * norm((rv2(x!1) - rv2(x0))) <epsilon!1/2")
             (("1"
               (case "norm(rv2(x0)) * norm((rv1(x!1) - rv1(x0))) < epsilon!1/2")
               (("1" (assert))
                ("2" (hide -1 -2 -6 2) (cross-mult -4) (assert))))
              ("2"
               (hide -1 -6 3)
               (assert)
               (replace -1)
               (mult-ineq -2 -4)
               (assert)
               (case "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
               (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))))
            ("2"
             (hide 3)
             (lemma "triangle")
             (inst -1 "rv1(x!1) * (rv2(x!1) - rv2(x0))"
              "rv2(x0)*(rv1(x!1) - rv1(x0))")
             (assert)
             (lemma "schwarz")
             (inst-cp -1 "rv1(x!1)" "(rv2(x!1) - rv2(x0))")
             (inst - "rv2(x0)" "(rv1(x!1) - rv1(x0))")
             (assert)
             (hide -4 -5 -6 -7 -8)
             (grind :exclude ("norm" "abs")))))
          ("2"
           (hide -2 -3 3)
           (case "epsilon!1 / (2 * norm(rv2(x0))) > 0")
           (("1" (assert)) ("2" (hide 2) (cross-mult 1) (assert))
            ("3" (flatten) (assert))))
          ("3" (flatten) (assert))))))
      ("2"
       (hide 2)
       (hide -1 -2)
       (skosimp*)
       (inst?)
       (assert)
       (hide -1)
       (lemma "norm_sub_ge")
       (inst?)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_dot
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "rr")
   (typepred "rv")
   (expand "continuous?")
   (expand "continuous_rv?")
   (skeep)
   (inst - "x0")
   (inst -2 "x0")
   (expand "continuous?")
   (expand "continuous_rv?")
   (inst-cp -2 "1")
   (skosimp*)
   (case "FORALL x: abs(x - x0) < delta!1 IMPLIES abs(rr(x)) < 1 + abs(rr(x0))")
   (("1"
     (hide -4)
     (name "r" "1 + abs(rr(x0))")
     (inst -3 "epsilon!1/(2*r)")
     (skosimp*)
     (case "norm(rv(x0)) = 0")
     (("1"
       (lemma "norm_eq_0")
       (inst?)
       (assert)
       (replace -1 * lr)
       (hide -1)
       (assert)
       (hide -5)
       (inst + "min(delta!1,delta!2)")
       (skosimp*)
       (inst - "x!1")
       (inst - "x!1")
       (assert)
       (rewrite "norm_scal")
       (replace -1)
       (mult-ineq -2 -3)
       (("1"
         (case-replace "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
         (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))
        ("2" (rewrite "abs_abs") (hide -4 2 3) (expand "abs") (ground))))
      ("2"
       (inst -4 "epsilon!1/(2*norm(rv(x0)))")
       (("1"
         (skosimp*)
         (inst + "min(min(delta!1,delta!2),delta!3)")
         (skosimp*)
         (inst - "x!1")
         (inst - "x!1")
         (inst - "x!1")
         (case "norm(rr(x!1) * rv(x!1) - rr(x0) * rv(x0)) <= norm(rv(x0)) * abs((rr(x!1) - rr(x0))) + abs(rr(x!1)) * norm((rv(x!1) - rv(x0)))")
         (("1"
           (assert)
           (case "abs(rr(x!1)) * norm((rv(x!1) - rv(x0))) <epsilon!1/2")
           (("1"
             (case "norm(rv(x0)) * abs((rr(x!1) - rr(x0))) < epsilon!1/2")
             (("1" (assert))
              ("2" (hide -1 -2 -5 2) (cross-mult -3) (assert))))
            ("2"
             (hide -1 -5 -6 3)
             (replace -1)
             (mult-ineq -2 -3)
             (("1"
               (assert)
               (case "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
               (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))
              ("2"
               (hide 2 3 4)
               (rewrite "abs_abs")
               (expand "abs")
               (ground))))))
          ("2"
           (assert)
           (lemma "norm_triangle")
           (inst -1 "rr(x!1) * rv(x!1)" "rr(x!1)*rv(x0)"
            "rr(x0) * rv(x0)")
           (assert)
           (case-replace
            "rr(x!1) * rv(x!1) - rr(x!1) * rv(x0) =
                                                                         rr(x!1) * (rv(x!1) - rv(x0))")
           (("1"
             (hide -1)
             (case-replace
              "rr(x!1) * rv(x0) - rr(x0) * rv(x0) =
                                                                                   (rr(x!1) - rr(x0)) * rv(x0)")
             (("1"
               (hide -1)
               (rewrite "norm_scal")
               (assert)
               (rewrite "norm_scal")
               (assert))
              ("2" (hide-all-but 1) (assert) (grind))))
            ("2" (hide-all-but 1) (grind))))))
        ("2"
         (case "epsilon!1 / (2 * norm(rv(x0))) > 0")
         (("1" (assert)) ("2" (hide 2) (cross-mult 1))
          ("3" (flatten) (assert))))
        ("3" (flatten) (assert))))))
    ("2"
     (hide 2)
     (hide -1 -2)
     (skosimp*)
     (inst?)
     (assert)
     (hide -1)
     (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_dot
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vr")
   (typepred "vv")
   (expand "continuous_vv?")
   (skeep)
   (expand "continuous_vv?")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "continuous_vr?")
   (inst - "x0")
   (inst -2 "x0")
   (inst-cp -2 "1")
   (skosimp*)
   (case "FORALL (x: Vect2): norm(x - x0) < delta!1 IMPLIES abs(vr(x)) < 1 + abs(vr(x0))")
   (("1"
     (hide -4)
     (name "r" "1 + abs(vr(x0))")
     (inst -3 "epsilon!1/(2*r)")
     (skosimp*)
     (case "norm(vv(x0)) = 0")
     (("1"
       (lemma "norm_eq_0")
       (inst?)
       (assert)
       (replace -1 * lr)
       (hide -1)
       (assert)
       (hide -5)
       (inst + "min(delta!1,delta!2)")
       (skosimp*)
       (inst - "x!1")
       (inst - "x!1")
       (assert)
       (rewrite "norm_scal")
       (replace -1)
       (mult-ineq -2 -3)
       (("1"
         (case-replace "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
         (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))
        ("2"
         (rewrite "abs_abs")
         (hide-all-but 1)
         (expand "abs")
         (grind))))
      ("2"
       (inst -4 "epsilon!1/(2*norm(vv(x0)))")
       (("1"
         (skosimp*)
         (inst + "min(min(delta!1,delta!2),delta!3)")
         (skosimp*)
         (inst - "x!1")
         (inst - "x!1")
         (inst - "x!1")
         (assert)
         (case "norm(vr(x!1) * vv(x!1) - vr(x0) * vv(x0)) <= norm(vv(x0)) * abs((vr(x!1) - vr(x0))) + abs(vr(x!1)) * norm((vv(x!1) - vv(x0)))")
         (("1"
           (assert)
           (case "abs(vr(x!1)) * norm((vv(x!1) - vv(x0))) <epsilon!1/2")
           (("1"
             (case "norm(vv(x0)) * abs((vr(x!1) - vr(x0))) < epsilon!1/2")
             (("1" (assert))
              ("2"
               (hide 3)
               (hide -1 -2 -3 -5 2)
               (cross-mult -2)
               (assert))))
            ("2"
             (hide -1 3)
             (replace -1)
             (mult-ineq -2 -3)
             (("1"
               (assert)
               (case "r * (epsilon!1 / (2 * r)) = epsilon!1/2")
               (("1" (assert)) ("2" (hide-all-but 1) (cross-mult 1))))
              ("2"
               (rewrite "abs_abs")
               (hide-all-but 1)
               (expand "abs")
               (grind))))))
          ("2"
           (assert)
           (lemma "norm_triangle")
           (inst -1 "vr(x!1) * vv(x!1)" "vr(x!1)*vv(x0)"
            "vr(x0) * vv(x0)")
           (assert)
           (case-replace
            "vr(x!1) * vv(x!1) - vr(x!1) * vv(x0) =
                                                               vr(x!1) * (vv(x!1) - vv(x0))")
           (("1"
             (hide -1)
             (case-replace
              "vr(x!1) * vv(x0) - vr(x0) * vv(x0) =
                                                                       (vr(x!1) - vr(x0)) * vv(x0)")
             (("1"
               (hide -1)
               (rewrite "norm_scal")
               (assert)
               (rewrite "norm_scal")
               (assert))
              ("2" (hide-all-but 1) (assert) (grind))))
            ("2" (hide-all-but 1) (grind))))))
        ("2"
         (case "epsilon!1 / (2 * norm(vv(x0))) > 0")
         (("1" (assert)) ("2" (hide 2) (cross-mult 1))
          ("3" (flatten) (assert))))
        ("3" (flatten) (assert))))))
    ("2"
     (hide 2)
     (hide -1 -2)
     (skosimp*)
     (inst?)
     (assert)
     (hide -1)
     (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "vv1!1")
   (typepred "vv2!1")
   (expand "continuous_vv")
   (expand "o ")
   (expand "continuous_vv?")
   (skosimp*)
   (expand "continuous_vv?")
   (skosimp*)
   (inst -1 "x0!1")
   (inst -2 "vv2!1(x0!1)")
   (inst -2 "epsilon!1")
   (skosimp*)
   (inst -1 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "vv2!1(x!1)")
   (inst -1 "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "rv!1")
   (typepred "vT!1")
   (expand "continuous_vv?")
   (expand "continuous_rv?")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "o ")
   (expand "continuous_vv?")
   (expand "continuous_rv?")
   (expand "continuous_vr?")
   (skosimp*)
   (inst -1 "x0!1")
   (inst -2 "vT!1(x0!1)")
   (inst -2 "epsilon!1")
   (skosimp*)
   (inst -1 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "vT!1(x!1)")
   (assert)
   (inst -1 "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "vr!1")
   (typepred "vv!1")
   (expand "continuous_vv")
   (expand "continuous_vr")
   (expand "o ")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "continuous_vv?")
   (expand "continuous_vv?")
   (expand "continuous_vr?")
   (skosimp*)
   (inst -1 "x0!1")
   (inst -2 "vv!1(x0!1)")
   (inst -2 "epsilon!1")
   (skosimp*)
   (inst -1 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "vv!1(x!1)")
   (inst -1 "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "rr!1")
   (typepred "vT!1")
   (expand "continuous?")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "o ")
   (inst -1 "x0!1")
   (inst -2 "vT!1(x0!1)")
   (expand "continuous_vr?")
   (expand "continuous?")
   (skosimp*)
   (inst -2 "epsilon!1")
   (skosimp*)
   (inst -1 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "vT!1(x!1)")
   (assert)
   (inst -1 "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "vv!1")
   (typepred "rv!1")
   (expand "continuous_rv")
   (expand "continuous_vv")
   (expand "o ")
   (expand "continuous_rv?")
   (expand "continuous_vv?")
   (skosimp*)
   (inst -1 "x0!1")
   (inst -2 "rv!1(x0!1)")
   (expand "continuous_rv?")
   (expand "continuous_vv?")
   (skosimp*)
   (inst -2 "epsilon!1")
   (skosimp*)
   (inst -1 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "rv!1(x!1)")
   (inst -1 "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "rT")
   (typepred "rv")
   (expand "continuous?")
   (expand "continuous_rv?")
   (skosimp*)
   (expand "continuous_rv?")
   (expand "continuous?")
   (inst -2 "x0!1")
   (inst -1 "rT(x0!1)")
   (skosimp*)
   (expand "o ")
   (inst -1 "epsilon!1")
   (skosimp*)
   (inst -2 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "x!1")
   (assert)
   (inst -1 "rT(x!1)")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "rv!1")
   (typepred "vr!1")
   (expand "continuous_vr")
   (expand "continuous_rv")
   (expand "continuous?")
   (expand "continuous_vr?")
   (expand "continuous_rv?")
   (skosimp*)
   (expand "o ")
   (expand "continuous?")
   (expand "continuous_vr?")
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (inst -1 "epsilon!1")
   (skosimp*)
   (inst -2 "x0!1")
   (inst -2 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst?)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vv")
   (lemma "cont_vect2_vect2.const_cont_vv_fun")
   (expand "const_fun")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_rv")
   (lemma "cont_real_vect2[real].const_cont_rv_fun")
   (inst?)
   (expand "const_vfun")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "cont_vect2_real.const_cont_vr_fun")
   (expand "continuous_vr")
   (inst?)
   (expand "const_fun")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "rr1")
   (typepred "rr2")
   (expand "continuous_rv")
   (expand "continuous?")
   (expand "continuous_rv?")
   (skeep)
   (expand "continuous_rv?")
   (skosimp*)
   (inst?)
   (inst?)
   (expand "continuous?")
   (inst - "epsilon!1/sqrt(2)")
   (inst - "epsilon!1/sqrt(2)")
   (skosimp*)
   (inst + "min(delta!1,delta!2)")
   (skosimp*)
   (inst -1 "x!1")
   (inst -2 "x!1")
   (assert)
   (use-with "sq_lt" 1)
   (assert)
   (hide 2)
   (rewrite "sq_norm")
   (use-with "sq_lt" -1)
   (assert)
   (use-with "sq_lt" -3)
   (assert)
   (hide -3 -4)
   (hide -3)
   (rewrite "sq_div")
   (assert)
   (case "sqv((# x := rr1(x!1), y := rr2(x!1) #) -
                                         (# x := rr1(x0), y := rr2(x0) #)) = sq(rr1(x!1) - rr1(x0)) + sq(rr2(x!1) - rr2(x0))")
   (("1" (assert)) ("2" (hide - 2) (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vr1")
   (typepred "vr2")
   (expand "continuous_vr")
   (expand "continuous_vv")
   (expand "continuous_vv?")
   (expand "continuous_vr?")
   (skeep)
   (expand "continuous_vv?")
   (expand "continuous_vr?")
   (inst - "x0")
   (inst -2 "x0")
   (skosimp*)
   (inst - "epsilon!1/sqrt(2)")
   (inst - "epsilon!1/sqrt(2)")
   (skosimp*)
   (inst + "min(delta!1,delta!2)")
   (skosimp*)
   (inst -1 "x!1")
   (inst -2 "x!1")
   (assert)
   (use-with "sq_lt" 1)
   (assert)
   (hide 2)
   (rewrite "sq_norm")
   (use-with "sq_lt" -1)
   (assert)
   (use-with "sq_lt" -3)
   (assert)
   (hide -3 -4)
   (hide -3)
   (rewrite "sq_div")
   (case "sqv((# x := vr1(x!1), y := vr2(x!1) #) -
                                                (# x := vr1(x0), y := vr2(x0) #)) = sq(vr1(x!1) - vr1(x0)) + sq(vr2(x!1) - vr2(x0))")
   (("1" (assert)) ("2" (hide - 2) (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_vr?")
   (skeep)
   (expand "continuous_vr?")
   (skosimp)
   (inst 1 "epsilon!1")
   (skosimp)
   (expand "norm")
   (case " abs(x(x!1) - x(x0)) <= sqrt(sqv(x!1 - x0))")
   (("1" (assert))
    ("2"
     (hide-all-but 1)
     (lemma "sq_le")
     (inst -1 "abs(x(x!1)-x(x0))" "sqrt(sqv(x!1-x0))")
     (assert)
     (hide 2)
     (rewrite "sqv_sos")
     (expand "sos")
     (assert)
     (expand "-")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous_vr?")
   (skeep)
   (expand "continuous_vr?")
   (skosimp)
   (inst 1 "epsilon!1")
   (skosimp)
   (expand "norm")
   (case " abs(y(x!1) - y(x0)) <= sqrt(sqv(x!1 -x0))")
   (("1" (assert))
    ("2"
     (hide-all-but 1)
     (lemma "sq_le")
     (inst -1 "abs(y(x!1)-y(x0))" "sqrt(sqv(x!1-x0))")
     (assert)
     (hide 2)
     (rewrite "sqv_sos")
     (expand "sos")
     (assert)
     (expand "-")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vr1")
   (typepred "vr2")
   (lemma "cont_vect2_real.prod_cont_vr_fun")
   (inst - "vr1" "vr2")
   (expand "*")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vr")
   (expand "continuous_vr")
   (lemma "cont_vect2_real.div_cont_vr_fun")
   (inst - "vr" "vnz")
   (assert)
   (expand "/")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "div_cont_vr")
   (inst -1 "vr" "LAMBDA(v):nzx")
   (assert)
   (rewrite "const_cont_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "div_cont_vr")
   (inst -1 "LAMBDA(v):x" "vnz")
   (("1" (assert)) ("2" (rewrite "const_cont_vr"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vv1")
   (typepred "vv2")
   (lemma "sum_cont_vv_fun")
   (inst - "vv1" "vv2")
   (expand "+ " -)
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vr1")
   (typepred "vr2")
   (lemma "sum_cont_vr_fun")
   (inst - "vr1" "vr2")
   (expand "+ " -1)
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "rv1")
   (typepred "rv2")
   (expand "continuous_rv")
   (lemma "sum_cont_rv_fun")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vv1")
   (typepred "vv2")
   (expand "continuous_vv")
   (lemma "diff_cont_vv_fun")
   (assert)
   (expand "-")
   (inst - "vv1" "vv2")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "vr1")
   (typepred "vr2")
   (lemma "diff_cont_vr_fun")
   (inst - "vr1" "vr2")
   (expand "-")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "rv1")
   (typepred "rv2")
   (expand "continuous_rv")
   (lemma "cont_real_vect2.diff_cont_rv_fun")
   (inst - "rv1" "rv2")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sub_cont_vr")
   (inst -1 "LAMBDA(v):0" "vr")
   (("1" (assert)) ("2" (rewrite "const_cont_vr"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sub_cont_vv")
   (inst -1 "LAMBDA(v):zero" "vv")
   (("1" (assert)) ("2" (rewrite "const_cont_vv"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sub_cont_rv")
   (inst -1 "LAMBDA(x):zero" "rv")
   (("1" (assert)) ("2" (rewrite "const_cont_rv"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "scal_cont_vv[real]")
   (inst -1 "LAMBDA(v):y" "vv")
   (rewrite "const_cont_vr"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "comp_rr_vr_cont[real]")
   (inst -1 "abs" "vr")
   (("1" (expand "o") (expand "continuous_vr") (propax))
    ("2"
     (hide 2)
     (lemma "abs_cont")
     (inst -1 "id")
     (("1" (expand "id") (expand "abs") (propax))
      ("2" (hide 2) (expand "id") (rewrite "id_cont"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace
    "(LAMBDA (v): max(vr1(v), vr2(v))) = (LAMBDA (v): (vr1(v)+vr2(v)+abs(vr1(v)-vr2(v)))/2)")
   (("1"
     (hide -1)
     (rewrite "scal_div1_cont_vr")
     (hide 2)
     (rewrite "add_cont_vr")
     (hide 2)
     (rewrite "add_cont_vr")
     (hide 2)
     (rewrite "abs_cont_vr")
     (hide 2)
     (rewrite "sub_cont_vr"))
    ("2"
     (hide 2)
     (decompose-equality 1)
     (("1" (rewrite "max_abs"))
      ("2"
       (hide 2)
       (skeep 1)
       (lemma "max_abs")
       (inst -1 "vr1(v)" "vr2(v)")
       (replaces -1 :dir rl)
       (typepred "max(vr1(v), vr2(v))")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace
    "(LAMBDA(v):min(vr1(v),vr2(v)))= (LAMBDA(v):-max(-vr1(v),-vr2(v)))")
   (("1"
     (hide -1)
     (rewrite "neg_cont_vr")
     (hide 2)
     (rewrite "max_cont_vr")
     (("1" (hide 2) (rewrite "neg_cont_vr"))
      ("2" (rewrite "neg_cont_vr"))))
    ("2"
     (hide 2)
     (decompose-equality 1)
     (("1" (rewrite "min_max"))
      ("2"
       (skeep)
       (rewrite "min_max" :dir rl)
       (typepred "min(vr1(v),vr2(v))")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "comp_rr_vr_cont[real]")
   (inst -1 "sq" "vr")
   (("1" (expand "continuous_vr") (expand "o") (propax))
    ("2"
     (hide 2)
     (lemma "sq_cont")
     (inst -1 "id")
     (("1" (expand "id") (expand "sq") (propax))
      ("2" (hide 2 3) (expand "id") (rewrite "id_cont"))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "comp_vr_vv_cont[real]")
   (inst -1 "sqv" "vv")
   (expand "continuous_vr")
   (expand "o")
   (propax))


proof_type: j_proof
decl_type: tcc
library: vect_analysis
theory: vect_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "neg_cont_vv")
   (inst -1 "id")
   (("1"
     (expand "id")
     (case-replace "(LAMBDA(v):-v) = vectors_2D.-")
     (hide-all-but 1)
     (decompose-equality 1))
    ("2" (expand "id") (rewrite "id_cont_vv"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "tt!1")
   (typepred "vT!1")
   (expand "continuous?")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "o ")
   (inst -1 "x0!1")
   (inst -2 "vT!1(x0!1)")
   (expand "continuous_vr?")
   (expand "continuous?")
   (skosimp*)
   (inst -2 "epsilon!1")
   (skosimp*)
   (inst -1 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "vT!1(x!1)")
   (assert)
   (inst -1 "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect2_cont_comp2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "tt")
   (typepred "rv")
   (expand "continuous?")
   (expand "continuous_rv?")
   (skosimp*)
   (expand "continuous_rv?")
   (expand "continuous?")
   (inst -2 "x0!1")
   (inst -1 "tt(x0!1)")
   (skosimp*)
   (expand "o ")
   (inst -1 "epsilon!1")
   (skosimp*)
   (inst -2 "delta!1")
   (skosimp*)
   (inst + "delta!2")
   (skosimp*)
   (inst -2 "x!1")
   (assert)
   (inst -1 "tt(x!1)")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect3_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-") :if-match nil)
   (rewrite "abs_diff_0")
   (name "eps" "abs(l1!1 - l2!1)")
   (replace -1)
   (inst -4 "eps/2")
   (("1"
     (inst -5 "eps/2")
     (("1"
       (assert)
       (skosimp*)
       (case " EXISTS (x: Vect3): a!1 /= x AND norm(x - a!1) < delta!1 AND norm(x - a!1) < delta!2")
       (("1"
         (skosimp*)
         (inst?)
         (inst?)
         (assert)
         (case "0 < norm(x!1 - a!1)")
         (("1"
           (assert)
           (lemma "triangle2")
           (inst - "eps/2" "eps/2" "l1!1" "f!1(x!1)" "l2!1")
           (assert))
          ("2"
           (assert)
           (lemma "vectors_3D.norm_eq_0")
           (inst?)
           (assert)
           (replace -1 * lr)
           (assert)
           (rewrite "sub_eq_zero"))))
        ("2"
         (hide -4 -5)
         (name "DEL" "min(delta!1,delta!2)")
         (inst + "(a!1`x + DEL/2, a!1`y, a!1`z)")
         (grind))))
      ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect3_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("f" "_" "x0"))
   (induct "n")
   (("1"
     (flatten)
     (lemma "const_continuous_vr" ("u" "1"))
     (inst - "x0")
     (expand "const_fun")
     (lemma "extensionality_postulate"
      ("f" "LAMBDA (x: Vect3): 1" "g" "f^0"))
     (flatten)
     (hide -2)
     (split -1)
     (("1" (assert))
      ("2"
       (hide-all-but 1)
       (skosimp)
       (expand "^")
       (expand "^")
       (expand "expt")
       (propax))))
    ("2"
     (skosimp)
     (assert)
     (lemma "prod_continuous_vr" ("x0" "x0" "f1" "f" "f2" "f^j!1"))
     (assert)
     (lemma "extensionality_postulate"
      ("f" "f * f ^ j!1" "g" "f^(1+j!1)"))
     (flatten)
     (hide -2)
     (split -1)
     (("1" (assert))
      ("2"
       (hide-all-but 1)
       (skosimp)
       (expand "*")
       (expand "^")
       (expand "^")
       (expand "expt" 1 2)
       (propax))))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect3_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "(LAMBDA (x: Vect3): 0)")
   (expand "continuous_vr?")
   (skosimp*)
   (expand "continuous_vr?")
   (skosimp*)
   (inst + "1")
   (skosimp*)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "curried_min_exists")
   (skosimp*)
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
   (prop)
   (("1"
     (inst - "y!1")
     (expand "fullset")
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (prop))
    ("2" (inst - "y!1") (expand "fullset") (assert))
    ("3" (inst - "y!1") (expand "fullset") (prop))
    ("4" (inst - "y!1") (expand "fullset") (prop))
    ("5"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("6"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("7"
     (expand "nonempty?")
     (expand "empty?")
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("8"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "(A!1 + B!1)/2")
     (assert))
    ("9"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("10"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (prop))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("11"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (assert))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("12"
     (hide 1)
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (prop))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("13"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("14"
     (lemma "curried_min_exists")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (assert)
     (prop)
     (("1" (inst - "y!1") (expand "fullset") (propax))
      ("2" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))
    ("15" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))
    ("16" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "curried_min_is_cont")
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
   (prop)
   (("1" (expand "continuous?" +) (expand "fullset") (propax))
    ("2" (lemma "closed_intervals_compact") (inst?))
    ("3"
     (hide 2)
     (expand "continuous?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (expand "continuous_at?")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta !1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (typepred "y!1")
       (inst - "y!1")
       (("1" (assert)) ("2" (hide -2 2) (grind))))
      ("2" (hide 2) (typepred "x!1") (grind))))
    ("4"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "(A!1 + B!1)/2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (skoletin 1)
   (("1"
     (skosimp*)
     (lemma "curried_min_is_cont_3D")
     (inst - "f!1" "A!1" "B!1")
     (prop)
     (("1"
       (assert)
       (replace -2 - rl)
       (expand "continuous?")
       (expand "continuous?")
       (inst - "y!1")
       (("1"
         (expand "continuous_at?")
         (inst - "epsilon!1")
         (expand "member")
         (expand "ball")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "q!1")
         (("1" (assert)) ("2" (expand "fullset") (propax))))
        ("2" (expand "fullset") (propax))))
      ("2"
       (hide 2)
       (lemma "product_cont_product_subset")
       (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
       (prop)
       (("1"
         (hide-all-but (-1 1))
         (expand "continuous?")
         (expand "continuous_at?")
         (expand "member")
         (expand "ball")
         (skosimp*)
         (inst - "x!1")
         (("1"
           (inst - "epsilon!2")
           (skosimp*)
           (inst + "delta!1")
           (skosimp*)
           (inst - "y!2")
           (("1" (assert))
            ("2"
             (expand "extend")
             (prop)
             (("1" (expand "fullset") (propax))
              ("2" (typepred "y!2") (expand "extend") (assert))
              ("3" (typepred "y!2") (expand "extend") (assert))
              ("4" (expand "fullset") (propax))))))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "x!1") (expand "extend") (assert))
            ("3" (typepred "x!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (skosimp*)
         (inst - "x!1" "y!2" "epsilon!2")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "z!1" "w!1")
         (assert))))))
    ("2"
     (hide 2)
     (hide -)
     (lemma "curried_min_is_cont_TCC1")
     (skosimp*)
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (case "nonempty?(LAMBDA (x: real): A!1 <= x AND x <= B!1)")
     (("1"
       (assert)
       (reveal -2)
       (label "cont_ed" -1)
       (label "nonempty" -2)
       (label "bigpred" -3)
       (prop)
       (("1" (inst - "y!1") (expand "fullset") (assert))
        ("2" (inst - "y!1") (expand "fullset") (assert))
        ("3" (inst - "y!1") (expand "fullset") (assert))
        ("4"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst - "f!1(A!1,y!1)")
         (inst + "A!1"))
        ("5"
         (lemma "product_cont_product_subset")
         (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
         (assert)
         (hide-all-but ("cont_ed" 1))
         (skosimp*)
         (inst - "x!1" "y!2" "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "z!1" "w!1")
         (assert))
        ("6"
         (lemma "product_cont_product_subset")
         (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
         (assert)
         (hide-all-but ("cont_ed" 1))
         (skosimp*)
         (inst - "x!1" "y!2" "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "z!1" "w!1")
         (assert))
        ("7"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst - "f!1(A!1,y!1)")
         (inst + "A!1"))
        ("8" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))
        ("9" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))
      ("2"
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (inst - "A!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "multiary_Heine")
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
   (assert)
   (prop)
   (("1" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))
    ("2"
     (expand "continuous?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "y!1")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!1") (expand "extend") (assert))
          ("3" (typepred "y!1") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "multiary_Heine_3D")
   (inst - "f!1" "A!1" "B!1")
   (expand "uniformly_continuous_in_first?")
   (prop)
   (("1"
     (inst - "y1!1" "epsilon!1")
     (("1"
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "x1!1" "x2!1" "y2!1")
       (("1" (assert)) ("2" (expand "fullset") (propax))))
      ("2" (expand "fullset") (propax))))
    ("2"
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 1))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!2")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!2")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "curried_min_exists")
   (skosimp*)
   (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
   (prop)
   (("1"
     (inst - "y!1")
     (expand "fullset")
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (prop))
    ("2" (inst - "y!1") (expand "fullset") (assert))
    ("3" (inst - "y!1") (expand "fullset") (prop))
    ("4"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("5"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("6"
     (expand "nonempty?")
     (expand "empty?")
     (copy -2)
     (inst - "(A!1 + B!1)/2")
     (expand "member")
     (propax))
    ("7"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("8"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (prop))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("9"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (expand "member")
       (expand "ball")
       (inst - "y!2")
       (("1" (assert))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "y!2") (expand "extend") (assert))
          ("3" (typepred "y!2") (expand "extend") (assert))))))
      ("2"
       (expand "extend")
       (prop)
       (("1" (expand "fullset") (propax))
        ("2" (typepred "x!1") (expand "extend") (assert))
        ("3" (typepred "x!1") (expand "extend") (assert))))))
    ("10"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "f!1(A!1,y!1)")
     (inst + "A!1"))
    ("11"
     (lemma "curried_min_exists")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (assert)
     (prop)
     (("1" (inst - "y!1") (expand "fullset") (propax))
      ("2" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))
    ("12" (lemma "closed_intervals_compact") (inst - "A!1" "B!1"))))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: vect3_Heine
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (lemma "curried_min_is_cont_3D_TCC1")
   (skosimp*)
   (inst - "f!1" "A!1" "B!1")
   (prop)
   (("1" (inst - "y1!1") (prop)) ("2" (inst - "y1!1") (prop))
    ("3" (inst - "y1!1") (prop))
    ("4"
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 2))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (hide-all-but (-1 1))
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))
    ("5"
     (hide 1)
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 1))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (hide-all-but (-1 1))
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))
    ("6"
     (hide 1)
     (lemma "product_cont_product_subset")
     (inst - "closed_intv(A!1,B!1)" "fullset[Vect3]" "f!1")
     (prop)
     (("1"
       (hide-all-but (-1 1))
       (expand "continuous?")
       (expand "continuous_at?")
       (expand "member")
       (expand "ball")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2"
           (expand "extend")
           (prop)
           (("1" (expand "fullset") (propax))
            ("2" (typepred "y!1") (expand "extend") (assert))
            ("3" (typepred "y!1") (expand "extend") (assert))
            ("4" (expand "fullset") (propax))))))
        ("2"
         (expand "extend")
         (prop)
         (("1" (expand "fullset") (propax))
          ("2" (typepred "x!1") (expand "extend") (assert))
          ("3" (typepred "x!1") (expand "extend") (assert))
          ("4" (expand "fullset") (propax))))))
      ("2"
       (hide-all-but (-1 1))
       (skosimp*)
       (inst - "x!1" "y!1" "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "z!1" "w!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: vect_metric_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "subset_is_metric_space")
   (skosimp*)
   (inst?)
   (inst - "fullset[Vector[n]]")
   (assert)
   (expand "fullset")
   (expand "subset?")
   (expand "member")
   (propax))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: vect_metric_space
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (assuming-tcc)
   (expand "metric_space?")
   (prop)
   (("1" (expand "space_zero?") (skosimp*) (lemma "dist_eq_0") (inst?))
    ("2"
     (expand "space_symmetric?")
     (skosimp*)
     (lemma "dist_sym")
     (inst?))
    ("3"
     (expand "space_triangle?")
     (skosimp*)
     (lemma "dist_norm")
     (copy -1)
     (copy -1)
     (inst - "x!1" "z!1")
     (inst - "x!1" "y!1")
     (inst - "y!1" "z!1")
     (replace -1)
     (replace -2)
     (replace -3)
     (lemma "norm_triangle[n]")
     (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_cont_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma cont_rv_iff_comps[T])
   (inst?)
   (assert)
   (hide 2)
   (expand "derivable_rv?")
   (flatten)
   (lemma derivable_cont_fun[T])
   (("1"
     (inst?)
     (assert)
     (hide -1 -2)
     (lemma derivable_cont_fun[T])
     (inst?)
     (assert))
    ("2" (hide - 2) (lemma "not_one_element") (propax))
    ("3"
     (hide 2)
     (lemma "deriv_domain")
     (expand "deriv_domain?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (expand "+ ")
   (inst - "i!1")
   (inst - "i!1")
   (lemma "sum_derivable")
   (expand "+ ")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (inst - "i!1")
   (inst - "i!1")
   (lemma "diff_derivable")
   (inst?)
   (assert)
   (expand "-")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (inst - "i!1")
   (expand "-")
   (expand "-")
   (lemma "neg_derivable")
   (inst?)
   (assert)
   (expand "-")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (inst - "i!1")
   (expand "*")
   (expand "*")
   (lemma "scal_derivable")
   (expand "*")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (lemma "const_derivable")
   (inst?)
   (expand "const_fun")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "deriv")
   (lemma "sum_derivable")
   (inst - "f1!1" "f2!1" "x1!1")
   (assert)
   (expand "derivable?" -2)
   (expand "derivable?" -3)
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_sum")
     (expand "+ ")
     (inst?)
     (assert)
     (hide -1 2)
     (inst?)
     (inst?)
     (assert))
    ("2"
     (skosimp*)
     (expand "+")
     (assert)
     (expand "derivable?" -1)
     (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "deriv")
   (lemma "neg_derivable")
   (assert)
   (expand "derivable?" -2)
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_neg")
     (expand "-")
     (inst?)
     (assert)
     (hide -1 2)
     (inst?))
    ("2"
     (skosimp*)
     (expand "-")
     (expand "derivable?" -1)
     (inst?)
     (assert)
     (replace -2)
     (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "deriv")
   (lemma "diff_derivable")
   (inst - "f1!1" "f2!1" "x1!1")
   (assert)
   (expand "derivable?" -2)
   (expand "derivable?" -3)
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_diff")
     (expand "-")
     (inst?)
     (assert)
     (hide -1 2)
     (inst?)
     (inst?)
     (assert))
    ("2"
     (skosimp*)
     (expand "-")
     (assert)
     (expand "derivable?" -1)
     (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deriv")
   (lemma "const_derivable")
   (assert)
   (expand "derivable?" -1)
   (inst?)
   (inst - "x!1")
   (apply-extensionality 1 :hide? t)
   (lemma "deriv_const")
   (inst?)
   (expand "const_fun")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect_def
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (expand "deriv")
   (lemma "scal_derivable")
   (assert)
   (expand "derivable?" -2)
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_scal")
     (expand "*")
     (inst?)
     (assert)
     (hide -1 2)
     (inst?))
    ("2"
     (skosimp*)
     (expand "*")
     (expand "derivable?" -1)
     (inst?)
     (assert)
     (replace -2)
     (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_sigma
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "m")
   (("1" (assert)) ("2" (assert))
    ("3"
     (skosimp*)
     (case "j!1 > 0")
     (("1"
       (assert)
       (case-replace
        "(LAMBDA (x: T):
                           sigma(0, j!1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i))) =
                      (LAMBDA (x: T):
                           sigma(0, j!1-1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i)) + h!1(x)(j!1))")
       (("1"
         (hide -1)
         (inst - "y!1" "LAMBDA (x:T): LAMBDA (i: Index[j!1]): h!1(x)(i)")
         (assert)
         (split -2)
         (("1"
           (lemma "sum_derivable[T]")
           (inst - "(LAMBDA (x: T): h!1(x)(j!1))"
            "(LAMBDA (x: T):
                                 sigma(0, j!1 - 1,
                                       LAMBDA (i: Index[1 + j!1]): h!1(x)(i)))"
            "y!1")
           (("1"
             (assert)
             (split -1)
             (("1" (expand "+") (propax)) ("2" (hide 2) (inst?))
              ("3"
               (hide 2)
               (case-replace
                "(LAMBDA (x_1: T):
                                    sigma(0, j!1 - 1,
                                          LAMBDA (i_1: Index[j!1]): h!1(x_1)(i_1))) =
                 (LAMBDA (x: T):
                                     sigma(0, j!1 - 1,
                                           LAMBDA (i: Index[1 + j!1]): h!1(x)(i)))")
               (("1"
                 (hide 2)
                 (apply-extensionality 1 :hide? t)
                 (("1"
                   (hide -1)
                   (lemma "sigma_diff_eq[j!1,j!1+1]")
                   (inst?)
                   (assert))
                  ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))
                ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))))
            ("2" (skosimp*) (assert))))
          ("2" (skosimp*) (inst?))))
        ("2"
         (hide -2 2)
         (apply-extensionality 1 :hide? t)
         (("1"
           (lemma "sigma_last[Index[j!1+1]]")
           (("1" (inst?) (assert)) ("2" (skosimp*) (assert))))
          ("2" (skosimp*) (assert))))
        ("3" (skosimp*) (assert))))
      ("2"
       (hide -1)
       (assert)
       (expand "sigma")
       (expand "sigma")
       (inst?))))
    ("4" (hide 2) (skosimp*) (assert)) ("5" (hide 2) (skosimp*) (assert))
    ("6" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_sigma
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skosimp*)
     (expand "sigma")
     (lemma "deriv_const[T]")
     (inst?)
     (expand "const_fun")
     (inst?))
    ("2"
     (skosimp*)
     (case "j!1 = 0")
     (("1"
       (replace -1)
       (hide -2)
       (expand "sigma")
       (expand "sigma")
       (expand "deriv" 1 2)
       (propax))
      ("2"
       (inst - "y!1")
       (assert)
       (("1"
         (inst - "LAMBDA (x: T): LAMBDA (i: Index[j!1]): h!1(x)(i)")
         (split -1)
         (("1"
           (lemma "sigma_last[below(j!1+1)]")
           (("1"
             (inst?)
             (("1"
               (assert)
               (replace -1)
               (hide -1)
               (case-replace
                "(LAMBDA (x: T): sigma(0, j!1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i))) =
                 (LAMBDA (x: T): sigma(0, j!1-1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i)) + h!1(x)(j!1))")
               (("1"
                 (hide -1)
                 (lemma "deriv_sum[T]")
                 (inst -
                  "(LAMBDA (x: T): sigma(0, j!1 - 1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i)))"
                  "(LAMBDA (x: T):  h!1(x)(j!1))" "y!1")
                 (("1"
                   (assert)
                   (split -1)
                   (("1"
                     (expand "+ " -1)
                     (replace -1)
                     (hide -1)
                     (case-replace
                      "(LAMBDA (x: T): sigma(0, j!1 - 1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i))) =
                                   (LAMBDA (x: T): sigma(0, j!1 - 1, LAMBDA (i: Index[j!1]): h!1(x)(i)))")
                     (("1"
                       (hide -1)
                       (replace -1)
                       (hide -1)
                       (case "sigma(0, j!1 - 1, LAMBDA (i: Index[1 + j!1]): deriv(h!1, y!1)(i)) =
                                                         sigma(0, j!1 - 1, LAMBDA (i: Index[j!1]): deriv(h!1, y!1)(i))")
                       (("1"
                         (case-replace
                          "sigma(0, j!1 - 1, LAMBDA (i: Index[1 + j!1]): deriv(h!1, y!1)(i)) =
                                                   sigma(0, j!1 - 1, LAMBDA (i: Index[j!1]): deriv(h!1, y!1)(i))")
                         (hide -1)
                         (expand "deriv" 2 3)
                         (expand "deriv" 2 2)
                         (assert)
                         (expand "deriv" 2 1)
                         (propax))
                        ("2"
                         (hide 3)
                         (lemma "sigma_diff_eq[1+j!1,j!1]")
                         (inst?)
                         (("1" (assert))
                          ("2"
                           (skosimp*)
                           (lemma "not_one_element")
                           (propax))
                          ("3"
                           (skosimp*)
                           (lemma "deriv_domain")
                           (propax))
                          ("4"
                           (skosimp*)
                           (expand "derivable?" 1)
                           (propax))
                          ("5"
                           (skosimp*)
                           (lemma "not_one_element")
                           (propax))
                          ("6"
                           (skosimp*)
                           (lemma "deriv_domain")
                           (propax))
                          ("7"
                           (skosimp*)
                           (expand "derivable?" 1)
                           (propax))))
                        ("3" (skosimp*) (assert))
                        ("4"
                         (skosimp*)
                         (lemma "not_one_element")
                         (propax))
                        ("5"
                         (skosimp*)
                         (assert)
                         (lemma "deriv_domain")
                         (propax))
                        ("6"
                         (skosimp*)
                         (lemma "not_one_element")
                         (propax))
                        ("7"
                         (skosimp*)
                         (lemma "deriv_domain")
                         (propax))))
                      ("2"
                       (hide 3)
                       (apply-extensionality 1 :hide? t)
                       (("1"
                         (lemma "sigma_diff_eq[1+j!1,j!1]")
                         (inst?)
                         (assert))
                        ("2" (skosimp*) (assert))
                        ("3" (skosimp*) (assert))))
                      ("3" (skosimp*) (assert))
                      ("4" (skosimp*) (assert))))
                    ("2"
                     (hide 3)
                     (hide -1)
                     (case-replace
                      "(LAMBDA (x: T): sigma(0, j!1 - 1, LAMBDA (i: Index[1 + j!1]): h!1(x)(i))) =
                       (LAMBDA (x: T): sigma(0, j!1 - 1, LAMBDA (i: Index[ j!1]): h!1(x)(i)))")
                     (("1"
                       (hide -1)
                       (lemma "sigma_derivable")
                       (hide -1)
                       (lemma "sigma_derivable")
                       (inst - "j!1" "y!1"
                        "(LAMBDA (x: T):  LAMBDA (i: Index[j!1]): h!1(x)(i))")
                       (assert)
                       (skosimp*)
                       (inst?))
                      ("2"
                       (hide 2)
                       (apply-extensionality 1 :hide? t)
                       (("1"
                         (lemma "sigma_diff_eq[1+j!1,j!1]")
                         (inst?)
                         (assert))
                        ("2" (skosimp*) (assert))
                        ("3" (skosimp*) (assert))))
                      ("3" (skosimp*) (assert))
                      ("4" (skosimp*) (assert))))
                    ("3" (hide 3) (hide -1) (inst?))))
                  ("2" (skosimp*) (assert))))
                ("2"
                 (hide 3)
                 (apply-extensionality 1 :hide? t)
                 (("1"
                   (hide -1)
                   (lemma "sigma_last[below(j!1+1)]")
                   (inst?)
                   (assert))
                  ("2" (skosimp*) (assert))))
                ("3" (skosimp*) (assert))))
              ("2"
               (skosimp*)
               (hide 3)
               (hide -1)
               (lemma "not_one_element")
               (propax))
              ("3" (skosimp*) (lemma "deriv_domain") (propax))
              ("4" (skosimp*) (expand "derivable?" 1) (propax))))
            ("2" (skosimp*) (assert))))
          ("2" (hide 3) (expand "derivable?") (skosimp*) (inst?))))
        ("2" (assert))))))
    ("3" (skosimp*) (assert))
    ("4" (skosimp*) (lemma "not_one_element") (propax))
    ("5" (skosimp*) (assert) (lemma "deriv_domain") (propax))
    ("6" (skosimp*) (assert) (hide 2) (expand "derivable?" 1) (propax))
    ("7" (skosimp*) (assert)) ("8" (skosimp*) (assert))
    ("9"
     (skosimp*)
     (assert)
     (hide 2)
     (lemma "sigma_derivable")
     (inst - "n!2" "y!1" "h!1")
     (assert))
    ("10" (hide 2) (skosimp*) (assert)) ("11" (skosimp*) (assert))
    ("12" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_dot_prod
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?" -)
   (expand "*")
   (lemma "sigma_derivable")
   (inst - "n" "x1!1"
    "(LAMBDA (x: T): LAMBDA (i: Index[n]): f1!1(x)(i) * f2!1(x)(i))")
   (assert)
   (hide 2)
   (skosimp*)
   (lemma "prod_derivable")
   (inst - "(LAMBDA (x: T): f1!1(x)(i!1))"
    "(LAMBDA (x: T): f2!1(x)(i!1))" "x1!1")
   (assert)
   (expand "*")
   (hide 2)
   (inst?)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_dot_prod
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "derivable?(LAMBDA (x: T):
                                   LAMBDA (i: Index[n]): f1!1(x)(i) * f2!1(x)(i),
                                 x1!1)")
   (("1"
     (lemma "deriv_sigma")
     (expand "*")
     (inst - "n " "x1!1")
     (assert)
     (inst -
      "LAMBDA  (x: T): LAMBDA (i: Index[n]): f1!1(x)(i) * f2!1(x)(i)")
     (split -1)
     (("1"
       (replace -1)
       (hide -1)
       (lemma "sigma_sum")
       (inst?)
       (replace -1)
       (hide -1)
       (rewrite "sigma_eq")
       (hide 2)
       (skosimp*)
       (case-replace
        "deriv(LAMBDA (x: T): LAMBDA (i: Index[n]): f1!1(x)(i) * f2!1(x)(i), x1!1) (n1!1)
                                   = deriv(LAMBDA (x: T): f1!1(x)(n1!1) * f2!1(x)(n1!1), x1!1)")
       (("1"
         (hide -1)
         (lemma "deriv_prod")
         (inst - "(LAMBDA (x: T): f1!1(x)(n1!1))"
          "(LAMBDA (x: T): f2!1(x)(n1!1))" "x1!1")
         (split -1)
         (("1"
           (expand "*")
           (assert)
           (replace -1)
           (hide -1)
           (expand "deriv" 1 3)
           (expand "deriv" 1 2)
           (propax))
          ("2" (hide -1 2) (expand "derivable?" -1) (inst?))
          ("3" (hide -1 2) (expand "derivable?" -2) (inst?))))
        ("2" (hide 2) (expand "deriv" 1 1) (propax))
        ("3" (hide 2) (assert) (expand "derivable?" -1) (inst?))))
      ("2"
       (hide 2)
       (skosimp*)
       (assert)
       (expand "derivable?" -1)
       (inst?))))
    ("2"
     (hide 2)
     (lemma "prod_derivable")
     (inst?)
     (expand "derivable?" 1)
     (skosimp*)
     (inst - "(LAMBDA (x: T): f1!1(x)(i!1))"
      "(LAMBDA (x: T): f2!1(x)(i!1))")
     (assert)
     (expand "*")
     (hide 2)
     (expand "derivable?" -)
     (inst?)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (inst?)
   (inst?)
   (lemma "sum_derivable")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (inst?)
   (inst?)
   (lemma "diff_derivable")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (lemma "dot_prod_derivable")
   (inst?)
   (assert)
   (hide 2)
   (inst?)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (skosimp*)
   (lemma "const_derivable")
   (inst?)
   (postpone))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "ff1!1")
   (typepred "ff2!1")
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_sum")
     (inst - "ff1!1" "ff2!1" "x!1")
     (expand "deriv" 1)
     (assert)
     (hide 2)
     (expand "derivable?" -1)
     (expand "derivable?" -2)
     (inst?)
     (inst?)
     (assert))
    ("2"
     (expand "+")
     (lemma "sum_derivable_vfun")
     (inst - "ff1!1" "ff2!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "ff!1")
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_neg")
     (inst - "ff!1" "x!1")
     (expand "deriv" 1)
     (assert)
     (hide 2)
     (expand "derivable?" -1)
     (inst?))
    ("2" (lemma "neg_derivable_vfun") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "ff1!1")
   (typepred "ff2!1")
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_diff")
     (inst - "ff1!1" "ff2!1" "x!1")
     (expand "deriv" 1)
     (assert)
     (hide 2)
     (expand "derivable?" -1)
     (expand "derivable?" -2)
     (inst?)
     (inst?)
     (assert))
    ("2"
     (lemma "diff_derivable_vfun")
     (inst - "ff1!1" "ff2!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "ff1!1")
   (typepred "ff2!1")
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_dot_prod")
     (inst - "ff1!1" "ff2!1" "x!1")
     (expand "deriv" 1)
     (assert)
     (expand "derivable?" -2)
     (expand "derivable?" -3)
     (inst?)
     (inst?)
     (assert)
     (assert)
     (expand "+")
     (propax))
    ("2" (lemma "dot_derivable_vfun") (inst - "ff1!1" "ff2!1") (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "ff!1")
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_scal")
     (inst?)
     (inst - "x!1")
     (expand "deriv" 1)
     (assert)
     (hide 2)
     (expand "derivable?" -1)
     (inst?))
    ("2" (lemma "scal_derivable_vfun") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: deriv_real_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality 1 :hide? t)
   (("1"
     (lemma "deriv_const")
     (inst?)
     (expand "zero")
     (inst - "x!1")
     (assert)
     (expand "deriv")
     (replace -1 + :dir rl)
     (assert))
    ("2" (lemma "const_derivable_vfun") (inst?))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "convergence")
   (rewrite "sub_eq_zero" :dir rl)
   (rewrite "norm_eq_0" :dir rl)
   (name "eps" "norm(l1 - l2)")
   (inst -3 "eps/2")
   (("1"
     (inst -2 "eps/2")
     (("1"
       (skosimp*)
       (inst -2 "a")
       (inst -3 "a")
       (assert)
       (lemma "norm_triangle[m]")
       (inst - "l1" "f(a)" "l2")
       (lemma "norm_sym[m]")
       (inst - "l1" "f(a)")
       (assert))
      ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "convergence")
   (rewrite "sub_eq_zero" :dir rl)
   (rewrite "norm_eq_0" :dir rl)
   (inst -1 "norm(l-f(a))")
   (("1" (skeep -1) (inst?) (assert) (rewrite "norm_sym") (assert))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "convergence")
   (skosimp)
   (inst - "epsilon!1/4")
   (inst - "epsilon!1/4")
   (skosimp*)
   (inst 1 "min(delta!1, delta!2)")
   (skosimp*)
   (inst?)
   (inst?)
   (assert)
   (lemma "norm_add_le[m]")
   (inst - "f1(v!1) - l1" "f2(v!1)-l2")
   (case "f1(v!1) - l1 + (f2(v!1) - l2) = f1(v!1) + f2(v!1) - (l1 + l2)")
   (("1" (assert)) ("2" (hide-all-but 1) (decompose-equality) (grind))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "convergence")
   (skosimp)
   (inst - "epsilon!1")
   (skosimp)
   (inst + "delta!1")
   (skosimp)
   (inst?)
   (assert)
   (rewrite "norm_sym")
   (case-replace "-f(v!1) -- l = l - f(v!1)")
   (hide-all-but 1)
   (decompose-equality)
   (grind))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "f1 - f2 = f1 + (-f2)")
   (("1"
     (hide -1)
     (lemma "cv_sum")
     (inst -1 "a" "f1" "-f2" "l1" "-l2")
     (assert)
     (rewrite "cv_neg"))
    ("2" (decompose-equality))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case-replace "k = 0")
   (("1" (assert) (lemma "cv_const") (inst - "a" "zero"))
    ("2"
     (expand "convergence")
     (skosimp*)
     (inst - "epsilon!1/abs(k)")
     (("1"
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst?)
       (assert)
       (cross-mult -1)
       (lemma "norm_scal[m]")
       (inst - "k" "f(v!1)-l")
       (rewrite "scal_sub_right")
       (expand "*" 2 1)
       (assert))
      ("2"
       (hide 3)
       (case "epsilon!1 / abs(k) > 0")
       (("1" (assert)) ("2" (hide 2) (cross-mult 1) (assert))
        ("3" (flatten) (lemma "abs_eq_0") (inst?) (assert))))
      ("3" (assert))))))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "convergent?")
   (skosimp*)
   (inst + "-l!1")
   (expand "convergence")
   (skosimp*)
   (inst - "epsilon!1")
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst - "v!1")
   (assert)
   (expand "norm")
   (expand "sqv")
   (assert)
   (grind))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "convergent?")
   (skosimp*)
   (inst + "k!1*l!1")
   (lemma "cv_scal")
   (inst?)
   (prop))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (auto-rewrite "lim_fun_lemma" "lim_fun_def" "neg_fun_convergent"
                 "cv_neg")
   (skosimp*)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "lim_fun_def")
   (inst - "const_fun(l!1)" "l!1" "a!1")
   (replace -1)
   (expand "const_fun")
   (lemma "cv_const")
   (inst - "a!1" "l!1"))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "scal_fun_convergent")
   (inst - "a!1" "f!1" "k!1")
   (prop)
   (lemma "lim_fun_def")
   (inst - "(LAMBDA (v): k!1 * f!1(v))" "k!1 * lim(f!1,a!1)" "a!1")
   (replace -1)
   (lemma "lim_fun_def")
   (inst - "f!1" "lim(f!1,a!1)" "a!1")
   (prop)
   (lemma "cv_scal")
   (inst - "a!1" "f!1" "k!1" "lim(f!1,a!1)")
   (prop))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: limit_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "convergent?")
   (inst + "l!1")
   (lemma "cv_const")
   (inst - "a!1" "l!1")
   (expand "const_fun")
   (propax))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "continuity_def")
   (rewrite "continuity_def")
   (rewrite "continuity_def")
   (lemma "cv_sum[n,m]")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous_vv?")
   (skosimp*)
   (expand "const_fun")
   (inst + "epsilon!1")
   (skosimp*)
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_vv?")
   (skosimp*)
   (inst - "epsilon!1")
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst?)
   (assert)
   (lemma "norm_neg[m]")
   (inst - "f!1(x!1) - f!1(x0!1)")
   (expand "-")
   (assert))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: cont_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (expand "continuous_vv?")
   (skosimp*)
   (inst?)
   (inst?)
   (lemma "sum_fun_continuous_vv")
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: vect_analysis
theory: cont_vect
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "(LAMBDA (x: Vector[n]): vectors.zero)")
   (expand "continuous_vv?")
   (skosimp*)
   (rewrite "continuity_def")
   (lemma "cv_const")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vect_analysis
theory: limit_vect_real
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind :exclude ("abs" "norm" "-" "sigma") :if-match nil)
   (rewrite "abs_diff_0")
   (name "eps" "abs(l1!1 - l2!1)")
   (replace -1)
   (inst -4 "eps/2")
   (("1"
     (inst -5 "eps/2")
     (("1"
       (assert)
       (skosimp*)
       (case " EXISTS (x: Vector): a!1 /= x AND norm(x - a!1) < delta!1 AND norm(x - a!1) < delta!2")
       (("1"
         (skosimp*)
         (inst?)
         (inst?)
         (assert)
         (case "0 < norm(x!1 - a!1)")
         (("1"
           (assert)
           (lemma "triangle2")
           (inst - "eps/2" "eps/2" "l1!1" "f!1(x!1)" "l2!1")
           (assert))
          ("2"
           (lemma "norm_eq_0")
           (inst?)
           (assert)
           (replace -1 * lr)
           (assert)
           (rewrite "sub_eq_zero"))))
        ("2"
         (hide -4 -5)
         (name "DEL" "min(delta!1,delta!2)")
         (name AA "a!1 WITH [0 := a!1(0) + DEL/2]")
         (("1"
           (inst + "AA")
           (case "norm(AA - a!1) = abs(DEL/2)")
           (("1"
             (replace -1 * lr)
             (hide -1)
             (case "a!1 /= AA")
             (("1" (assert) (hide -1 -2) (grind))
              ("2"
               (flatten)
               (assert)
               (hide 1 -3 -4)
               (replace -1 * lr)
               (hide -1)
               (case "AA WITH [(0) := AA(0) + DEL / 2](0) = AA(0)")
               (("1" (hide -2) (assert))
                ("2" (replace -1 * lr) (propax))))))
            ("2"
             (hide -1)
             (reveal -1)
             (hide 2)
             (replace -1 * rl)
             (hide -1)
             (expand "norm")
             (case-replace
              "a!1 WITH [(0) := a!1(0) + DEL / 2] - a!1 =
                                                   (LAMBDA (i: Index): IF i = 0 THEN DEL/2 ELSE 0 ENDIF)")
             (("1"
               (hide -1)
               (expand "sqv")
               (expand "*")
               (lemma "sigma_first")
               (inst?)
               (assert)
               (assert)
               (replace -1)
               (hide -1)
               (lemma "sigma_restrict")
               (inst?)
               (assert)
               (inst - "n-1" "1")
               (("1"
                 (assert)
                 (replace -1 * lr)
                 (hide -1)
                 (expand "restrict")
                 (rewrite "sigma_const")
                 (assert)
                 (expand "abs")
                 (propax))
                ("2"
                 (assert)
                 (case "n = 1")
                 (("1"
                   (replace -1)
                   (expand "sigma")
                   (assert)
                   (expand "abs")
                   (propax))
                  ("2"
                   (case-replace "n = 0")
                   (("1" (assert)) ("2" (assert))))))))
              ("2"
               (apply-extensionality 1 :hide? t)
               (assert)
               (hide 2)
               (lift-if)
               (ground)
               (("1" (replace -1) (assert) (expand "-") (propax))
                ("2" (expand "-") (propax))))))))
          ("2" (assert))))))
      ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "norm")
   (split)
   (("1"
     (flatten)
     (lemma "sqrt_eq_0")
     (inst -1 "sqv(v)")
     (split -1)
     (("1"
       (hide -2)
       (rewrite "sqv_sos")
       (expand "sos")
       (lemma "sigma_nonneg_eq_0")
       (inst?)
       (skeep)
       (inst -1 "i")
       (assert)
       (rewrite "sq_eq_0"))
      ("2" (propax))))
    ("2"
     (flatten)
     (rewrite "sqv_sos")
     (expand "sos")
     (case-replace "(LAMBDA i:sq(v(i))) = (LAMBDA i:0)")
     (("1" (hide -) (rewrite "sigma_const") (assert))
      ("2"
       (hide 2)
       (decompose-equality 1)
       (inst?)
       (rewrite "sq_eq_0"))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "norm_comp_eq_0")
   (inst?)
   (replaces -1)
   (split)
   (("1" (flatten) (decompose-equality) (inst?) (expand "zero") (propax))
    ("2"
     (flatten)
     (skeep)
     (decompose-equality -1)
     (inst?)
     (expand "zero")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "norm_sqv_eq_0")
   (inst?)
   (replaces -1 :dir rl)
   (lemma "norm_eq_0")
   (inst?))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "norm_eq_0")
   (inst?)
   (assert)
   (expand "norm")
   (flatten)
   (split +)
   (("1"
     (flatten)
     (expand "sqv")
     (case-replace "v*v = 0")
     (("1" (assert))
      ("2"
       (hide 2)
       (assert)
       (expand "*")
       (lemma "sigma_Fnnr")
       (inst?)
       (assert)
       (expand "sq")
       (assert))))
    ("2"
     (flatten)
     (replace -2)
     (expand "zero")
     (expand "sq")
     (lemma "sigma_zero")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "norm_eq_0")
   (inst?)
   (replaces -1 :dir rl)
   (case-replace "norm(v)=0 IFF sq(norm(v))=0")
   (("1"
     (hide -1)
     (expand "norm")
     (rewrite "sq_sqrt")
     (expand "sqv")
     (propax))
    ("2" (hide 2) (rewrite "sq_eq_0") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "nz_vector?")
   (lemma "norm_eq_0")
   (inst?)
   (lemma "norm_comp_eq_0")
   (inst?)
   (replaces -1)
   (ground)
   (("1" (skeep -1) (inst? -2)) ("2" (skeep 4) (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("u" "v" "w"))
   (ground)
   (("1"
     (decompose-equality 1)
     (decompose-equality -1)
     (inst -1 "x!1")
     (grind))
    ("2"
     (decompose-equality -1)
     (decompose-equality 1)
     (inst -1 "x!1")
     (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind)
   (("1" (decompose-equality 1) (decompose-equality -1) (grind))
    ("2" (decompose-equality 1))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind)
   (("1" (decompose-equality 1))
    ("2" (decompose-equality 1) (decompose-equality -1) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("u" "v"))
   (ground)
   (("1"
     (decompose-equality 1)
     (decompose-equality -1)
     (inst -1 "x!1")
     (expand "zero")
     (expand "-")
     (assert))
    ("2" (replace -1) (rewrite "sub_eq_args"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (lemma "sigma_scal")
   (inst?)
   (("1"
     (inst -1 "-1")
     (assert)
     (case-replace
      "(LAMBDA (i_673: below(n)): -1 * ((-u!1)(i_673) * w!1(i_673))) = (LAMBDA (i_673: below(n)): ((u!1)(i_673) * w!1(i_673)))")
     (("1" (assert))
      ("2" (apply-extensionality 1 :hide? t) (hide-all-but 1) (grind))))
    ("2" (expand "sigma") (assert)) ("3" (expand "sigma") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (lemma "sigma_scal")
   (inst?)
   (("1"
     (inst -1 "-1")
     (assert)
     (case-replace
      "(LAMBDA (i_673: below(n)): -1 * ((u!1)(i_673) * (-w!1)(i_673))) = (LAMBDA (i_673: below(n)): ((u!1)(i_673) * w!1(i_673)))")
     (("1" (assert))
      ("2" (apply-extensionality 1 :hide? t) (hide-all-but 1) (grind))))
    ("2" (expand "sigma") (assert)) ("3" (expand "sigma") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 "v")
   (expand "*")
   (expand "zero")
   (lemma "sigma_const")
   (inst -1 "n-1" "0" "0")
   (("1" (assert)) ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("a" "v" "w"))
   (expand "*")
   (lemma "sigma_scal")
   (inst -1 "LAMBDA i: v(i) * w(i)" "a" "n-1" "0")
   (("1" (assert)) ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (case-replace
    "(LAMBDA i: u!1(i) * (v!1 + w!1)(i)) =
                          (LAMBDA i: u!1(i) * v!1(i) + u!1(i) * w!1(i))")
   (("1" (hide -1) (rewrite "sigma_sum"))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (expand "+ ")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (case-replace
    "(LAMBDA i: (v!1 + w!1)(i) * u!1(i)) =
                      (LAMBDA i: v!1(i)* u!1(i)  + w!1(i) * u!1(i))")
   (("1" (hide -1) (rewrite "sigma_sum"))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (expand "+ ")
     (ground))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "add_neg_sub" :dir rl)
   (rewrite "dot_add_right")
   (rewrite "dot_neg_right")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "add_neg_sub" :dir rl)
   (rewrite "dot_add_left")
   (rewrite "dot_neg_left")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (grind)
   (expand "*")
   (apply-extensionality 1 :hide? t)
   (mult-by 1 "nza!1")
   (assert)
   (case "(LAMBDA i: nza!1 * u!1(i))(x!1) = (LAMBDA i: nza!1 * v!1(i))(x!1)")
   (("1" (assert)) ("2" (replace -1) (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (lemma "sigma_scal")
   (inst?)
   (("1" (assert)) ("2" (assert)) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "dot_scal_left")
   (rewrite "dot_comm")
   (rewrite "dot_scal_left")
   (rewrite "dot_comm")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind)
   (("1" (decompose-equality 2) (decompose-equality -1) (inst?) (grind))
    ("2" (decompose-equality 2))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "*")
   (prop)
   (("1"
     (apply-extensionality 1 :hide? t)
     (replace -1 * rl)
     (hide -1)
     (assert))
    ("2"
     (apply-extensionality 1 :hide? t)
     (lemma "comps_eq")
     (inst?)
     (assert)
     (hide -2)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "*")
   (prop)
   (("1"
     (apply-extensionality 1 :hide? t)
     (replace -1 * lr)
     (hide -1)
     (assert))
    ("2"
     (apply-extensionality 1 :hide? t)
     (lemma "comps_eq")
     (inst?)
     (assert)
     (hide -2)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "*")
   (typepred "nzv")
   (rewrite "nzv_comp_neq_0")
   (skeep -1)
   (decompose-equality -1)
   (inst? -1)
   (mult-by 2 "nzv(i)"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind)
   (expand "*")
   (decompose-equality 2)
   (decompose-equality -1)
   (inst?)
   (grind))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (lemma "sigma_minus")
   (inst - "LAMBDA i: w!1(i) * u!1(i)" "LAMBDA i: w!1(i) * v!1(i)" "n-1"
    "0")
   (assert)
   (move-terms -1 l 2)
   (replace -1)
   (hide -1)
   (assert)
   (case-replace
    "(LAMBDA i: w!1(i) * (u!1 - v!1)(i)) = (LAMBDA (i_1: below(n)):
                  w!1(i_1) * u!1(i_1) - w!1(i_1) * v!1(i_1))")
   (("1" (assert))
    ("2" (hide 2) (apply-extensionality 1 :hide? t) (hide -1) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "*")
   (lemma "sigma_minus")
   (inst - "LAMBDA i: w!1(i) * u!1(i)" "LAMBDA i: w!1(i) * v!1(i)" "n-1"
    "0")
   (assert)
   (move-terms -1 l 2)
   (replace -1)
   (hide -1)
   (assert)
   (case-replace
    "(LAMBDA i: w!1(i) * (u!1 - v!1)(i)) = (LAMBDA (i_1: below(n)):
                    w!1(i_1) * u!1(i_1) - w!1(i_1) * v!1(i_1))")
   (("1" (assert))
    ("2" (hide 2) (apply-extensionality 1 :hide? t) (hide -1) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("a" "v"))
   (ground)
   (("1"
     (case "EXISTS (i:below(n)):v(i) /= 0")
     (("1"
       (skolem -1 "i")
       (decompose-equality -2)
       (inst -1 "i")
       (expand "*")
       (lemma "both_sides_times1")
       (inst -1 "v(i)" "a" "1")
       (("1" (ground)) ("2" (assert))))
      ("2" (hide -1 2) (decompose-equality 2) (inst 2 "x!1") (grind))))
    ("2" (expand "*") (decompose-equality 1))
    ("3" (replace -1) (rewrite "scal_zero"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sqv")
   (rewrite "dot_add_left")
   (rewrite "dot_add_right")
   (rewrite "dot_add_right")
   (assert)
   (rewrite "dot_comm")
   (rewrite "dot_comm")
   (assert)
   (rewrite "dot_assoc"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sqv")
   (rewrite "dot_scal_right")
   (expand "sq")
   (assert)
   (rewrite "dot_assoc" :dir rl)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sqv")
   (rewrite "dot_sub_left")
   (rewrite "dot_sub_right")
   (rewrite "dot_sub_right")
   (assert)
   (rewrite "dot_comm")
   (rewrite "dot_comm")
   (assert)
   (rewrite "dot_assoc" :dir rl)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "sqv")
   (expand "*")
   (case-replace
    "(LAMBDA i: (v!1 - u!1)(i) * (v!1 - u!1)(i)) = (LAMBDA i: (u!1 - v!1)(i) * (u!1 - v!1)(i))")
   (hide 2)
   (apply-extensionality 1 :hide? t)
   (grind))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sq_eq")
   (inst?)
   (assert)
   (replace -1 * rl)
   (hide -1)
   (rewrite "sq_norm")
   (rewrite "sq_norm")
   (expand "sqv")
   (propax))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (rewrite "sqv_scal")
   (rewrite "sqrt_times")
   (rewrite "sqrt_sq_abs"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "^")
   (assert)
   (rewrite "dot_scal_right")
   (assert)
   (rewrite "dot_scal_left")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "^")
   (rewrite "norm_scal")
   (expand "abs")
   (grind-reals)
   (rewrite "scal_1"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "^")
   (rewrite "norm_scal")
   (rewrite "sign_abs")
   (rewrite "scal_assoc")
   (rewrite "scal_assoc")
   (grind-reals)
   (case-replace
    "nza / (sign(nza) * norm(nzv) * nza) = sign(nza) / norm(nzv)")
   (hide 2)
   (grind :exclude "norm"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "sqv(v!1) = 0")
   (("1"
     (rewrite "sqv_eq_0")
     (replace -1)
     (hide -1)
     (rewrite "dot_zero_right")
     (rewrite "sq_0")
     (assert))
    ("2"
     (case "(FORALL (t:real): sqv(u!1-t*v!1) >= 0)")
     (("1"
       (inst -1 "(u!1*v!1)/sqv(v!1)")
       (("1"
         (rewrite "sqv_sub_scal")
         (name-replace "UDOTV" "u!1 * v!1")
         (case-replace
          "2 * (UDOTV / sqv(v!1)) * u!1 * v!1 = 2 * sq(UDOTV) / sqv(v!1) ")
         (("1"
           (hide -1)
           (case-replace
            "sq(UDOTV / sqv(v!1)) * sqv(v!1) = sq(UDOTV) / sqv(v!1) ")
           (("1"
             (hide -1)
             (assert)
             (case-replace
              "sqv(u!1) + sq(UDOTV) / sqv(v!1) - 2 * sq(UDOTV) / sqv(v!1) = sqv(u!1) - sq(UDOTV) / sqv(v!1)")
             (("1" (hide -1) (assert) (mult-by -1 "sqv(v!1)") (assert))
              ("2" (lemma "sqv_eq_0") (inst?) (assert))))
            ("2" (rewrite "sq_div") (expand "sq" 1) (assert))))
          ("2"
           (assert)
           (assert)
           (hide -1 3)
           (reveal -2)
           (case-replace
            "2 * (UDOTV / sqv(v!1)) * u!1 * v!1 = 2 * (UDOTV / sqv(v!1)) * (u!1 * v!1)")
           (("1" (hide -1) (replace -1) (hide -1) (expand "sq") (assert))
            ("2" (hide -1 2 3) (rewrite "dot_scal_left"))))))
        ("2" (assert))))
      ("2" (assert) (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "cauchy_schwarz")
   (inst?)
   (lemma "sqrt_le")
   (inst?)
   (assert)
   (hide -2)
   (lemma "sqrt_sq_abs")
   (inst?)
   (assert)
   (replace -1)
   (hide -1)
   (rewrite "sqrt_times")
   (expand "norm")
   (expand "abs")
   (lift-if)
   (ground))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sq_le")
   (inst?)
   (assert)
   (hide 2)
   (rewrite "sqv_add")
   (rewrite "sq_plus")
   (move-terms 1 r (1 2))
   (case "u*v <= sqrt(sqv(u)) * sqrt(sqv(v))")
   (("1" (assert) (rewrite "dot_scal_left") (assert))
    ("2" (hide 2) (lemma "schwarz") (inst?) (expand "norm") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqv_sq")
   (rewrite "sqv_sq")
   (rewrite "sqv_sq")
   (expand "-")
   (case-replace
    "(LAMBDA i:sq(u(i)-w(i))) = (LAMBDA i:sq(u(i)-v(i)+v(i)-w(i)))")
   (("1"
     (hide -1)
     (lemma "schwarz_cor")
     (inst -1 "u-v" "v-w")
     (rewrite "sqv_sq")
     (rewrite "sqv_sq")
     (rewrite "sqv_sq")
     (expand "-")
     (expand "+")
     (assert))
    ("2" (decompose-equality))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (lemma "sqrt_le")
   (inst -1 "sqv(u!1 + v!1)" "sq(sqrt(sqv(u!1)) + sqrt(sqv(v!1)))")
   (rewrite "sqrt_sq")
   (assert)
   (hide 2)
   (rewrite "sqv_add")
   (expand "sq")
   (rewrite "sqrt_sqv_sq")
   (rewrite "sqrt_sqv_sq")
   (rewrite "sqrt_sqv_norm")
   (rewrite "sqrt_sqv_norm")
   (lemma "dot_norm")
   (inst -1 "u!1" "v!1")
   (flatten)
   (rewrite "dot_scal_left")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (lemma "sq_le")
   (inst?)
   (assert)
   (hide 2)
   (rewrite "sq_sqrt")
   (expand "sq")
   (rewrite "sq_rew")
   (rewrite "sq_rew")
   (rewrite "sq_sqrt")
   (rewrite "sq_sqrt")
   (rewrite "sqv_sub")
   (assert)
   (rewrite "sqrt_sqv_norm")
   (rewrite "sqrt_sqv_norm")
   (assert)
   (lemma "dot_norm")
   (inst -1 "-u!1" "v!1")
   (flatten)
   (rewrite "norm_neg")
   (rewrite "dot_neg_left")
   (assert)
   (rewrite "dot_scal_left")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "norm_add_le")
   (inst -1 "u!1-v!1" "v!1")
   (assert)
   (rewrite "add_cancel2")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (expand "sqv")
   (expand "*")
   (rewrite "sqrt_sq_abs" :dir rl)
   (case-replace
    "(LAMBDA i: u!1(i) * u!1(i)) =
                           (LAMBDA i: sq(u!1(i)))")
   (("1"
     (hide -1)
     (lemma "sqrt_ge")
     (inst?)
     (("1"
       (assert)
       (hide 2)
       (case "i!1 = n - 1")
       (("1"
         (expand "sigma")
         (assert)
         (lift-if)
         (ground)
         (replace -1 * rl)
         (lemma "sigma_nonneg[below[n]]")
         (inst?)
         (assert)
         (skosimp*)
         (assert))
        ("2"
         (case-replace "i!1 = 0")
         (("1"
           (lemma "sigma_first")
           (inst?)
           (assert)
           (replace -1)
           (hide -1)
           (assert)
           (lemma "sigma_nonneg[below[n]]")
           (inst?)
           (assert)
           (skosimp*)
           (assert))
          ("2"
           (lemma "sigma_middle[below(n)]")
           (inst - "(LAMBDA i: sq(u!1(i)))" "n-1" "i!1" "0")
           (assert)
           (replace -1)
           (hide -1)
           (case-replace
            "sigma(1 + i!1, n - 1, (LAMBDA i: sq(u!1(i)))) >= 0")
           (("1"
             (case "sigma(0, i!1 - 1, (LAMBDA i: sq(u!1(i)))) >= 0")
             (("1" (assert))
              ("2"
               (hide-all-but 1)
               (lemma "sigma_nonneg[below[n]]")
               (inst?)
               (assert)
               (skosimp*)
               (assert))))
            ("2"
             (hide-all-but 1)
             (lemma "sigma_nonneg[below[n]]")
             (inst?)
             (assert)
             (skosimp*)
             (assert))))))))
      ("2"
       (lemma "sigma_nonneg[below[n]]")
       (inst?)
       (assert)
       (skosimp*)
       (assert))))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (expand "sq")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (rewrite "sq_sqrt")
   (rewrite "sq_sqrt")
   (rewrite "sq_sqrt")
   (auto-rewrite "sqv_sub")
   (auto-rewrite "scal_sub_right")
   (auto-rewrite "dot_sub_right")
   (auto-rewrite "dot_sub_left")
   (auto-rewrite "sub_cancel")
   (assert)
   (expand "sqv")
   (auto-rewrite "dot_scal_assoc")
   (auto-rewrite "dot_scal_right")
   (auto-rewrite "dot_scal_left")
   (assert)
   (lemma "dot_comm")
   (inst -1 "v0!1" "v1!1")
   (replace -1)
   (hide -1)
   (lemma "dot_comm")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "parallel?")
   (split)
   (("1"
     (flatten)
     (skeep -1)
     (inst 1 "1/nzk")
     (lemma "scal_cross")
     (inst?)
     (assert))
    ("2"
     (flatten)
     (skeep -1)
     (inst 1 "1/nzk")
     (lemma "scal_cross")
     (inst? -1)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "parallel?")
   (skolem -1 "k1")
   (skolem -2 "k2")
   (replaces -1)
   (replaces -2)
   (replaces -1)
   (inst 1 "k1*k2")
   (rewrite "scal_assoc"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "parallel?")
   (split)
   (("1" (flatten) (skeep -1) (rewrite "scal_zero"))
    ("2" (flatten) (replaces -1) (inst 1 "1") (rewrite "scal_zero"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "orthogonal?")
   (rewrite "sqv_add")
   (assert)
   (rewrite "dot_scal_left")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (both-sides-f 1 "sq")
   (("1"
     (rewrite "sq_norm")
     (rewrite "sq_norm")
     (rewrite "pythagorean")
     (assert))
    ("2" (rewrite "sq_ge"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "add_comm")
   (rewrite "norm_add_ge_left")
   (expand "orthogonal?")
   (rewrite "dot_comm"))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: vectors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 "m")
   (expand "norm")
   (case "sqv(vectors.zero WITH [m := 1]) = 1")
   (("1" (expand "zero") (replace -1) (rewrite "sqrt_1"))
    ("2"
     (hide 2)
     (expand "sqv")
     (expand "*")
     (typepred "m")
     (case "m=n-1")
     (("1"
       (replace -1 :dir rl)
       (expand "sigma")
       (assert)
       (lemma "sigma_eq")
       (inst -1
        "LAMBDA i:(zero WITH [m := 1](i)) * (zero WITH [m := 1](i))"
        "zero" "m-1" "0")
       (split -1)
       (("1"
         (replace -1)
         (hide -1)
         (expand "zero")
         (rewrite "sigma_zero"))
        ("2" (skolem 1 "N") (grind))))
      ("2"
       (lemma "sigma_split")
       (inst -1
        "LAMBDA i: (zero WITH [m := 1](i)) * (zero WITH [m := 1](i))"
        "n-1" "0" "m")
       (assert)
       (replace -1)
       (hide -1)
       (case-replace
        "sigma(1 + m, n - 1,
                                 LAMBDA i: (zero WITH [m := 1](i)) * (zero WITH [m := 1](i))) =0")
       (("1"
         (hide -1)
         (assert)
         (expand "sigma")
         (assert)
         (lemma "sigma_eq")
         (inst -1
          "LAMBDA i:(zero WITH [m := 1](i)) * (zero WITH [m := 1](i))"
          "zero" "m-1" "0")
         (split -1)
         (("1"
           (replace -1)
           (hide -1)
           (expand "zero")
           (rewrite "sigma_zero"))
          ("2" (hide 3) (skolem 1 "N") (grind))))
        ("2"
         (hide 3)
         (lemma "sigma_eq")
         (inst -1
          "LAMBDA i:(zero WITH [m := 1](i)) * (zero WITH [m := 1](i))"
          "zero" "n-1" "1+m")
         (split -1)
         (("1"
           (replace -1)
           (hide -1)
           (expand "zero")
           (rewrite "sigma_zero"))
          ("2" (hide 2) (skolem 1 "N") (grind))))))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "norm")
   (split)
   (("1"
     (flatten)
     (lemma "sqrt_eq_0")
     (inst -1 "sqv(v)")
     (split -1)
     (("1"
       (hide -2)
       (rewrite "sqv_sos")
       (expand "sos")
       (case "sq(v`x)=0 AND sq(v`y)=0 AND sq(v`z)=0")
       (("1"
         (flatten)
         (rewrite "sq_eq_0")
         (rewrite "sq_eq_0")
         (rewrite "sq_eq_0")
         (assert))
        ("2" (assert))))
      ("2" (propax))))
    ("2"
     (flatten)
     (rewrite "sqv_sos")
     (expand "sos")
     (replaces -)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "nz_vector?")
   (lemma "norm_eq_0")
   (inst?)
   (lemma "norm_xyz_eq_0")
   (inst?)
   (ground))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (flatten)
     (replaces -1 :dir rl)
     (decompose-equality 1)
     (("1" (grind)) ("2" (grind)) ("3" (grind))))
    ("2"
     (flatten)
     (replaces -1)
     (decompose-equality 1)
     (("1" (grind)) ("2" (grind)) ("3" (grind))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind)
   (mult-by 1 "nzv`x")
   (mult-by 1 "nzv`y")
   (mult-by 1 "nzv`z")
   (typepred "nzv")
   (rewrite "nzv_xyz_neq_0"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind)
   (apply-extensionality 2 :hide? t)
   (("1" (mult-cases -2)) ("2" (mult-cases -3)) ("3" (mult-cases -4))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (case-replace
      "(a!1 * v!1)`x = v!1`x AND (a!1 * v!1)`y = v!1`y AND (a!1 * v!1)`z = v!1`z")
     (("1"
       (flatten)
       (expand "zero")
       (expand "*")
       (apply-extensionality 2 :hide? t))
      ("2" (replace -1) (propax))))
    ("2" (replace -1) (grind) (apply-extensionality :hide? t))
    ("3" (replace -1) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "^")
   (rewrite "norm_scal")
   (expand "abs")
   (case "(1 / norm(nzv!1)) < 0")
   (("1" (assert) (cross-mult -1) (assert))
    ("2" (assert) (expand "*") (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "sqv(v!1) = 0")
   (("1" (rewrite "sqv_eq_0") (grind))
    ("2"
     (case "(FORALL (t:real): sqv(u!1-t*v!1) >= 0)")
     (("1"
       (inst -1 "(u!1*v!1)/sqv(v!1)")
       (("1"
         (rewrite "sqv_sub_scal")
         (name-replace UDOTV "u!1 * v!1")
         (case-replace
          "2 * (UDOTV / sqv(v!1)) * u!1 * v!1 = 2 * sq(UDOTV) / sqv(v!1) ")
         (("1"
           (hide -1)
           (case-replace
            "sq(UDOTV / sqv(v!1)) * sqv(v!1) = sq(UDOTV) / sqv(v!1) ")
           (("1"
             (hide -1)
             (assert)
             (case-replace
              "sqv(u!1) + sq(UDOTV) / sqv(v!1) - 2 * sq(UDOTV) / sqv(v!1) = sqv(u!1) - sq(UDOTV) / sqv(v!1)")
             (("1" (hide -1) (assert) (mult-by -1 "sqv(v!1)") (assert))
              ("2" (hide -2 2) (lemma "sqv_eq_0") (inst?) (assert))))
            ("2" (rewrite "sq_div") (expand "sq" 1) (assert))))
          ("2"
           (assert)
           (assert)
           (hide -1 3)
           (reveal -2)
           (case-replace
            "2 * (UDOTV / sqv(v!1)) * u!1 * v!1 = 2 * (UDOTV / sqv(v!1)) * (u!1 * v!1)")
           (("1" (hide -1) (replace -1) (hide -1) (expand "sq") (assert))
            ("2" (hide -1 2 3) (grind))))))
        ("2" (assert))))
      ("2" (assert) (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqv_sq")
   (rewrite "sqv_sq")
   (rewrite "sqv_sq")
   (expand "-")
   (case-replace "sq(u`x - w`x) = sq(u`x - v`x + v`x - w`x)")
   (("1"
     (hide -1)
     (case-replace "sq(u`y - w`y) = sq(u`y - v`y + v`y - w`y)")
     (("1"
       (case-replace "sq(u`z - w`z) = sq(u`z - v`z + v`z - w`z)")
       (("1"
         (hide -1 -2)
         (lemma "schwarz_cor")
         (inst - "u-v" "v-w")
         (grind))
        ("2" (hide 2) (assert))))
      ("2" (assert))))
    ("2" (hide 2) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (lemma "sq_le")
   (inst?)
   (assert)
   (hide 2)
   (rewrite "sq_sqrt")
   (expand "sq")
   (rewrite "sq_rew")
   (rewrite "sq_rew")
   (rewrite "sq_sqrt")
   (rewrite "sq_sqrt")
   (rewrite "sqv_sub")
   (assert)
   (rewrite "sqrt_sqv_norm")
   (rewrite "sqrt_sqv_norm")
   (assert)
   (lemma "dot_norm")
   (inst -1 "-u!1" "v!1")
   (flatten)
   (rewrite "norm_neg")
   (rewrite "dot_neg_left")
   (mult-by -2 "2")
   (assert)
   (ground)
   (rewrite "dot_scal_left")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "norm")
     (expand "sqv")
     (expand "*")
     (case "sqrt(u!1`x * u!1`x + u!1`y * u!1`y + u!1`z * u!1`z) >= sqrt(u!1`x * u!1`x)")
     (("1" (rewrite "sq_rew") (rewrite "sqrt_sq_abs"))
      ("2" (hide 2) (rewrite "sqrt_ge"))))
    ("2"
     (expand "norm")
     (expand "sqv")
     (expand "*")
     (case "sqrt(u!1`x * u!1`x + u!1`y * u!1`y + u!1`z * u!1`z) >= sqrt(u!1`y * u!1`y)")
     (("1" (rewrite "sq_rew") (rewrite "sq_rew") (rewrite "sqrt_sq_abs"))
      ("2"
       (hide 2)
       (rewrite "sq_rew")
       (rewrite "sq_rew")
       (rewrite "sq_rew")
       (rewrite "sqrt_ge")
       (assert))))
    ("3"
     (expand "norm")
     (expand "sqv")
     (expand "*")
     (case "sqrt(u!1`x * u!1`x + u!1`y * u!1`y + u!1`z * u!1`z) >= sqrt(u!1`z * u!1`z)")
     (("1"
       (rewrite "sq_rew")
       (rewrite "sq_rew")
       (rewrite "sq_rew")
       (rewrite "sqrt_sq_abs"))
      ("2" (hide 2) (rewrite "sqrt_ge"))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "norm")
   (rewrite "sq_sqrt")
   (rewrite "sq_sqrt")
   (rewrite "sq_sqrt")
   (grind))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "parallel?")
   (split)
   (("1" (flatten) (skeep -1) (rewrite "scal_zero"))
    ("2" (flatten) (replaces -1) (grind))))


proof_type: j_proof
decl_type: tcc
library: vectors
theory: vectors_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind)
   (decompose-equality 2)
   (("1" (grind-reals)) ("2" (grind-reals)) ("3" (grind-reals))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: test_vec
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (vect-distr)
   (rewrite "comp_distr_add")
   (rewrite "comp_distr_scal")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_dot_alt
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "m")
   (("1" (skosimp*) (expand "sigma") (expand "sigma") (lift-if) (ground))
    ("2"
     (skosimp*)
     (inst?)
     (lemma "sigma_last[nat]")
     (assert)
     (inst - "_" "j!1+1" "0")
     (inst?)
     (assert)
     (replace -1)
     (hide -1)
     (lemma "sigma_last[Index[n]]")
     (inst - "_" "j!1+1" "0")
     (inst?)
     (assert))
    ("3" (skosimp*)) ("4" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "norm")
   (split)
   (("1"
     (lemma "sqrt_eq_0")
     (inst -1 "sqv(v)")
     (split -1)
     (("1"
       (rewrite "sqv_sos")
       (expand "sos")
       (rewrite "sq_plus_eq_0")
       (flatten)
       (assert))
      ("2" (assert))))
    ("2"
     (flatten)
     (rewrite "sqv_sos")
     (expand "sos")
     (replaces -)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "nz_vector?")
   (lemma "norm_eq_0")
   (inst?)
   (lemma "norm_xy_eq_0")
   (inst?)
   (replaces -1)
   (ground))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (grind)
   (("1" (apply-extensionality 1 :hide? t))
    ("2" (apply-extensionality 1 :hide? t))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (flatten)
     (replaces -1 :dir rl)
     (decompose-equality 1)
     (("1" (grind)) ("2" (grind))))
    ("2"
     (flatten)
     (replaces -1)
     (decompose-equality 1)
     (("1" (grind)) ("2" (grind))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (grind)
   (mult-by 1 "nzv`x")
   (mult-by 1 "nzv`y")
   (typepred "nzv")
   (lemma "norm_xy_eq_0")
   (inst?)
   (ground))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (grind)
   (apply-extensionality 2 :hide? t)
   (("1" (mult-cases -1)) ("2" (mult-cases -2))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (case-replace "(a!1 * v!1)`x = v!1`x AND (a!1 * v!1)`y = v!1`y")
     (("1"
       (flatten)
       (expand "zero")
       (expand "*")
       (apply-extensionality 2 :hide? t))
      ("2" (assert))))
    ("2" (replace -1) (grind) (apply-extensionality :hide? t))
    ("3" (replace -1) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "^")
   (rewrite "norm_scal")
   (expand "abs")
   (case "1 / norm(nzv!1) >= 0")
   (("1" (assert) (expand "*") (propax)) ("2" (cross-mult 1) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "sqv(v!1) = 0")
   (("1" (rewrite "sqv_eq_0") (grind))
    ("2"
     (case "(FORALL (t:real): sqv(u!1-t*v!1) >= 0)")
     (("1"
       (inst -1 "(u!1*v!1)/sqv(v!1)")
       (("1"
         (rewrite "sqv_sub_scal")
         (name-replace UDOTV "u!1 * v!1")
         (case-replace
          "2 * (UDOTV / sqv(v!1)) * u!1 * v!1 = 2 * sq(UDOTV) / sqv(v!1) ")
         (("1"
           (hide -1)
           (case-replace
            "sq(UDOTV / sqv(v!1)) * sqv(v!1) = sq(UDOTV) / sqv(v!1) ")
           (("1"
             (hide -1)
             (assert)
             (case-replace
              "sqv(u!1) + sq(UDOTV) / sqv(v!1) - 2 * sq(UDOTV) / sqv(v!1) = sqv(u!1) - sq(UDOTV) / sqv(v!1)")
             (("1" (hide -1) (assert) (mult-by -1 "sqv(v!1)") (assert))
              ("2" (hide -2 2) (lemma "sqv_eq_0") (inst?) (assert))))
            ("2" (rewrite "sq_div") (expand "sq" 1) (assert))))
          ("2"
           (assert)
           (hide -1 3)
           (reveal -2)
           (case-replace
            "2 * (UDOTV / sqv(v!1)) * u!1 * v!1 = 2 * (UDOTV / sqv(v!1)) * (u!1 * v!1)")
           (("1" (hide -1) (replace -1) (hide -1) (expand "sq") (assert))
            ("2" (hide -1 2 3) (grind))))))
        ("2" (assert))))
      ("2" (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (nzv: Nz_vector, u: Vector): norm(u) = 1 AND norm(nzv) = 1 AND
                        norm(u) * norm(nzv) = abs(u * nzv) IMPLIES
                         (EXISTS (cr: real): cr * nzv = u)")
   (("1"
     (skeep)
     (case "u = zero")
     (("1"
       (inst + "0")
       (replace -1)
       (assert)
       (hide -)
       (expand "zero")
       (expand "*")
       (propax))
      ("2"
       (case "norm(u)>0")
       (("1"
         (inst - "1/norm(nzv)*nzv" "1/norm(u)*u")
         (("1"
           (assert)
           (split -)
           (("1"
             (skeep -1)
             (inst + "norm(u)*cr/norm(nzv)")
             (hide -3)
             (case "norm(u)*(cr * (1 / norm(nzv) * nzv)) = norm(u)*(1/norm(u)*u)")
             (("1"
               (assert)
               (case "norm(u)*(1/norm(u)*u) = u")
               (("1"
                 (assert)
                 (case "norm(u) * (cr * (1 / norm(nzv) * nzv)) = norm(u) * cr / norm(nzv) * nzv")
                 (("1" (assert))
                  ("2" (hide-all-but 1) (grind :exclude "norm"))))
                ("2"
                 (hide-all-but 1)
                 (decompose-equality +)
                 (("1" (grind)) ("2" (grind))))))
              ("2" (assert))))
            ("2"
             (rewrite "norm_scal")
             (rewrite "abs_div")
             (expand "abs")
             (assert))
            ("3"
             (rewrite "norm_scal")
             (rewrite "abs_div")
             (expand "abs")
             (assert))
            ("4"
             (rewrite "norm_scal")
             (rewrite "norm_scal")
             (rewrite "abs_div")
             (rewrite "abs_div")
             (assert)
             (case "1 / norm(u) * u * (1 / norm(nzv) * nzv) = (1/norm(u))*(1/norm(nzv))*(u*nzv)")
             (("1"
               (replace -1)
               (hide -1)
               (rewrite "abs_mult")
               (rewrite "abs_mult")
               (rewrite "abs_div")
               (expand "abs" + 1)
               (expand "abs" + 1)
               (expand "abs" + 1)
               (expand "abs" + 1)
               (expand "abs" + 2)
               (expand "abs" + 2)
               (expand "abs" + 2)
               (assert))
              ("2" (hide-all-but 1) (grind))))))
          ("2" (lemma "norm_eq_0") (inst?) (assert))))
        ("2" (lemma "norm_eq_0") (inst?) (assert))))))
    ("2"
     (hide 2)
     (skeep)
     (name "nzvp" "(# x:=nzv`y,y:=-nzv`x #)")
     (case "nzv*nzvp = 0 AND norm(nzvp) = 1")
     (("1"
       (flatten)
       (case "u = (u*nzv)*nzv + (u*nzvp)*nzvp")
       (("1"
         (case "sqv(u) = sq(u*nzv) + sq(u*nzvp)")
         (("1"
           (case "sq(u*nzv) = sqv(u)*sqv(nzv)")
           (("1"
             (replace -1)
             (case "sqv(u) = 1 AND sqv(nzv) = 1")
             (("1"
               (flatten)
               (replace -1)
               (replace -2)
               (assert)
               (lemma "sq_eq_0")
               (inst - "u*nzvp")
               (assert)
               (replace -1)
               (assert)
               (replace -6 +)
               (inst + "u*nzv")
               (hide -)
               (grind))
              ("2"
               (split +)
               (("1"
                 (rewrite "sqrt_eq" + :dir rl)
                 (rewrite "sqrt_sqv_norm"))
                ("2"
                 (rewrite "sqrt_eq" + :dir rl)
                 (rewrite "sqrt_sqv_norm"))))))
            ("2"
             (rewrite "sqrt_eq" 1 :dir rl)
             (rewrite "sqrt_times")
             (rewrite "sqrt_sqv_norm")
             (rewrite "sqrt_sqv_norm")
             (rewrite "sqrt_sq_abs")
             (assert))))
          ("2"
           (name "aac" "sqv(u)")
           (replace -1)
           (replace -2 -1)
           (replace -1 :dir rl)
           (hide -1)
           (case "sqv(nzvp) = 1 AND sqv(nzv) = 1")
           (("1"
             (flatten)
             (mult-by -1 "sq(u*nzvp)")
             (mult-by -2 "sq(u*nzv)")
             (mult-by -4 "(u*nzv)*(u*nzvp)")
             (hide-all-but (-1 -2 -3 1))
             (grind))
            ("2"
             (split +)
             (("1"
               (rewrite "sqrt_eq" 1 :dir rl)
               (rewrite "sqrt_sqv_norm"))
              ("2"
               (rewrite "sqrt_eq" 1 :dir rl)
               (rewrite "sqrt_sqv_norm"))))))))
        ("2"
         (case "NOT FORALL (e1, e2, w: Vect2):
                       e1 /= zero AND e2 /= zero AND e1*e2=0 IMPLIES
                        w = ((w * e1) / sqv(e1)) * e1 + ((w * e2) / sqv(e2)) * e2")
         (("1"
           (hide-all-but 1)
           (skosimp*)
           (lemma "posreal_times_posreal_is_posreal")
           (inst - "sqv(e1!1)" "sqv(e2!1)")
           (("1"
             (case "sqv(e1!1)*sqv(e2!1)*w!1 = (w!1*e1!1*sqv(e2!1))*e1!1 + (w!1*e2!1*sqv(e1!1))*e2!1")
             (("1"
               (decompose-equality 3)
               (("1"
                 (mult-by 1 "sqv(e1!1)*sqv(e2!1)")
                 (grind :exclude "sqv"))
                ("2"
                 (mult-by 1 "sqv(e1!1)*sqv(e2!1)")
                 (grind :exclude "sqv"))))
              ("2" (hide 4) (grind))))
            ("2" (hide 4) (lemma "sqv_eq_0") (inst?) (assert))
            ("3" (lemma "sqv_eq_0") (inst?) (assert))))
          ("2"
           (inst - "nzv" "nzvp" "u")
           (assert)
           (split -)
           (("1"
             (case "sqv(nzv) = 1 AND sqv(nzvp) =1 ")
             (("1" (flatten) (replaces -1) (replaces -1) (assert))
              ("2"
               (split +)
               (("1"
                 (rewrite "sqrt_eq" 1 :dir rl)
                 (rewrite "sqrt_sqv_norm"))
                ("2"
                 (rewrite "sqrt_eq" 1 :dir rl)
                 (rewrite "sqrt_sqv_norm"))))))
            ("2"
             (flatten)
             (replace -1)
             (assert)
             (hide-all-but -3)
             (expand "zero")
             (grind))))
          ("3"
           (hide-all-but 1)
           (skeep)
           (lemma "sqv_eq_0")
           (inst?)
           (assert))
          ("4"
           (hide-all-but 1)
           (skeep)
           (lemma "sqv_eq_0")
           (inst?)
           (assert))))))
      ("2"
       (split +)
       (("1" (hide-all-but 1) (expand "nzvp") (grind))
        ("2" (hide-all-but (-3 1)) (expand "nzvp") (grind))))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqrt_sqv_norm" :dir rl)
   (rewrite "sqv_sq")
   (rewrite "sqv_sq")
   (rewrite "sqv_sq")
   (expand "-")
   (case-replace "sq(u`x - w`x) = sq(u`x - v`x + v`x - w`x)")
   (("1"
     (hide -1)
     (case-replace "sq(u`y - w`y) = sq(u`y - v`y + v`y - w`y)")
     (("1" (hide -1) (lemma "schwarz_cor") (inst - "u-v" "v-w") (grind))
      ("2" (hide 2) (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "norm")
     (expand "sqv")
     (expand "*")
     (case-replace
      "sqrt(u!1`x * u!1`x + u!1`y * u!1`y) >= sqrt(u!1`x * u!1`x)")
     (("1" (rewrite "sq_rew") (rewrite "sqrt_sq_abs"))
      ("2" (hide 2) (rewrite "sqrt_ge"))))
    ("2"
     (expand "norm")
     (expand "sqv")
     (expand "*")
     (case-replace
      "sqrt(u!1`x * u!1`x + u!1`y * u!1`y) >= sqrt(u!1`y * u!1`y)")
     (("1" (rewrite "sq_rew") (rewrite "sq_rew") (rewrite "sqrt_sq_abs"))
      ("2" (hide 2) (rewrite "sqrt_ge"))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: vectors_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (M: posnat, RS: [nat -> real]):
                                                     (FORALL (i: nat): abs(RS(i)) <= M) IMPLIES
                                                      (EXISTS (ns: [nat -> nat], acpr: real):
                                      		  (FORALL (i:nat): ns(i)>i) AND
                                                         (FORALL (epsil: posreal):
                                                            EXISTS (K: posnat):
                                                              FORALL (j: nat):
                                                                j >= K IMPLIES abs(RS(ns(j)) - acpr) < epsil))")
   (("1"
     (skeep)
     (inst-cp - "M" "LAMBDA (i:nat): VS(i)`x")
     (split -)
     (("1"
       (skeep)
       (inst -3 "M" "LAMBDA (i:nat): VS(ns(i))`y")
       (split -)
       (("1"
         (skolem - ("nnss" "acpry"))
         (name "acp" "(# x:=acpr,y:=acpry #)")
         (inst +
          "ns o
                                         nnss"
          "acp")
         (expand "o" +)
         (invoke (case "NOT %1") (! 1 1))
         (("1"
           (hide 2)
           (skeep)
           (inst - "j")
           (inst -4 "nnss(j)")
           (assert))
          ("2"
           (replaces -1)
           (flatten)
           (invoke (case "NOT %1") (! 1 1))
           (("1"
             (hide 2)
             (skeep)
             (inst -3 "epsil/2")
             (inst -5 "epsil/2")
             (skosimp*)
             (inst + "max(K!1,K!2)+1")
             (skeep)
             (inst -4 "j")
             (inst -6 "nnss(j)")
             (assert)
             (inst - "j")
             (assert)
             (name "W" "VS(ns(nnss(j)))")
             (replace -1)
             (assert)
             (name "Ax" "(# x:= W`x-acpr,y:=0 #)")
             (name "Ay" "(# x:=0,y:=W`y-acpry #)")
             (case "NOT W-acp = Ax+Ay")
             (("1"
               (hide-all-but 1)
               (expand "Ax")
               (expand "Ay")
               (expand "-")
               (grind))
              ("2"
               (replaces -1)
               (lemma "norm_add_le")
               (inst?)
               (case "norm(Ax)<epsil/2 AND norm(Ay)<epsil/2")
               (("1" (ground))
                ("2"
                 (hide 2)
                 (split)
                 (("1"
                   (case "norm(Ax) = abs(W`x-acpr)")
                   (("1" (assert))
                    ("2"
                     (hide 2)
                     (rewrite "sq_eq" 1 :dir rl)
                     (rewrite "sq_norm")
                     (expand "Ax" 1)
                     (hide -)
                     (grind))))
                  ("2"
                   (case "norm(Ay) = abs(W`y-acpry)")
                   (("1" (assert))
                    ("2"
                     (hide 2)
                     (rewrite "sq_eq" 1 :dir rl)
                     (rewrite "sq_norm")
                     (expand "Ay" 1)
                     (hide -)
                     (grind))))))))))
            ("2"
             (replace -1)
             (inst - "norm(acp)-M")
             (("1"
               (skosimp*)
               (inst - "K!1")
               (assert)
               (inst -7 "ns(nnss(K!1))")
               (name "W" "VS(ns(nnss(K!1)))")
               (replace -1)
               (hide-all-but (-2 -8 1))
               (lemma "norm_neg")
               (inst - "W-acp")
               (case "-(W-acp) = acp-W")
               (("1"
                 (replaces -1)
                 (assert)
                 (replaces -1 :dir rl)
                 (lemma "norm_add_le")
                 (inst - "acp-W" "W")
                 (assert))
                ("2" (hide-all-but 1) (grind))))
              ("2" (assert))))))))
        ("2"
         (hide 2)
         (skosimp*)
         (inst -3 "ns(i!1)")
         (name "W" "VS(ns(i!1))")
         (replace -1)
         (hide (-1 -2 -3))
         (rewrite "sq_le" 1 :dir rl)
         (rewrite "sq_le" -1 :dir rl)
         (rewrite "sq_norm")
         (expand "sqv")
         (expand "*")
         (typepred "sq(W`y)")
         (grind))))
      ("2"
       (hide (-1 2))
       (skosimp*)
       (inst - "i!1")
       (rewrite "sq_le" 1 :dir rl)
       (rewrite "sq_le" -1 :dir rl)
       (rewrite "sq_norm")
       (typepred "sq(VS(i!1)`x)")
       (grind))))
    ("2"
     (hide 2)
     (skeep)
     (case "EXISTS (acpr:real): FORALL (epsil:posreal,K:nat): EXISTS (j:nat): j>=K AND abs(RS(j)-acpr)<epsil")
     (("1"
       (skeep -1)
       (name "ns"
             "LAMBDA (i:nat): choose({j:nat | j>i+2 AND abs(RS(j)-acpr)<1/(i+2)})")
       (("1"
         (inst + "ns" "acpr")
         (split)
         (("1" (skeep) (assert))
          ("2"
           (skeep)
           (lemma "archimedean")
           (inst - "epsil")
           (skeep)
           (inst + "n+1")
           (skeep)
           (typepred "ns(j)")
           (case "1/(2+j) <1/n")
           (("1" (assert)) ("2" (cross-mult 1) (assert))))))
        ("2"
         (hide 2)
         (skeep)
         (inst - "1/(2+i)" "8+i")
         (skeep)
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst - "j")
         (assert))))
      ("2"
       (hide 2)
       (name "S"
             "LAMBDA (x:real): EXISTS (K:nat): FORALL (i:nat): i>=K IMPLIES RS(i)>=x")
       (case "nonempty?[real](S) AND bounded_above?(S)")
       (("1"
         (flatten)
         (name "acpr" "lub(S)")
         (("1"
           (typepred "acpr")
           (expand "least_upper_bound?")
           (flatten)
           (inst + "acpr")
           (skeep)
           (case "S(acpr-epsil/2)")
           (("1"
             (expand "upper_bound?" -2)
             (inst - "acpr + epsil/2")
             (("1" (assert))
              ("2"
               (expand "S" -1)
               (skolem -1 "K1")
               (expand "S" 1)
               (inst + "K + K1 + 1")
               (skeep)
               (inst - "i")
               (inst + "i")
               (assert)
               (expand "abs" +)
               (lift-if)
               (ground))))
            ("2"
             (hide 2)
             (expand "S" 1)
             (inst - "acpr-epsil/2")
             (assert)
             (expand "upper_bound?" +)
             (skeep)
             (typepred "s")
             (expand "S" -1)
             (skeep)
             (inst + "K!1")
             (skeep)
             (inst - "i")
             (assert))))
          ("2" (propax))))
        ("2"
         (hide 2)
         (split)
         (("1"
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (inst - "-M-1")
           (expand "S" 1)
           (inst + "0")
           (skeep)
           (inst - "i")
           (expand "abs")
           (lift-if)
           (ground))
          ("2"
           (expand "bounded_above?")
           (inst + "M+1")
           (expand "upper_bound?")
           (skeep)
           (typepred "s")
           (expand "S")
           (skosimp*)
           (inst - "K!1")
           (inst - "K!1")
           (assert))))))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (assert)
   (expand "sq")
   (assert)
   (rewrite "sqrt_0"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "dist")
     (expand "sq_dist")
     (rewrite "sq_eq" :dir rl)
     (rewrite "sq_sqrt")
     (rewrite "sq_0")
     (case "sq(p1!1`x - p2!1`x) = 0 AND sq(p1!1`y - p2!1`y) = 0")
     (("1"
       (hide -2)
       (flatten)
       (apply-extensionality 1 :hide? t)
       (("1" (rewrite "sq.sq_eq_0"))
        ("2" (hide -1) (rewrite "sq.sq_eq_0"))))
      ("2" (hide 2) (assert))))
    ("2" (replace -1) (rewrite "dist_eq_args"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "norm")
   (expand "sq_dist")
   (expand "sq")
   (assert)
   (expand "sqv")
   (expand "*")
   (expand "-")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "sq_dist_is_dist_sq")
   (rewrite "sq_dist_is_dist_sq")
   (rewrite "dist_sym"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (case "sqrt(sq(p1!1`x - p2!1`x) + sq(p1!1`y - p2!1`y)) >= sqrt(sq(p1!1`x - p2!1`x))")
   (("1" (rewrite "sqrt_sq_abs"))
    ("2" (hide 2) (rewrite "sqrt_ge") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (case "sqrt(sq(p1!1`x - p2!1`x) + sq(p1!1`y - p2!1`y)) >= sqrt(sq(p1!1`y - p2!1`y))")
   (("1" (rewrite "sqrt_sq_abs"))
    ("2" (hide 2) (rewrite "sqrt_ge") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sq_norm_dist")
   (inst -1 "p0!1" "p1!1" "p2!1")
   (assert)
   (assert)
   (rewrite "dist_norm")
   (rewrite "dist_norm")
   (rewrite "dist_norm"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "dist")
   (expand "sq_dist")
   (case-replace "sq(p0`x - p2`x) = sq(p0`x - p1`x + p1`x - p2`x)")
   (("1"
     (hide -1)
     (case-replace "sq(p0`y - p2`y) = sq(p0`y - p1`y + p1`y - p2`y)")
     (("1"
       (hide -1)
       (lemma "schwarz_cor")
       (inst - "p0-p1" "p1-p2")
       (grind))
      ("2" (hide 2) (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "dist_triangle")
   (inst-cp - "p0" "p1" "p2")
   (inst - "p1" "p0" "p2")
   (expand "abs")
   (lift-if)
   (ground)
   (lemma "dist_sym")
   (inst - "p0" "p1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_segment?")
   (inst + "0")
   (grind)
   (apply-extensionality 1 :hide? t))


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


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "vel_from_tm(p1!1, p2!1, t!1)")
   (replace -1 +)
   (hide -1)
   (replace -1)
   (hide -1)
   (apply-extensionality 1 :hide? t)
   (("1" (grind)) ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "vel_from_tm(p1!1, p2!1, t!1)")
   (apply-extensionality 1 :hide? t)
   (("1" (expand "*" +) (cross-mult 1) (grind))
    ("2" (expand "*" +) (cross-mult 1) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "zero")
   (expand "vel_from_tm")
   (expand "-")
   (apply-extensionality 1 :hide? t)
   (("1" (grind)) ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "vel_from_tm_rew")
   (inst?)
   (assert)
   (replace -1)
   (hide -1)
   (assert)
   (rewrite "norm_scal")
   (rewrite "sq_times")
   (rewrite "dist_norm" :dir rl)
   (expand "dist")
   (rewrite "sq_sqrt")
   (case-replace "sq(abs(1 / t!1)) = 1/sq(t!1)")
   (("1" (assert) (rewrite "sq_dist_sym") (assert))
    ("2" (hide 3) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "vel_from_spd")
   (assert)
   (rewrite "vel_from_tm_rew")
   (("1" (assert)) ("2" (hide 3) (lemma "dist_eq_0") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "^")
   (expand "vel_from_spd")
   (rewrite "dist_norm")
   (assert)
   (rewrite "norm_sym")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "line_from")
   (split +)
   (("1" (inst + "0") (assert))
    ("2"
     (inst + "1")
     (assert)
     (apply-extensionality 1 :hide? t)
     (("1" (grind)) ("2" (grind))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "-")
   (skosimp*)
   (replace -1)
   (hide -1)
   (inst + "-x!1")
   (assert)
   (apply-extensionality :hide? t)
   (("1" (grind)) ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (skosimp*)
   (inst + "1-x!1")
   (replace -1)
   (hide -1)
   (apply-extensionality 1 :hide? t)
   (("1" (grind)) ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "gen_line_tm")
   (expand "on_line?")
   (expand "vel_from_tm")
   (inst + "0")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "gen_line_tm")
   (expand "vel_from_tm")
   (inst + "t!1")
   (assert)
   (apply-extensionality 2 :hide? t)
   (("1" (grind)) ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "gen_line_spd")
   (expand "on_line?")
   (inst + "0")
   (expand "vel_from_spd")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "gen_line_spd")
   (expand "vel_from_spd")
   (inst + "dist(p1!1,p2!1)/s!1")
   (apply-extensionality 2 :hide? t)
   (("1" (grind :exclude "dist")) ("2" (grind :exclude "dist"))
    ("3" (flatten) (rewrite "dist_eq_0"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (flatten)
   (expand "on_line?")
   (expand "vel_from_spd")
   (assert)
   (lift-if)
   (ground)
   (("1" (inst + "0") (assert))
    ("2" (inst?) (assert) (flatten) (rewrite "dist_eq_0"))))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp* :preds? t)
   (expand "vec_from")
   (expand "nz_vector?")
   (flatten)
   (rewrite "sub_eq_zero"))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst + "(LAMBDA p1,p2,t: (1/t)*(p2-p1))")
   (skosimp*)
   (apply-extensionality 1 :hide? t)
   (("1" (grind)) ("2" (grind))))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp* :preds? t)
   (expand "vel_from_tm")
   (lemma "scal_eq_zero")
   (inst?)
   (assert)
   (rewrite "sub_eq_zero"))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: lines_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "vel_from_spd")
   (name-replace "AA" "s!1 / dist(p1!1, p2!1)")
   (lemma "scal_eq_zero")
   (inst?)
   (assert)
   (rewrite "sub_eq_zero"))


proof_type: f_proof
decl_type: formula
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (name "W" "Q!1 - P0!1")
   (assert)
   (factor 1 l)
   (name-replace "tmt" "t!1 - tp!1" "")
   (case-replace "(P0!1 + tp!1 * nzv!1) - Q!1 = tp!1*nzv!1 - W")
   (("1"
     (hide -1)
     (replace -2)
     (hide -2)
     (expand "perp_pt")
     (replace -1)
     (assert)
     (lemma "dot_comm")
     (inst -1 "W" "nzv!1")
     (replace -1)
     (rewrite "dot_sub_right")
     (("1" (assert))
      ("2"
       (hide-all-but (-2 1))
       (flatten)
       (rewrite "dot_sq_norm")
       (lemma "sq_eq_0")
       (inst?)
       (assert))))
    ("2" (hide -2 2) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sq_norm_dist")
   (inst -1 "Q!1" "(P0!1 + tp!1 * nzv!1)" "(P0!1 + t!1 * nzv!1)")
   (assert)
   (name "DEL" "(t!1-tp!1)*nzv!1")
   (case-replace "(P0!1 + tp!1 * nzv!1) - (P0!1 + t!1 * nzv!1) = -DEL")
   (("1"
     (name "C" "(P0!1 + tp!1 * nzv!1) - Q!1")
     (replace -1)
     (lemma "perp_is_normal")
     (inst -1 "P0!1" "Q!1" "nzv!1" "t!1" "tp!1")
     (assert)
     (case-replace "(C * -DEL) = 0")
     (("1" (assert) (lemma "sq_ge") (inst?) (assert))
      ("2" (hide-all-but (-1 -2 -3 1)) (grind))))
    ("2" (hide-all-but (-1 1)) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (lemma "sq_norm_dist")
   (inst -1 "Q!1" "(P0!1 + tp!1 * nzv!1)" "(P0!1 + t!1 * nzv!1)")
   (assert)
   (name "DEL" "(t!1-tp!1)*nzv!1")
   (replace -1)
   (name "C" "(P0!1 + tp!1 * nzv!1) - Q!1")
   (replace -1)
   (case-replace "(P0!1 + tp!1 * nzv!1) - (P0!1 + t!1 * nzv!1) = -DEL")
   (("1"
     (lemma "perp_is_normal")
     (inst -1 "P0!1" "Q!1" "nzv!1" "t!1" "tp!1")
     (assert)
     (factor -1 l)
     (replace -3)
     (case-replace "(C * -DEL) = 0")
     (("1" (assert) (lemma "sq_ge") (inst?) (assert))
      ("2" (hide-all-but (-1 -4 1)) (grind))))
    ("2" (hide-all-but (-2 1)) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (lemma "sq_norm_dist")
   (inst -1 "Q!1" "(P0!1 + tp!1 * nzv!1)" "(P0!1 + t!1 * nzv!1)")
   (assert)
   (lemma "perp_is_normal")
   (inst -1 "P0!1" "Q!1" "nzv!1" "t!1" "tp!1")
   (assert)
   (factor -1 l)
   (name "DEL" "(t!1 - tp!1) * nzv!1")
   (name "C" "(P0!1 + tp!1 * nzv!1) - Q!1")
   (replace -1)
   (replace -2)
   (case-replace "(P0!1 + tp!1 * nzv!1) - (P0!1 + t!1 * nzv!1) = -DEL")
   (("1"
     (hide -1)
     (case-replace "C*-DEL = 0")
     (("1" (assert)) ("2" (hide-all-but (-1 -2 -3 1)) (grind))))
    ("2" (hide-all-but (-1 -2 1)) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (skosimp*)
   (rewrite "dist_norm")
   (expand "dist")
   (lemma "perp_is_min")
   (assert)
   (inst -1 "p(L!1)" "q!1" "v(L!1)" "x!1" "perp_pt(q!1, p(L!1), v(L!1))")
   (assert)
   (replace -2 * rl)
   (rewrite "norm_sym")
   (rewrite "dist_norm")
   (case-replace "perp_pt(q!1,p(L!1), v(L!1))  = perp_pt(q!1, L!1)")
   (hide 2)
   (expand "perp_pt")
   (propax))


proof_type: f_proof
decl_type: formula
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (hide 1)
   (expand "perpendicular?")
   (expand "orthogonal?")
   (expand "line_from")
   (expand "vec_from")
   (assert)
   (auto-rewrite "dot_add_right")
   (auto-rewrite "dot_add_left")
   (auto-rewrite "dot_sub_right")
   (assert)
   (auto-rewrite "dot_sub_left")
   (expand "perp_pt")
   (assert)
   (field 1)
   (("1" (rewrite "dot_comm") (assert)) ("2" (rewrite "dot_comm"))))


proof_type: j_proof
decl_type: tcc
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "nzv")
   (lemma "nzv_xy_neq_0")
   (inst?)
   (assert)
   (hide -2)
   (lemma "nzv_xy_neq_0")
   (inst -1 "perpL(nzv)")
   (assert)
   (hide -2)
   (grind))


proof_type: j_proof
decl_type: tcc
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "nzv")
   (lemma "nzv_xy_neq_0")
   (inst?)
   (assert)
   (hide -2)
   (lemma "nzv_xy_neq_0")
   (inst -1 "perpR(nzv)")
   (assert)
   (hide -2)
   (grind))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: perpendicular_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (mult-cases -1)
   (rewrite "dot_sq_norm")
   (lemma "norm_eq_0")
   (inst?)
   (assert)
   (lemma "sq_eq_0")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "posreal_times_posreal_is_posreal")
   (inst - "sqv(e1!1)" "sqv(e2!1)")
   (("1"
     (expand "orthogonal?")
     (case "sqv(e1!1)*sqv(e2!1)*w!1 = (w!1*e1!1*sqv(e2!1))*e1!1 + (w!1*e2!1*sqv(e1!1))*e2!1")
     (("1"
       (decompose-equality 3)
       (("1" (mult-by 1 "sqv(e1!1)*sqv(e2!1)") (grind :exclude "sqv"))
        ("2" (mult-by 1 "sqv(e1!1)*sqv(e2!1)") (grind :exclude "sqv"))))
      ("2" (hide 4) (grind))))
    ("2" (hide 4) (lemma "sqv_eq_0") (inst?) (assert))
    ("3" (lemma "sqv_eq_0") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "orthonormal?")
   (flatten)
   (lemma "orthogonal_basis")
   (inst - "e1!1" "e2!1" "w!1")
   (assert)
   (case-replace "sqv(e1!1) = 1")
   (("1"
     (case-replace "sqv(e2!1) = 1")
     (("1" (assert))
      ("2"
       (hide -2 -3 4)
       (expand "norm")
       (lemma "sqrt_eq")
       (inst?)
       (assert))))
    ("2"
     (hide -1 -2 -4 4)
     (expand "norm")
     (lemma "sqrt_eq")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "orthogonal?(w,e1)")
   (("1"
     (lemma "orthogonal_basis")
     (inst - "w" "e1" "e2")
     (assert)
     (copy -4)
     (case "e2*w = 0")
     (("1"
       (replace -3 -2)
       (replace -1)
       (assert)
       (inst + "(e2*e1)/sqv(e1)")
       (assert))
      ("2" (hide-all-but (-5 1)) (grind))))
    ("2" (expand "orthogonal?") (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (replace -2)
   (hide -2)
   (rewrite "sqv_add")
   (expand "orthonormal?")
   (flatten)
   (expand "orthogonal?")
   (replace -1)
   (assert)
   (rewrite "sqv_scal")
   (rewrite "sqv_scal")
   (case-replace "sqv(e1) = 1")
   (("1"
     (case-replace "sqv(e2) = 1")
     (("1" (assert))
      ("2"
       (hide -1 -2 4)
       (expand "norm")
       (lemma "sqrt_eq")
       (inst?)
       (assert))))
    ("2"
     (hide -1 -3 4)
     (expand "norm")
     (lemma "sqrt_eq")
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "orthonormal?")
   (flatten)
   (expand "orthogonal?")
   (assert)
   (lemma "dot_add_left")
   (inst - "(c!1 * e1!1 + d!1 * e2!1)" "a!1 * e1!1" "b!1 * e2!1")
   (hide 2)
   (rewrite "add_dot_add")
   (hide -1)
   (replace -1)
   (assert)
   (case-replace "e1!1 * e1!1 = 1")
   (("1"
     (case-replace "e2!1 * e2!1 = 1")
     (("1" (assert) (hide -1 -2) (lemma "dot_comm") (inst?) (assert))
      ("2"
       (hide -1 -2 3)
       (expand "norm")
       (expand "sqv")
       (lemma "sqrt_eq")
       (inst?)
       (("1" (assert)) ("2" (assert))))))
    ("2"
     (hide -1 -3 3)
     (expand "norm")
     (expand "sqv")
     (lemma "sqrt_eq")
     (inst?)
     (("1" (assert)) ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (assert)
   (rewrite "perpR_add")
   (rewrite "perpR_scal")
   (rewrite "perpR_scal")
   (assert)
   (grind))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (skoletin 1)
   (skoletin 1)
   (expand "^")
   (expand "perpR")
   (expand "orthonormal?")
   (typepred "v!1")
   (flatten)
   (split +)
   (("1" (expand "orthogonal?") (grind))
    ("2" (flatten) (replace -1) (assert))
    ("3" (replace -2) (rewrite "norm_scal") (expand "abs") (assert))
    ("4" (flatten) (assert))
    ("5"
     (replace -1)
     (replace -2)
     (hide -)
     (lemma "norm_scal")
     (inst - "1 / norm(v!1)" "perpR(v!1)")
     (case-replace "norm(perpR(v!1)) = norm(v!1)")
     (("1"
       (hide -1)
       (expand "perpR")
       (expand "*")
       (assert)
       (expand "abs")
       (assert))
      ("2"
       (hide -1 2)
       (expand "norm")
       (lemma "sqrt_eq")
       (inst?)
       (flatten)
       (hide -1)
       (split -1)
       (("1" (propax)) ("2" (hide 2) (grind))))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (replace -2)
   (expand "sqv")
   (rewrite "dot_add_left")
   (rewrite "dot_add_right")
   (expand "orthogonal?")
   (case "e2*e1 = 0")
   (("1" (grind)) ("2" (hide-all-but (-1 1)) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "orthogonal_basis_sqv")
   (inst?)
   (assert)
   (split -)
   (("1"
     (case "sqv(e1) = 1 AND sqv(e2) = 1")
     (("1" (flatten) (assert))
      ("2"
       (expand "orthonormal?")
       (flatten)
       (lemma "sqrt_sqv_norm")
       (inst-cp - "e1")
       (inst - "e2")
       (assert))))
    ("2" (expand "orthonormal?") (flatten))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "orthogonal_basis_sqv")
   (inst?)
   (assert)
   (lemma "sqrt_sqv_norm")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "orthonormal_basis_sqv")
   (inst?)
   (assert)
   (lemma "sqrt_sqv_norm")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "orthogonal_basis_sqv")
   (inst?)
   (assert)
   (lemma "sq_ge")
   (inst?)
   (assert)
   (hide 2)
   (rewrite "sq_times")
   (case "FORALL (pz: Vect2): sq(norm(pz)) = sqv(pz)")
   (("1"
     (inst-cp - "w")
     (inst - "e1")
     (replace -1)
     (replace -2)
     (assert))
    ("2"
     (skeep)
     (lemma "sqrt_sqv_norm")
     (inst - "pz")
     (replace -1 :dir rl)
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "orthogonal_basis_norm_ge")
   (inst?)
   (assert)
   (split -)
   (("1" (expand "orthonormal?") (flatten) (assert))
    ("2"
     (expand "orthogonal?")
     (expand "orthonormal?")
     (flatten)
     (expand "orthogonal?")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "orthogonal?")
   (mult-by -1 "(a1*b2 + b1*a2)")
   (replaces -2)
   (replaces -2)
   (grind))


proof_type: f_proof
decl_type: formula
library: vectors
theory: basis_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "orthogonal_basis_dot")
   (inst - "a1" "a2" "b1" "b2" "e1" "e2" "w1" "w2")
   (assert)
   (split -)
   (("1"
     (case "sqv(e1) = 1 AND sqv(e2) = 1")
     (("1" (flatten) (assert))
      ("2"
       (hide-all-but (-2 1))
       (expand "orthonormal?")
       (assert)
       (case "FORALL (egrtzp:Vect2): norm(egrtzp) = 1 IMPLIES sqv(egrtzp) = 1")
       (("1" (flatten) (inst-cp - "e1") (inst - "e2") (assert))
        ("2"
         (hide-all-but 1)
         (skeep)
         (rewrite "sq_eq" -1 :dir rl)
         (rewrite "sq_norm"))))))
    ("2" (expand "orthonormal?") (ground))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: det_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sq_le")
   (inst?)
   (("1"
     (assert)
     (hide 2)
     (rewrite "sq_det")
     (rewrite "sq_times")
     (rewrite "sq_norm")
     (rewrite "sq_norm")
     (assert))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: det_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "sq_eq")
   (inst -1 "det(nzu,nzv)" "0")
   (("1" (assert) (rewrite "sq_det") (replaces -3) (assert))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (expand "linear_transform?")
   (inst - "u" "zero")
   (inst - "a" "0")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (expand "linear_transform?")
   (inst - "u" "v")
   (inst - "1" "1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (expand "linear_transform?")
   (inst - "u" "v")
   (inst - "1" "-1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "linear_transform?")
   (ground)
   (("1" (skeep) (inst - "u" "v") (inst - "1" "1") (assert))
    ("2" (skeep) (inst - "u" "zero") (inst - "a" "0") (assert))
    ("3"
     (skeep)
     (skeep)
     (inst - "a*u" "b*v")
     (inst-cp - "u" "a")
     (inst - "v" "b")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (ground)
   (("1"
     (skeep)
     (skeep)
     (expand "linear_transform?")
     (inst - "u" "v")
     (inst - "a" "1")
     (assert))
    ("2"
     (copy -1)
     (lemma "linear_transform_rew")
     (inst - "L")
     (assert)
     (hide 2)
     (split)
     (("1" (skeep) (inst - "u" "v") (inst - "1") (assert))
      ("2"
       (skeep)
       (inst - "u" "zero")
       (inst - "a")
       (assert)
       (inst - "zero" "zero")
       (inst - "1")
       (assert)
       (case "L(zero) = zero")
       (("1" (replace -1) (assert))
        ("2"
         (hide-all-but (-2 1))
         (expand "+")
         (decompose-equality))))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "linear_transform_alt_left")
   (inst?)
   (replace -1)
   (hide -1)
   (ground)
   (("1" (skeep) (inst - "v" "u") (skeep) (inst - "a") (grind))
    ("2" (skeep) (inst - "v" "u") (skeep) (inst - "a") (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (decompose-equality 3)
   (lemma "orthogonal_basis")
   (inst - "u" "v" "x!1")
   (assert)
   (replace -1)
   (lemma "linear_transform_add")
   (inst?)
   (assert)
   (inst?)
   (replace -1)
   (hide -1)
   (lemma "linear_transform_scal")
   (inst - "L")
   (assert)
   (inst - "u" "((x!1 * u) / sqv(u))")
   (lemma "linear_transform_scal")
   (inst - "L")
   (assert)
   (inst - "v" "((x!1 * v) / sqv(v))")
   (lemma "linear_transform_add")
   (inst - "J")
   (assert)
   (inst - "((x!1 * u) / sqv(u)) * u" "((x!1 * v) / sqv(v)) * v")
   (replace -1)
   (lemma "linear_transform_scal")
   (inst - "J")
   (assert)
   (copy -1)
   (inst - "v" "((x!1 * v) / sqv(v))")
   (inst - "u" "((x!1 * u) / sqv(u))")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "linear_functional?")
   (skeep)
   (inst - "u" "zero")
   (inst - "a" "0")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "linear_functional?")
   (skeep)
   (inst - "u" "v")
   (inst - "1" "1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "linear_functional?")
   (skeep)
   (inst - "u" "v")
   (inst - "1" "-1")
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "F(iv) /= 0")
   (("1"
     (name "const1" "F(jv)/F(iv)")
     (("1"
       (name "constvect" "const1*iv-jv")
       (inst + "constvect")
       (split)
       (("1"
         (hide-all-but (-1 1))
         (flatten)
         (replace -1)
         (hide -1)
         (expand "jv")
         (expand "iv")
         (expand "zero")
         (grind))
        ("2"
         (replace -1 + rl)
         (expand "linear_functional?")
         (inst - "iv" "jv" "const1" "-1")
         (assert))))
      ("2" (propax))))
    ("2"
     (flatten)
     (inst + "iv")
     (assert)
     (expand "iv")
     (expand "zero")
     (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "wwww" "(F(iv), F(jv))")
   (inst + "wwww")
   (decompose-equality 1)
   (expand "*")
   (replace -1 + rl)
   (assert)
   (expand "linear_functional?")
   (inst - "iv" "jv")
   (inst - "x!1`x" "x!1`y")
   (case "x!1 = x!1`x * iv + x!1`y * jv")
   (("1" (assert))
    ("2"
     (hide-all-but 1)
     (expand "iv")
     (expand "jv")
     (expand "*")
     (expand "+")
     (decompose-equality 1))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "linear_functional?")
   (ground)
   (("1" (skeep) (inst - "u" "v") (inst - "1" "1") (assert))
    ("2" (skeep) (inst - "u" "zero") (inst - "a" "0") (assert))
    ("3"
     (skeep)
     (skeep)
     (inst - "a*u" "b*v")
     (inst-cp - "u" "a")
     (inst - "v" "b")
     (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (ground)
   (("1"
     (skeep)
     (skeep)
     (expand "linear_functional?")
     (inst - "u" "v")
     (inst - "a" "1")
     (assert))
    ("2"
     (copy -1)
     (lemma "linear_functional_rew")
     (inst - "F")
     (assert)
     (hide 2)
     (split)
     (("1" (skeep) (inst - "u" "v") (inst - "1") (assert))
      ("2"
       (skeep)
       (inst - "u" "zero")
       (inst - "a")
       (assert)
       (inst - "zero" "zero")
       (inst - "1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "linear_functional_alt_left")
   (inst?)
   (replace -1)
   (hide -1)
   (ground)
   (("1" (skeep) (inst - "v" "u") (skeep) (inst - "a") (grind))
    ("2" (skeep) (inst - "v" "u") (skeep) (inst - "a") (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (decompose-equality 3)
   (lemma "orthogonal_basis")
   (inst - "u" "v" "x!1")
   (assert)
   (replace -1)
   (lemma "linear_functional_add")
   (inst?)
   (assert)
   (inst?)
   (replace -1)
   (hide -1)
   (lemma "linear_functional_scal")
   (inst - "F")
   (assert)
   (inst - "u" "((x!1 * u) / sqv(u))")
   (lemma "linear_functional_scal")
   (inst - "F")
   (assert)
   (inst - "v" "((x!1 * v) / sqv(v))")
   (lemma "linear_functional_add")
   (inst - "G")
   (assert)
   (inst - "((x!1 * u) / sqv(u)) * u" "((x!1 * v) / sqv(v)) * v")
   (replace -1)
   (lemma "linear_functional_scal")
   (inst - "G")
   (assert)
   (copy -1)
   (inst - "v" "((x!1 * v) / sqv(v))")
   (inst - "u" "((x!1 * u) / sqv(u))")
   (replace -1)
   (replace -2)
   (replace -4)
   (replace -5)
   (assert))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "rzk" "F(perpR(u))/sqv(u)")
   (("1"
     (inst + "rzk")
     (lemma "linear_functional_perp_unique")
     (inst - "F" "(LAMBDA (v: Vector): rzk * det(v, u))" "u" "perpR(u)")
     (assert)
     (ground)
     (("1"
       (hide-all-but (-1 1))
       (expand "zero")
       (expand "perpR")
       (flatten)
       (decompose-equality))
      ("2"
       (hide-all-but 1)
       (expand "linear_functional?")
       (skosimp*)
       (grind))
      ("3" (hide-all-but 1) (grind))
      ("4"
       (replace -1 + rl)
       (lemma "det_perpR")
       (inst - "perpR(u)" "u")
       (replace -1)
       (lemma "sqv_perpR")
       (inst?)
       (expand "sqv" -1 1)
       (replace -1)
       (assert))))
    ("2" (lemma "sqv_eq_0") (inst - "u") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: linear_transformations_2D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (label "lfF" -1)
   (label "lfG" -2)
   (label "FGu" -3)
   (label "fv" -4)
   (label "gv" -5)
   (lemma "linear_functional_is_perp_dot")
   (inst-cp - "F" "v")
   (inst - "G" "v")
   (assert)
   (skosimp*)
   (replace -1)
   (replace -2)
   (assert)
   (rewrite "det_perpR")
   (rewrite "det_perpR")
   (name "const3" "u*perpR(v)")
   (replace -1)
   (name "const4" "w!1*perpR(v)")
   (replace -1)
   (hide-all-but ("FGu" 2))
   (case-replace "const3*const3 = sq(const3)")
   (("1"
     (case-replace "const4*const4 = sq(const4)")
     (("1"
       (hide -1)
       (hide -1)
       (case "rzk!1*rzk!2 > 0")
       (("1" (div-by 1 "sq(const4)") (assert))
        ("2" (div-by -1 "sq(const3)") (assert))))
      ("2" (expand "sq") (propax))))
    ("2" (expand "sq") (propax))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: ECEF
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skoletin 1)
   (name "theta" "pi/2-lat")
   (name "phi" "pi-lon")
   (name "xx" "r*sin(theta)*cos(phi)")
   (name "yy" "r*sin(theta)*sin(phi)")
   (name "zz" "r*cos(theta)")
   (case "vv = (xx,yy,zz)")
   (("1"
     (case "sq(xx) + sq(yy) = sq(r*sin(theta))")
     (("1"
       (case "sqv(vv) = sq(r)")
       (("1"
         (hide-all-but (-1 1))
         (lemma "sqrt_eq")
         (inst?)
         (assert)
         (rewrite "sqrt_sqv_norm"))
        ("2"
         (hide 2)
         (case "sqv(vv) = sq(xx) + sq(yy) + sq(zz)")
         (("1"
           (replace -1)
           (hide -1)
           (replace -1)
           (hide -1)
           (replace -2 :dir rl)
           (hide-all-but 1)
           (lemma "sin2_cos2")
           (inst - "theta")
           (mult-by -1 "sq(r)")
           (grind))
          ("2" (replace -2 +) (hide-all-but 1) (grind))))))
      ("2"
       (hide-all-but 1)
       (expand "xx")
       (expand "yy")
       (lemma "sin2_cos2")
       (inst - "phi")
       (mult-by -1 "sq(r*sin(theta))")
       (grind))))
    ("2"
     (hide-all-but 1)
     (expand "vv")
     (expand "spherical2xyz")
     (expand "xx")
     (expand "yy")
     (expand "zz")
     (expand "theta")
     (expand "phi")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: ECEF
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "theta" "pi/2-lat")
   (name "phi" "pi-lon")
   (name "xx" "r*sin(theta)*cos(phi)")
   (name "yy" "r*sin(theta)*sin(phi)")
   (name "zz" "r*cos(theta)")
   (replace -4)
   (replace -5)
   (assert)
   (replace -1)
   (replace -3)
   (replace -2)
   (case "sq(xx) + sq(yy) + sq(zz) = sq(r)")
   (("1"
     (case "NOT (xx=0 AND yy = 0 AND zz=0)")
     (("1" (hide-all-but (-7 1)) (expand "zero") (grind))
      ("2" (flatten) (replace -1) (replace -2) (replace -3) (assert))))
    ("2"
     (case "sq(xx) + sq(yy) = sq(r*sin(theta))")
     (("1"
       (replace -1)
       (lemma "sin2_cos2")
       (inst - "theta")
       (mult-by -1 "sq(r)")
       (expand "zz" +)
       (hide-all-but (-1 1))
       (grind))
      ("2"
       (hide-all-but 1)
       (expand "xx")
       (expand "yy")
       (lemma "sin2_cos2")
       (inst - "phi")
       (mult-by -1 "sq(r*sin(theta))")
       (grind))))))


proof_type: t_proof
decl_type: tcc
library: vectors
theory: ECEF
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (name "theta" "pi/2-lat")
   (name "phi" "pi-lon")
   (name "xx" "r*sin(theta)*cos(phi)")
   (name "yy" "r*sin(theta)*sin(phi)")
   (name "zz" "r*cos(theta)")
   (replace -4)
   (replace -5)
   (assert)
   (replace -1)
   (replace -3)
   (replace -2)
   (case "sq(xx) + sq(yy) + sq(zz) = sq(r)")
   (("1"
     (case "NOT (xx=0 AND yy = 0 AND zz=0)")
     (("1" (hide-all-but (-7 1)) (expand "zero") (propax))
      ("2" (flatten) (replace -1) (replace -2) (replace -3) (assert))))
    ("2"
     (case "sq(xx) + sq(yy) = sq(r*sin(theta))")
     (("1"
       (replace -1)
       (lemma "sin2_cos2")
       (inst - "theta")
       (mult-by -1 "sq(r)")
       (expand "zz" +)
       (hide-all-but (-1 1))
       (grind))
      ("2"
       (hide-all-but 1)
       (expand "xx")
       (expand "yy")
       (lemma "sin2_cos2")
       (inst - "phi")
       (mult-by -1 "sq(r*sin(theta))")
       (grind))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: cross_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "linearly_dependent?")
   (expand "zero")
   (expand "cross")
   (expand "+ ")
   (expand "*")
   (split +)
   (("1"
     (flatten)
     (skosimp*)
     (move-terms -2 l 2)
     (move-terms -3 l 2)
     (move-terms -4 l 2)
     (assert)
     (split -1)
     (("1"
       (flatten)
       (isolate-mult -1 l 2)
       (isolate-mult -3 l 2)
       (isolate-mult -5 l 2)
       (flatten)
       (replaces -)
       (assert))
      ("2"
       (flatten)
       (isolate-mult -1 r 3)
       (isolate-mult -3 r 3)
       (isolate-mult -5 r 3)
       (flatten)
       (assert)
       (prop)
       (("1" (replaces - :dir rl) (field 1))
        ("2"
         (replace -1 + rl)
         (replace -3 + rl)
         (move-terms 1 l 2)
         (cross-mult 1))
        ("3" (replaces - :dir rl) (field 1))))))
    ("2"
     (flatten)
     (typepred "nzu")
     (rewrite "nzv_xyz_neq_0")
     (typepred "nzv")
     (rewrite "nzv_xyz_neq_0")
     (case-replace "nzu`z = 0")
     (("1"
       (case-replace "nzu`y = 0")
       (("1"
         (case-replace "nzv`z = 0")
         (("1"
           (case-replace "nzv`y = 0")
           (("1" (inst + "nzv`x" "-nzu`x") (assert)) ("2" (assert))))
          ("2" (assert))))
        ("2"
         (case-replace "nzu`x = 0")
         (("1" (inst + "nzv`y" "-nzu`y") (assert))
          ("2"
           (case-replace "nzv`z = 0")
           (("1"
             (case-replace "nzv`x = 0")
             (("1" (assert) (mult-cases -8))
              ("2" (inst + "nzv`y" "-nzu`y") (assert))))
            ("2" (assert))))))))
      ("2"
       (case-replace "nzv`z = 0")
       (("1" (inst + "-nzv`z" "nzu`z") (assert))
        ("2" (inst + "-nzv`z" "nzu`z") (assert))))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "dist")
     (expand "sq_dist")
     (rewrite "sq_eq" :dir rl)
     (rewrite "sq_sqrt")
     (case "sq(p1!1`x - p2!1`x) = 0 AND sq(p1!1`y - p2!1`y) = 0 AND sq(p1!1`z - p2!1`z) = 0")
     (("1"
       (flatten)
       (hide -4)
       (apply-extensionality 1 :hide? t)
       (("1" (rewrite "sq.sq_eq_0"))
        ("2" (hide -1) (rewrite "sq.sq_eq_0"))
        ("3" (hide -1 -2) (rewrite "sq.sq_eq_0"))))
      ("2" (assert))))
    ("2" (assert) (replace -1) (rewrite "dist_eq_args"))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (case "sqrt(sq(p1!1`x - p2!1`x) + sq(p1!1`y - p2!1`y)+ sq(p1!1`z - p2!1`z)) >= sqrt(sq(p1!1`x - p2!1`x))")
   (("1" (rewrite "sqrt_sq_abs"))
    ("2" (hide 2) (rewrite "sqrt_ge") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (case "sqrt(sq(p1!1`x - p2!1`x) + sq(p1!1`y - p2!1`y) + sq(p1!1`z - p2!1`z)) >= sqrt(sq(p1!1`y - p2!1`y))")
   (("1" (rewrite "sqrt_sq_abs"))
    ("2" (hide 2) (rewrite "sqrt_ge") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dist")
   (expand "sq_dist")
   (case "sqrt(sq(p1!1`x - p2!1`x) + sq(p1!1`y - p2!1`y)   + sq(p1!1`z - p2!1`z)) >= sqrt(sq(p1!1`z - p2!1`z))")
   (("1" (rewrite "sqrt_sq_abs"))
    ("2" (hide 2) (rewrite "sqrt_ge") (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: distance_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "dist")
   (expand "sq_dist")
   (case-replace "sq(p0`x - p2`x) = sq(p0`x - p1`x + p1`x - p2`x)")
   (("1"
     (hide -1)
     (case-replace "sq(p0`y - p2`y) = sq(p0`y - p1`y + p1`y - p2`y)")
     (("1"
       (hide -1)
       (case-replace "sq(p0`z - p2`z) = sq(p0`z - p1`z + p1`z - p2`z)")
       (("1" (lemma "schwarz_cor") (inst - "p0-p1" "p1-p2") (grind))
        ("2" (hide 2) (assert))))
      ("2" (assert))))
    ("2" (hide 2) (assert))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "vel_from_tm(p1!1, p2!1, t!1)")
   (apply-extensionality 1 :hide? t)
   (("1" (expand "*" +) (cross-mult 1) (grind))
    ("2" (expand "*" +) (cross-mult 1) (grind)) ("3" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "vel_from_tm_rew")
   (inst?)
   (replace -1)
   (hide -1)
   (assert)
   (rewrite "norm_scal")
   (rewrite "sq_times")
   (rewrite "dist_norm" :dir rl)
   (expand "dist")
   (rewrite "sq_sqrt")
   (case-replace "sq(abs(1 / t!1)) = 1/sq(t!1)")
   (("1" (assert) (rewrite "sq_dist_sym") (assert))
    ("2" (hide 2) (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "line_from")
   (split +)
   (("1" (inst + "0") (assert))
    ("2"
     (inst + "1")
     (assert)
     (apply-extensionality 1 :hide? t)
     (("1" (grind)) ("2" (grind)) ("3" (grind))))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "-")
   (skosimp*)
   (replace -1)
   (hide -1)
   (inst + "-x!1")
   (assert)
   (apply-extensionality :hide? t)
   (("1" (grind)) ("2" (grind)) ("3" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (skosimp*)
   (inst + "1-x!1")
   (replace -1)
   (hide -1)
   (apply-extensionality 1 :hide? t)
   (("1" (grind)) ("2" (grind)) ("3" (grind))))


proof_type: f_proof
decl_type: formula
library: vectors
theory: lines_3D
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "on_line?")
   (expand "gen_line_tm")
   (expand "vel_from_tm")
   (inst + "t!1")
   (assert)
   (apply-extensionality 2 :hide? t)
   (("1" (grind)) ("2" (grind)) ("3" (grind))))


