# Proofs

proof_type: f_proof
decl_type: formula
library: analysis
theory: riesz_hahn_banach
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (LC: C_Bounded_Linear_Operator): LET ContExt = (# space := continuous_on_int?[a,b], Lop := LC #) IN
                                                                                                                                               EXISTS (OEE: Op_Extension(ContExt)): OEE`space = bounded_on_int?[a,b] AND
                                                                                                                                                 op_norm[a, b, (OEE`space)](OEE`Lop) =
                                                                                                                                                  op_norm[a, b, (ContExt`space)](ContExt`Lop)
                                                                                                                                                  AND (FORALL (f: Continuous_Function[a, b]): OEE`Lop(f) = ContExt`Lop(f))")
   (("1"
     (skeep)
     (inst - "LC")
     (name "ContExt"
           "(# space := continuous_on_int?[a, b], Lop := LC #)")
     (replace -1)
     (assert)
     (skeep -2)
     (label "OEEspace" -2)
     (inst + "OEE`Lop")
     (("1"
       (split +)
       (("1"
         (case "op_norm[a, b, ((OEE`space))](OEE`Lop) = op_norm[a, b, (bounded_on_int?[a, b])](OEE`Lop)")
         (("1"
           (case "op_norm[a, b, ((ContExt`space))](ContExt`Lop) = op_norm[a, b, (continuous_on_int?[a, b])](LC)")
           (("1" (assert))
            ("2"
             (hide 2)
             (hide -1)
             (hide -3)
             (name "CEnorm"
                   "op_norm[a, b, ((ContExt`space))](ContExt`Lop)")
             (replace -1)
             (name "LCnorm"
                   "op_norm[a, b, (continuous_on_int?[a, b])](LC)")
             (replace -1)
             (typepred "CEnorm")
             (case "CEnorm < LCnorm")
             (("1"
               (typepred "LCnorm")
               (inst -3 "CEnorm")
               (assert)
               (skosimp*)
               (typepred "CEnorm")
               (inst -2 "f!1")
               (assert))
              ("2"
               (expand "ContExt" -2)
               (assert)
               (typepred "CEnorm")
               (inst -3 "LCnorm")
               (assert)
               (skosimp*)
               (typepred "LCnorm")
               (inst - "f!1")
               (assert))))
            ("3"
             (expand "ContExt")
             (assert)
             (expand "fullset" +)
             (expand "extend" +)
             (expand "ContExt" +)
             (assert)
             (lemma "C_Bounded_Linear_Operator_TCC1")
             (expand "extend" -1)
             (expand "fullset" -1)
             (propax))))
          ("2"
           (hide 2)
           (name "OEnorm" "op_norm[a, b, ((OEE`space))](OEE`Lop)")
           (replace -1)
           (name "OELnorm"
                 "op_norm[a, b, (bounded_on_int?[a, b])](OEE`Lop)")
           (replace -1)
           (case "OEnorm < OELnorm")
           (("1"
             (typepred "OELnorm")
             (inst -3 "OEnorm")
             (assert)
             (skosimp*)
             (typepred "OEnorm")
             (inst - "f!1")
             (assert))
            ("2"
             (typepred "OEnorm")
             (inst -3 "OELnorm")
             (assert)
             (skosimp*)
             (typepred "OELnorm")
             (inst - "f!1")
             (assert))))
          ("3"
           (typepred "OEE`space")
           (expand "extend" +)
           (expand "fullset" +)
           (case "OEE`space = (LAMBDA (t: [INTab->real]):
                                                                                                                                                                                                                                                                              IF ((OEE`space))(t) THEN TRUE ELSE FALSE ENDIF)")
           (("1" (assert))
            ("2" (decompose-equality +) (lift-if) (propax))))))
        ("2" (skosimp*) (inst - "f!1") (expand "ContExt") (propax))))
      ("2"
       (split)
       (("1" (skosimp*) (replace "OEEspace" +) (ground))
        ("2"
         (typepred "OEE`Lop")
         (expand "bounded_linear_operator?")
         (ground)
         (("1"
           (expand "bounded_op?")
           (skosimp*)
           (inst + "M!1")
           (skosimp*)
           (inst - "f!1"))
          ("2"
           (expand "linear_op?")
           (ground)
           (("1" (expand "additive_op?") (skosimp*) (inst - "f!1" "g!1"))
            ("2"
             (expand "const_inv_op?")
             (skosimp*)
             (inst - "f!1" "c!1"))))))))))
    ("2"
     (hide 2)
     (skeep)
     (name "ContExt"
           "(# space := continuous_on_int?[a, b], Lop := LC #)")
     (replace -1)
     (assert)
     (label "ContExtname" -1)
     (lemma "zorn[Op_Extension(ContExt),le(ContExt)]")
     (("1"
       (split -)
       (("1"
         (skolem -1 "OEE")
         (case "OEE`space = bounded_on_int?[a,b]")
         (("1"
           (label "OEEspace" -1)
           (label "OEEmax" -2)
           (typepred "OEE")
           (expand "<=" -1)
           (flatten)
           (label "CEOEEsubset" -1)
           (label "opextends" -2)
           (label "normseq" -3)
           (inst + "OEE")
           (assert)
           (skosimp*)
           (inst - "f!1")
           (assert))
          ("2"
           (hide 2)
           (decompose-equality +)
           (iff)
           (ground)
           (("1"
             (typepred "OEE`space")
             (expand "bounded_linear_subspace?")
             (flatten)
             (expand "funs_bounded?")
             (inst - "x!1"))
            ("2"
             (lemma "Op_Extension_exists")
             (inst - "OEE" "x!1")
             (assert)
             (skosimp*)
             (expand "maximal?")
             (flatten)
             (inst + "Ext!1")
             (("1" (assert) (expand "le") (typepred "Ext!1") (propax))
              ("2"
               (assert)
               (typepred "Ext!1")
               (typepred "OEE")
               (lemma "Hahn_Banach_partial_order")
               (expand "partial_order?")
               (expand "preorder?")
               (expand "transitive?")
               (flatten)
               (inst - "ContExt" "OEE" "Ext!1")
               (assert)
               (expand "fullset")
               (propax))))))))
        ("2"
         (hide 2)
         (skeep)
         (case "empty?(ch)")
         (("1"
           (expand "bounded_above?")
           (inst + "ContExt")
           (("1"
             (expand "upper_bound?")
             (skosimp*)
             (expand "empty?")
             (inst - "r!1")
             (assert))
            ("2"
             (hide -)
             (split)
             (("1"
               (lemma "C_Bounded_Linear_Operator_TCC1")
               (expand "extend")
               (expand "fullset")
               (expand "ContExt")
               (case "(continuous_on_int?[a, b]) = (LAMBDA (t: [INTab -> real]):
                                                                                                                                 IF (continuous_on_int?[a, b])(t) THEN TRUE
                                                                                                                                 ELSE FALSE
                                                                                                                                 ENDIF)")
               (("1" (assert))
                ("2" (decompose-equality +) (lift-if) (propax))))
              ("2" (skeep) (expand "ContExt") (propax))
              ("3"
               (typepred "ContExt`Lop")
               (expand "bounded_linear_operator?")
               (ground)
               (("1"
                 (expand "bounded_op?")
                 (skosimp*)
                 (inst + "M!1")
                 (skosimp*)
                 (inst - "f!1"))
                ("2"
                 (expand "linear_op?")
                 (ground)
                 (("1"
                   (expand "additive_op?")
                   (skosimp*)
                   (inst - "f!1" "g!1"))
                  ("2"
                   (expand "const_inv_op?")
                   (skosimp*)
                   (inst - "f!1" "c!1"))))))
              ("4"
               (lemma "Hahn_Banach_partial_order")
               (expand "partial_order?")
               (expand "preorder?")
               (expand "reflexive?")
               (flatten)
               (inst - "ContExt"))))))
          ("2"
           (label "che" 1)
           (hide "che")
           (typepred "ch")
           (expand "chain?")
           (expand "restrict")
           (hide "ContExtname")
           (name "Extspace"
                 "LAMBDA (f:[INTab->real]): EXISTS (OE:Op_Extension(ContExt)): ch(OE) AND member(f,OE`space)")
           (label "Extspacename" -1)
           (label "totalorder" -2)
           (name "oechooser"
                 "(LAMBDA (f:(Extspace)): choose({OE:Op_Extension(ContExt)|ch(OE) AND member(f,OE`space)}))")
           (("1"
             (label "oechoosername" -1)
             (case "bounded_linear_subspace?[a, b](Extspace)")
             (("1"
               (label "blsExtspace" -1)
               (name "ExtLop"
                     "(LAMBDA (f:(Extspace)): oechooser(f)`Lop(f))")
               (("1"
                 (label "ExtLopname" -1)
                 (name "Extpair"
                       "(# space := Extspace, Lop := ExtLop #)")
                 (label "Extpairname" -1)
                 (expand "bounded_above?")
                 (inst + "Extpair")
                 (("1"
                   (expand "upper_bound?")
                   (skolem + "EES")
                   (expand "le")
                   (expand "<=" +)
                   (case "NOT (FORALL (EVV:Op_Extension(ContExt)): ch(EVV) IMPLIES subset?(EVV`space,Extpair`space))")
                   (("1"
                     (hide 2)
                     (skeep)
                     (expand "subset?")
                     (skolem 1 "f")
                     (flatten)
                     (expand "Extpair" +)
                     (expand "Extspace" +)
                     (expand "member")
                     (inst + "EVV")
                     (ground))
                    ("2"
                     (label "ssprvd" -1)
                     (copy "ssprvd")
                     (inst - "EES")
                     (label "subsetprvd" -1)
                     (assert)
                     (case "NOT (FORALL (ff: [INTab -> real],EVV:Op_Extension(ContExt)):
                                                                                                                                                                                                                                                                                                     ch(EVV) AND EVV`space(ff) IMPLIES EVV`Lop(ff) = Extpair`Lop(ff))")
                     (("1"
                       (hide 2)
                       (skeep)
                       (expand "Extpair" +)
                       (expand "ExtLop" +)
                       (typepred "oechooser(ff)")
                       (assert)
                       (copy "totalorder")
                       (expand "total_order?" -1)
                       (flatten)
                       (expand "dichotomous?")
                       (inst - "EVV" "oechooser(ff)")
                       (split -)
                       (("1"
                         (expand "<=" -1)
                         (flatten)
                         (inst - "ff")
                         (assert))
                        ("2"
                         (expand "<=" -1)
                         (flatten)
                         (inst - "ff")
                         (assert))))
                      ("2"
                       (label "extends" -1)
                       (split +)
                       (("1" (skeep) (inst - "ff" "EES") (assert))
                        ("2"
                         (name "EESnorm"
                               "op_norm[a, b, ((EES`space))](EES`Lop)")
                         (("1"
                           (replace -1)
                           (name "Extpairnorm"
                                 "op_norm[a, b, ((Extpair`space))](Extpair`Lop)")
                           (("1"
                             (replace -1)
                             (label "EESnormname" -2)
                             (label "Extpairnormname" -1)
                             (case "EESnorm < Extpairnorm")
                             (("1"
                               (typepred "Extpairnorm")
                               (inst -3 "EESnorm")
                               (assert)
                               (skosimp*)
                               (typepred "f!1")
                               (expand "Extpair" -1)
                               (expand "Extspace" -1)
                               (skosimp*)
                               (copy "extends")
                               (inst - "f!1" "OE!1")
                               (assert)
                               (replace -1 :dir rl)
                               (copy "totalorder")
                               (expand "total_order?" -1)
                               (flatten)
                               (expand "dichotomous?")
                               (inst - "EES" "OE!1")
                               (assert)
                               (split -)
                               (("1"
                                 (expand "<=" -1)
                                 (flatten)
                                 (typepred
                                  "op_norm[a, b, ((OE!1`space))](OE!1`Lop)")
                                 (("1" (inst - "f!1") (assert))
                                  ("2"
                                   (hide-all-but 1)
                                   (typepred "OE!1`space")
                                   (expand "extend")
                                   (expand "fullset")
                                   (case
                                    "OE!1`space = (LAMBDA (t: [INTab -> real]):
                                                                                                                                                                                                                                                                                                                                                              IF ((OE!1`space))(t) THEN TRUE ELSE FALSE ENDIF)")
                                   (("1" (assert))
                                    ("2"
                                     (decompose-equality +)
                                     (lift-if)
                                     (propax))))))
                                ("2"
                                 (expand "<=" -1)
                                 (flatten)
                                 (inst - "f!1")
                                 (assert)
                                 (typepred "EESnorm")
                                 (inst - "f!1")
                                 (assert))))
                              ("2"
                               (typepred "EESnorm")
                               (inst -3 "Extpairnorm")
                               (assert)
                               (skosimp*)
                               (typepred "Extpairnorm")
                               (inst - "f!1")
                               (("1"
                                 (inst "extends" "f!1" "EES")
                                 (assert))
                                ("2"
                                 (expand "Extpair" +)
                                 (expand "Extspace" +)
                                 (inst + "EES")
                                 (assert))))))
                            ("2"
                             (hide-all-but ("blsExtspace" 1))
                             (expand "extend")
                             (expand "fullset")
                             (case "Extspace = (LAMBDA (t: [INTab -> real]):
                                                                                                                                                                                                                                                                                                                  IF ((Extpair`space))(t) THEN TRUE ELSE FALSE ENDIF)")
                             (("1" (assert))
                              ("2"
                               (decompose-equality +)
                               (lift-if)
                               (ground))))
                            ("3"
                             (hide-all-but 1)
                             (skeep)
                             (expand "Extpair")
                             (propax))))
                          ("2"
                           (hide-all-but 1)
                           (typepred "EES`space")
                           (expand "extend")
                           (expand "fullset")
                           (case "EES`space = (LAMBDA (t: [INTab -> real]):
                                                                                                                                                                                                                                                                                                IF ((EES`space))(t) THEN TRUE ELSE FALSE ENDIF)")
                           (("1" (assert))
                            ("2"
                             (decompose-equality +)
                             (lift-if)
                             (propax))))))))
                      ("3"
                       (hide 2)
                       (skeep)
                       (inst "ssprvd" "EVV")
                       (assert)
                       (expand "subset?" "ssprvd")
                       (inst - "ff")
                       (assert))))))
                  ("2"
                   (case "NOT bounded_linear_subspace?[a, b](Extpair`space)")
                   (("1" (hide 2) (expand "Extpair" +) (propax))
                    ("2"
                     (assert)
                     (label "Expairbls" -1)
                     (case "NOT (FORALL (x: [INTab -> real]): Extspace(x) IFF Extpair`space(x))")
                     (("1" (hide 2) (skeep) (expand "Extpair") (propax))
                      ("2"
                       (assert)
                       (replace -1)
                       (case "NOT bounded_linear_operator?[a, b, (Extpair`space)](Extpair`Lop)")
                       (("1"
                         (hide 2)
                         (name "MM"
                               "op_norm[a,b,(ContExt`space)](ContExt`Lop)")
                         (("1"
                           (label "MMname" -1)
                           (expand "bounded_linear_operator?")
                           (split)
                           (("1"
                             (expand "bounded_op?")
                             (inst + "MM")
                             (skosimp*)
                             (expand "Extpair" +)
                             (expand "ExtLop" +)
                             (typepred "oechooser(f!1)")
                             (expand "<=" -1)
                             (replace "MMname")
                             (flatten)
                             (typepred
                              "op_norm[a, b, ((oechooser(f!1)`space))](oechooser(f!1)`Lop)")
                             (("1" (inst - "f!1") (assert))
                              ("2"
                               (hide-all-but 1)
                               (typepred "oechooser(f!1)`space")
                               (expand "extend")
                               (expand "fullset")
                               (case "(LAMBDA (t: [INTab -> real]):
                                                                                                                                                                                                                                                                                                   IF ((oechooser(f!1)`space))(t) THEN TRUE ELSE FALSE ENDIF) = oechooser(f!1)`space")
                               (("1" (assert))
                                ("2"
                                 (decompose-equality +)
                                 (lift-if)
                                 (propax))))))
                            ("2"
                             (expand "Extpair" +)
                             (expand "ExtLop" +)
                             (expand "linear_op?")
                             (split +)
                             (("1"
                               (expand "additive_op?")
                               (skolem 1 ("ff" "gg"))
                               (case "EXISTS (OESTV: Op_Extension(ContExt)): ch(OESTV) AND oechooser(ff+gg) <= OESTV AND oechooser(ff) <= OESTV AND oechooser(gg) <= OESTV")
                               (("1"
                                 (skeep -1)
                                 (expand "<=" (-1 -2 -3 -4))
                                 (flatten)
                                 (inst - "ff+gg")
                                 (inst - "ff")
                                 (inst - "gg")
                                 (assert)
                                 (typepred "oechooser(ff+gg)")
                                 (expand "member")
                                 (assert)
                                 (typepred "oechooser(ff)")
                                 (expand "member")
                                 (assert)
                                 (typepred "oechooser(gg)")
                                 (expand "member")
                                 (assert)
                                 (typepred "OESTV`Lop")
                                 (expand "bounded_linear_operator?")
                                 (flatten)
                                 (expand "linear_op?")
                                 (flatten)
                                 (expand "additive_op?")
                                 (inst - "ff" "gg")
                                 (assert))
                                ("2"
                                 (hide 2)
                                 (hide-all-but ("totalorder" +))
                                 (case
                                  "EXISTS (OESTV: Op_Extension(ContExt)): ch(OESTV) AND
                                                                                                                                                                                                                                                                                 oechooser(ff) <= OESTV AND oechooser(gg) <= OESTV")
                                 (("1"
                                   (skeep -1)
                                   (expand "total_order?")
                                   (flatten)
                                   (expand "dichotomous?")
                                   (inst - "OESTV" "oechooser(ff+gg)")
                                   (("1"
                                     (expand "le")
                                     (split -)
                                     (("1"
                                       (inst + "oechooser(ff+gg)")
                                       (assert)
                                       (expand "partial_order?")
                                       (expand "preorder?")
                                       (flatten)
                                       (split)
                                       (("1"
                                         (expand "reflexive?")
                                         (inst - "oechooser(ff+gg)"))
                                        ("2"
                                         (expand "transitive?")
                                         (inst
                                          -
                                          "oechooser(ff)"
                                          "OESTV"
                                          "oechooser(ff+gg)")
                                         (assert))
                                        ("3"
                                         (assert)
                                         (expand "transitive?")
                                         (inst
                                          -
                                          "oechooser(gg)"
                                          "OESTV"
                                          "oechooser(ff+gg)")
                                         (assert))))
                                      ("2" (inst + "OESTV") (assert))))
                                    ("2"
                                     (reveal "blsExtspace")
                                     (expand "bounded_linear_subspace?")
                                     (flatten)
                                     (expand "funs_sum_closed?")
                                     (inst - "ff" "gg"))))
                                  ("2"
                                   (hide 2)
                                   (inst-cp + "oechooser(ff)")
                                   (inst + "oechooser(gg)")
                                   (assert)
                                   (expand "total_order?")
                                   (flatten)
                                   (expand "dichotomous?")
                                   (inst
                                    -
                                    "oechooser(ff)"
                                    "oechooser(gg)")
                                   (expand "le")
                                   (expand "partial_order?")
                                   (expand "preorder?")
                                   (expand "reflexive?")
                                   (flatten)
                                   (inst-cp - "oechooser(ff)")
                                   (inst - "oechooser(gg)")
                                   (ground))))))
                              ("2"
                               (expand "const_inv_op?")
                               (skosimp*)
                               (case "EXISTS (OESTV: Op_Extension(ContExt)): ch(OESTV) AND oechooser(c!1*f!1) <= OESTV AND oechooser(f!1) <= OESTV")
                               (("1"
                                 (skeep -1)
                                 (expand "<=" (-1 -2 -3))
                                 (flatten)
                                 (inst - "c!1*f!1")
                                 (inst - "f!1")
                                 (typepred "OESTV`Lop")
                                 (expand "bounded_linear_operator?")
                                 (expand "linear_op?")
                                 (expand "const_inv_op?")
                                 (flatten)
                                 (inst - "f!1" "c!1")
                                 (("1"
                                   (assert)
                                   (typepred "oechooser(c!1*f!1)")
                                   (typepred "oechooser(f!1)")
                                   (expand "member")
                                   (assert))
                                  ("2"
                                   (expand "subset?")
                                   (inst - "f!1")
                                   (inst - "f!1")
                                   (assert))))
                                ("2"
                                 (hide-all-but ("totalorder" 1))
                                 (inst-cp + "oechooser(c!1*f!1)")
                                 (("1"
                                   (inst + "oechooser(f!1)")
                                   (assert)
                                   (expand "total_order?")
                                   (expand "dichotomous?")
                                   (flatten)
                                   (inst
                                    -
                                    "oechooser(f!1)"
                                    "oechooser(c!1*f!1)")
                                   (("1"
                                     (expand "le")
                                     (expand "partial_order?")
                                     (expand "preorder?")
                                     (expand "reflexive?")
                                     (flatten)
                                     (inst-cp - "oechooser(c!1*f!1)")
                                     (("1"
                                       (inst - "oechooser(f!1)")
                                       (ground))
                                      ("2"
                                       (reveal "blsExtspace")
                                       (expand
                                        "bounded_linear_subspace?")
                                       (flatten)
                                       (expand "funs_const_closed?")
                                       (inst - "f!1" "c!1"))))
                                    ("2"
                                     (reveal "blsExtspace")
                                     (expand "bounded_linear_subspace?")
                                     (flatten)
                                     (expand "funs_const_closed?")
                                     (inst - "f!1" "c!1"))))
                                  ("2"
                                   (reveal "blsExtspace")
                                   (expand "bounded_linear_subspace?")
                                   (flatten)
                                   (expand "funs_const_closed?")
                                   (inst - "f!1" "c!1"))))))))))
                          ("2"
                           (hide-all-but 1)
                           (lemma "C_Bounded_Linear_Operator_TCC1")
                           (expand "extend")
                           (expand "fullset")
                           (expand "ContExt")
                           (propax))
                          ("3"
                           (hide-all-but 1)
                           (split)
                           (("1" (skeep) (expand "ContExt") (propax))
                            ("2"
                             (assert)
                             (typepred "ContExt`Lop")
                             (expand "bounded_linear_operator?")
                             (ground)
                             (expand "bounded_op?")
                             (skosimp*)
                             (inst + "M!1")
                             (skosimp*)
                             (inst - "f!1"))))))
                        ("2"
                         (assert)
                         (expand "<=" +)
                         (case "NOT subset?(ContExt`space, Extpair`space)")
                         (("1"
                           (hide 2)
                           (expand "subset?")
                           (skeep)
                           (assert)
                           (expand "Extpair" +)
                           (expand "Extspace" +)
                           (reveal "che")
                           (expand "empty?")
                           (skosimp*)
                           (inst + "x!1")
                           (assert)
                           (typepred "x!1")
                           (expand "<=" -1)
                           (flatten)
                           (expand "subset?" -1)
                           (inst - "x")
                           (assert))
                          ("2"
                           (assert)
                           (case "NOT (FORALL (ff: [INTab -> real]):
                                                                                                                                                                                                     ContExt`space(ff) IMPLIES ContExt`Lop(ff) = Extpair`Lop(ff))")
                           (("1"
                             (hide 2)
                             (skeep)
                             (expand "Extpair" +)
                             (expand "ExtLop" +)
                             (typepred "oechooser(ff)")
                             (expand "<=" -1)
                             (flatten)
                             (inst - "ff")
                             (assert))
                            ("2"
                             (assert)
                             (label "opsequal" -1)
                             (label "subsetss" -2)
                             (label "bopExtpair" -3)
                             (replace "opsequal")
                             (name "CEnorm"
                                   "op_norm[a, b, ((ContExt`space))](ContExt`Lop)")
                             (("1"
                               (replace -1)
                               (label "CEnormname" -1)
                               (name "Extnorm"
                                     "op_norm[a, b, ((Extpair`space))](Extpair`Lop)")
                               (replace -1)
                               (label "Extnormname" -1)
                               (case "CEnorm < Extnorm")
                               (("1"
                                 (typepred "Extnorm")
                                 (inst -3 "CEnorm")
                                 (assert)
                                 (skosimp*)
                                 (expand "Extpair" -3)
                                 (expand "ExtLop" -3)
                                 (typepred "oechooser(f!1)")
                                 (expand "<=" -1)
                                 (flatten)
                                 (typepred
                                  "op_norm[a, b, ((oechooser(f!1)`space))](oechooser(f!1)`Lop)")
                                 (("1" (inst - "f!1") (assert))
                                  ("2"
                                   (hide-all-but 1)
                                   (expand "fullset")
                                   (expand "extend")
                                   (case
                                    "(LAMBDA (t: [INTab -> real]):
                                                                                                                                                                                                                           IF ((oechooser(f!1)`space))(t) THEN TRUE ELSE FALSE ENDIF) = oechooser(f!1)`space")
                                   (("1" (assert))
                                    ("2"
                                     (decompose-equality +)
                                     (lift-if)
                                     (propax))))))
                                ("2"
                                 (typepred "CEnorm")
                                 (inst -3 "Extnorm")
                                 (assert)
                                 (skosimp*)
                                 (typepred "Extnorm")
                                 (inst - "f!1")
                                 (("1"
                                   (case
                                    "ContExt`Lop(f!1) = Extpair`Lop(f!1)")
                                   (("1" (assert))
                                    ("2"
                                     (expand "Extpair" +)
                                     (expand "ExtLop" +)
                                     (typepred "oechooser(f!1)")
                                     (expand "<=" -1)
                                     (flatten)
                                     (inst - "f!1")
                                     (assert))))
                                  ("2"
                                   (expand "Extpair" +)
                                   (expand "Extspace" +)
                                   (reveal "che")
                                   (expand "empty?")
                                   (skosimp*)
                                   (inst + "x!1")
                                   (assert)
                                   (typepred "x!1")
                                   (expand "<=" -1)
                                   (flatten)
                                   (expand "subset?" -1)
                                   (inst - "f!1")
                                   (assert))))))
                              ("2"
                               (hide-all-but 1)
                               (expand "fullset")
                               (expand "extend")
                               (expand "ContExt")
                               (lemma "C_Bounded_Linear_Operator_TCC1")
                               (expand "fullset")
                               (expand "extend")
                               (propax))
                              ("3"
                               (hide-all-but 1)
                               (skeep)
                               (expand "ContExt")
                               (propax))))
                            ("3"
                             (hide-all-but 1)
                             (skeep)
                             (expand "Extspace")
                             (reveal "che")
                             (expand "empty?")
                             (skosimp*)
                             (inst + "x!1")
                             (assert)
                             (typepred "x!1")
                             (expand "<=" -1)
                             (flatten)
                             (expand "subset?")
                             (inst - "ff")
                             (assert))
                            ("4" (hide 2) (expand "ContExt") (skeep))))))
                        ("3"
                         (hide-all-but ("Expairbls" 1))
                         (expand "fullset")
                         (expand "extend")
                         (expand "Extpair")
                         (case "Extspace = (LAMBDA (t: [INTab -> real]):
                                                                                                                                                                                             IF Extspace(t) THEN TRUE ELSE FALSE ENDIF)")
                         (("1" (assert))
                          ("2"
                           (decompose-equality +)
                           (lift-if)
                           (propax))))
                        ("4" (propax))))))))))
                ("2" (skeep) (typepred "oechooser(f)") (assert))))
              ("2"
               (hide 2)
               (case "FORALL (ff,gg:(Extspace)): EXISTS (OESTV: Op_Extension(ContExt)): ch(OESTV) AND oechooser(ff) <= OESTV AND oechooser(gg) <= OESTV")
               (("1"
                 (label "funlem" -1)
                 (hide "Extspacename")
                 (expand "bounded_linear_subspace?")
                 (split)
                 (("1"
                   (expand "funs_sum_closed?")
                   (skosimp*)
                   (inst - "f!1" "g!1")
                   (skeep -)
                   (expand "Extspace")
                   (inst + "OESTV")
                   (assert)
                   (expand "<=" (-1 -2 -3))
                   (flatten)
                   (inst - "f!1")
                   (inst - "g!1")
                   (typepred "oechooser(f!1)")
                   (typepred "oechooser(g!1)")
                   (assert)
                   (typepred "OESTV`space")
                   (expand "bounded_linear_subspace?")
                   (flatten)
                   (expand "funs_sum_closed?")
                   (inst - "f!1" "g!1"))
                  ("2"
                   (expand "funs_const_closed?")
                   (skosimp*)
                   (hide "funlem")
                   (expand "Extspace")
                   (inst + "oechooser(f!1)")
                   (assert)
                   (typepred "oechooser(f!1)")
                   (typepred "oechooser(f!1)`space")
                   (expand "bounded_linear_subspace?")
                   (flatten)
                   (expand "funs_const_closed?")
                   (inst - "f!1" "c!1")
                   (assert))
                  ("3"
                   (expand "funs_bounded?")
                   (skosimp*)
                   (typepred "f!1")
                   (expand "Extspace" -1)
                   (skosimp*)
                   (typepred "OE!1`space")
                   (expand "bounded_linear_subspace?")
                   (flatten)
                   (expand "funs_bounded?")
                   (inst - "f!1")
                   (assert))
                  ("4"
                   (assert)
                   (expand "funs_contain_constants?")
                   (skosimp*)
                   (expand "Extspace")
                   (reveal "che")
                   (expand "empty?")
                   (skosimp*)
                   (inst + "x!1")
                   (assert)
                   (typepred "x!1`space")
                   (expand "bounded_linear_subspace?")
                   (flatten)
                   (expand "funs_contain_constants?")
                   (inst - "c!1"))
                  ("5"
                   (expand "funs_contain_continuous?")
                   (skosimp*)
                   (expand "Extspace")
                   (reveal "che")
                   (expand "empty?")
                   (skosimp*)
                   (inst + "x!1")
                   (assert)
                   (typepred "x!1`space")
                   (expand "bounded_linear_subspace?")
                   (flatten)
                   (expand "funs_contain_continuous?")
                   (inst - "f!1")
                   (assert))))
                ("2"
                 (hide-all-but ("totalorder" 1))
                 (skeep)
                 (expand "total_order?")
                 (expand "partial_order?")
                 (expand "preorder?")
                 (expand "reflexive?")
                 (expand "dichotomous?")
                 (flatten)
                 (inst-cp - "oechooser(ff)")
                 (inst - "oechooser(gg)")
                 (inst - "oechooser(ff)" "oechooser(gg)")
                 (expand "le")
                 (inst-cp + "oechooser(ff)")
                 (inst + "oechooser(gg)")
                 (ground))))))
            ("2"
             (skeep)
             (typepred "f")
             (expand "Extspace" -1)
             (skosimp*)
             (expand "nonempty?")
             (assert)
             (expand "empty?")
             (inst - "OE!1")
             (expand "member")
             (propax))))))))
      ("2" (hide 2) (lemma "Hahn_Banach_partial_order_sub") (inst?))
      ("3"
       (hide 2)
       (split)
       (("1"
         (hide -)
         (expand "ContExt")
         (lemma "C_Bounded_Linear_Operator_TCC1")
         (expand "extend")
         (expand "fullset")
         (ground)
         (case "(LAMBDA (t: [INTab -> real]):
                                                                                                                                                                           IF (continuous_on_int?[a, b])(t) THEN TRUE
                                                                                                                                                                           ELSE FALSE
                                                                                                                                                                           ENDIF) = continuous_on_int?[a, b]")
         (("1" (assert))
          ("2" (decompose-equality +) (lift-if) (propax))))
        ("2" (skeep) (expand "ContExt" +) (propax))
        ("3"
         (typepred "ContExt`Lop")
         (assert)
         (hide "ContExtname")
         (expand "bounded_linear_operator?")
         (ground)
         (("1"
           (expand "bounded_op?")
           (skosimp*)
           (inst + "M!1")
           (skosimp*)
           (inst - "f!1"))
          ("2"
           (expand "linear_op?")
           (ground)
           (("1" (expand "additive_op?") (skosimp*) (inst - "f!1" "g!1"))
            ("2"
             (expand "const_inv_op?")
             (skosimp*)
             (inst - "f!1" "c!1"))))))))))
    ("3"
     (hide 2)
     (skeep)
     (skeep)
     (skeep)
     (typepred "OEE")
     (expand "<=" -1)
     (flatten)
     (expand "subset?")
     (inst - "f")
     (assert))
    ("4"
     (assert)
     (expand "fullset")
     (hide 2)
     (skeep)
     (skeep)
     (expand "extend" +)
     (replace -1 +)
     (assert)
     (lemma "C_Bounded_Linear_Operator_TCC1")
     (expand "extend")
     (expand "fullset")
     (propax))
    ("5"
     (hide 2)
     (skeep)
     (skeep)
     (assert)
     (split)
     (("1" (skolem 1 "f") (replace -1) (assert))
      ("2"
       (replace -1)
       (assert)
       (typepred "LC")
       (expand "bounded_linear_operator?")
       (flatten)
       (expand "bounded_op?")
       (skosimp*)
       (inst + "M!1")
       (skosimp*)
       (inst - "f!1"))))
    ("6"
     (hide 2)
     (skeep)
     (skeep)
     (typepred "OEE")
     (typepred "OEE`space")
     (expand "extend")
     (expand "fullset")
     (case "OEE`space = (LAMBDA (t: [INTab -> real]):
                                                                                                                                    IF (OEE`space)(t) THEN TRUE ELSE FALSE ENDIF)")
     (("1" (assert)) ("2" (decompose-equality +) (lift-if) (propax))))
    ("7"
     (hide 2)
     (skeep)
     (skeep)
     (typepred "OEE`Lop")
     (expand "bounded_linear_operator?")
     (assert))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_hahn_banach
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "bounded_linear_subspace?")
   (expand "extend")
   (expand "fullset")
   (split)
   (("1"
     (expand "funs_sum_closed?")
     (skosimp*)
     (ground)
     (expand "continuous_on_int?")
     (lemma "sum_continuous")
     (inst?)
     (assert)
     (typepred "f!1")
     (typepred "g!1")
     (expand "continuous_on_int?")
     (ground))
    ("2"
     (expand "funs_const_closed?")
     (skeep)
     (ground)
     (lemma "scal_continuous")
     (inst?)
     (expand "continuous_on_int?")
     (inst?)
     (assert)
     (typepred "f")
     (expand "continuous_on_int?")
     (propax))
    ("3"
     (expand "funs_bounded?")
     (skeep)
     (lemma "continuous_implies_bounded[a,b]")
     (inst - "f"))
    ("4" (grind)) ("5" (grind :exclude "continuous?"))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_hahn_banach
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "bounded_linear_subspace?")
   (expand "extend")
   (expand "fullset")
   (split)
   (("1"
     (expand "funs_sum_closed?")
     (skosimp*)
     (ground)
     (typepred "f!1")
     (typepred "g!1")
     (expand "bounded_on_int?")
     (skosimp*)
     (inst + "M!1+M!2")
     (skeep)
     (inst - "x")
     (inst - "x")
     (grind))
    ("2"
     (expand "funs_const_closed?")
     (skeep)
     (ground)
     (typepred "f")
     (expand "bounded_on_int?")
     (skosimp*)
     (inst + "M!1*abs(c)")
     (skeep)
     (inst - "x")
     (expand "*")
     (rewrite "abs_mult")
     (mult-by -1 "abs(c)")
     (assert))
    ("3" (expand "funs_bounded?") (propax))
    ("4"
     (expand "funs_contain_constants?")
     (skeep)
     (ground)
     (expand "bounded_on_int?")
     (inst + "abs(c)")
     (grind))
    ("5"
     (expand "funs_contain_continuous?")
     (skeep)
     (ground)
     (lemma "continuous_implies_bounded[a,b]")
     (inst - "f"))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_hahn_banach
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (expand "bounded_op?")
   (typepred "OE`Lop")
   (expand "bounded_linear_operator?")
   (flatten)
   (expand "bounded_op?")
   (propax))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_hahn_banach
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (typepred "OE`space")
   (expand "extend")
   (expand "fullset")
   (hide -2)
   (hide -2)
   (case "OE`space = (LAMBDA (t: [INTab[a, b] -> real]):
                             IF (OE`space)(t) THEN TRUE ELSE FALSE ENDIF)")
   (("1" (assert))
    ("2" (hide-all-but 1) (decompose-equality) (lift-if) (propax))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_hahn_banach
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (typepred "Ext`space")
   (hide -2)
   (hide -2)
   (expand "fullset")
   (expand "extend")
   (case "Ext`space = (LAMBDA (t: [INTab[a, b] -> real]):
                      IF (Ext`space)(t) THEN TRUE ELSE FALSE ENDIF)")
   (("1" (assert)) ("2" (decompose-equality) (lift-if) (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("ff" "gg"))
   (case "NOT integrable?(a,b,gg,ff)")
   (("1"
     (hide 2)
     (lemma "RS_integrable_cont_BV")
     (inst - "a" "b" "ff" "gg")
     (assert)
     (typepred "ff")
     (expand "continuous_on_int?")
     (expand "continuous?")
     (skosimp*)
     (inst - "x!1")
     (("1"
       (expand "continuous_at?")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "y!1")
       (("1" (assert))
        ("2" (expand "restrict" +) (expand "Intab") (propax))))
      ("2" (expand "restrict" +) (expand "Intab") (propax))))
    ("2"
     (label "fint" -1)
     (assert)
     (name "SS" "integral(a,b,gg,ff)")
     (label "SSname" -1)
     (lemma "integral_def")
     (inst - "a" "b" "ff" "gg" "SS")
     (split -)
     (("1"
       (flatten)
       (hide -2)
       (split -)
       (("1"
         (label "integrall?" -1)
         (case "FORALL (P:partition(a,b),xis:xis?(a,b,P)): abs(Rie_sum(a,b,gg,P,xis,ff)) <= total_variation(a,b,gg)(b)*fun_norm(ff)")
         (("1"
           (case "FORALL (eps:posreal): abs(integral(a, b, gg, ff)) <=
                                                                                        total_variation(a, b, gg)(b) * fun_norm(ff)+eps")
           (("1"
             (inst -
              "(abs(integral(a, b, gg, ff)) -
                                                           total_variation(a, b, gg)(b) * fun_norm(ff))/10")
             (assert))
            ("2"
             (hide 2)
             (expand "integral?")
             (skeep)
             (inst "integrall?" "eps/10")
             (skosimp*)
             (lemma "partition_exists")
             (inst - "a" "b" "delta!1")
             (assert)
             (skosimp*)
             (name "xis" "gen_xis(a,b,P!1)")
             (inst - "P!1" "xis")
             (inst - "P!1")
             (assert)
             (inst - "Rie_sum(a,b,gg,P!1,xis,ff)")
             (("1"
               (grind :exclude
                ("gen_xis"
                 "width"
                 "Rie_sum"
                 "total_variation"
                 "integral"
                 "integrable?")))
              ("2"
               (lemma "Riemann?_Rie")
               (inst - "a" "b" "ff" "gg")
               (split -)
               (("1" (inst - "P!1" "xis")) ("2" (assert))))))))
          ("2"
           (hide 2)
           (skeep)
           (expand "Rie_sum")
           (lemma "sigma_abs[below(P`length-1)]")
           (inst?)
           (case "sigma(0, P`length - 2,
                                                              LAMBDA (n_1: below(P`length - 1)):
                                                                abs(ff(xis`seq(n_1)) * gg(P`seq(1 + n_1)) -
                                                                     ff(xis`seq(n_1)) * gg(P`seq(n_1)))) <= total_variation(a, b, gg)(b) * fun_norm(ff)")
           (("1" (assert))
            ("2"
             (hide 2)
             (hide -1)
             (typepred "total_variation(a,b,gg)(b)")
             (assert)
             (inst - "P")
             (case "sigma(0, P`length - 2,
                                                                    LAMBDA (n_1: below(P`length - 1)):
                                                                      abs(ff(xis`seq(n_1)) * gg(P`seq(1 + n_1)) -
                                                                           ff(xis`seq(n_1)) * gg(P`seq(n_1)))) <= variation_on(a, b, P)(gg) * fun_norm(ff)")
             (("1" (mult-by -4 "fun_norm[a,b](ff)") (assert))
              ("2"
               (hide 2)
               (expand "variation_on")
               (lemma "sigma_scal[below(P`length-1)]")
               (inst -
                "LAMBDA (n: below(P`length - 1)):
                                                            abs(gg(P`seq(1 + n)) - gg(P`seq(n)))"
                "fun_norm[a,b](ff)" "P`length-2" "0")
               (replace -1 :dir rl)
               (hide -1)
               (rewrite "sigma_le")
               (hide 2)
               (skeep)
               (typepred "n")
               (lemma "abs_mult")
               (inst - "ff(xis`seq(n))" "gg(P`seq(1 + n)) -gg(P`seq(n))")
               (replace -1)
               (case "abs(ff(xis`seq(n))) <= fun_norm(ff)")
               (("1" (mult-by -1 "abs(gg(P`seq(1 + n)) - gg(P`seq(n)))"))
                ("2"
                 (typepred "fun_norm(ff)")
                 (inst - "xis`seq(n)"))))))))))
        ("2" (propax)) ("3" (propax))))
      ("2" (ground))))
    ("3" (assert) (typepred "b") (assert)) ("4" (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("ff" "gg"))
   (lemma "integral_norm_bounded")
   (expand "fun_to_op")
   (inst - "ff" "gg")
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (typepred "f")
   (expand "continuous_on_int?")
   (case "uniformly_continuous?[INTab,real_dist,real,real_dist](f,Intab)")
   (("1"
     (expand "uniformly_continuous?")
     (inst - "eps")
     (skosimp*)
     (inst + "delta!1")
     (skeep)
     (label "Pwidth" -4)
     (label "Pinc" -3)
     (label "funif" -1)
     (hide -2)
     (skosimp*)
     (lemma "part_in")
     (case "FORALL (x: INTab, P: partition(a, b)):
                                                                strictly_increasing?(P) IMPLIES
                                                                 (EXISTS (ii: below(P`length - 1)):
                                                                    P`seq(ii) <= x AND x <= P`seq(ii + 1) AND
                                                                    char_fun(P`seq(ii),P`seq(ii+1))(x) = 1)")
     (("1"
       (hide -2)
       (inst - "x!1" "P")
       (assert)
       (skosimp*)
       (case "step_approx(P,xis)(f)(x!1) = f(xis`seq(ii!1))")
       (("1"
         (inst "funif" "x!1" "xis`seq(ii!1)")
         (("1"
           (expand "real_dist")
           (assert)
           (hide 2)
           (hide -1)
           (hide "Pinc")
           (case "P`seq(1+ii!1)-P`seq(ii!1) < delta!1")
           (("1"
             (hide "Pwidth")
             (typepred "xis")
             (inst - "ii!1")
             (assert)
             (grind :exclude ("char_fun")))
            ("2"
             (lemma "width_lem")
             (inst - "a" "b" "P" "ii!1")
             (assert))))
          ("2" (expand "restrict") (expand "Intab") (assert))
          ("3" (expand "restrict") (expand "Intab") (propax))))
        ("2"
         (hide 2)
         (expand "step_approx")
         (lemma "sigma_split[below(P`length-1)]")
         (inst -
          "LAMBDA (n: below(P`length - 1)):
                                                                         f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)"
          "P`length-2" "0" "ii!1")
         (assert)
         (replace -1)
         (hide -1)
         (lemma "sigma_split[below(P`length-1)]")
         (inst -
          "LAMBDA (n: below(P`length - 1)):
                                                                                   f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)"
          "ii!1" "0" "ii!1-1")
         (assert)
         (replace -1)
         (hide -1)
         (expand "sigma" + 2)
         (expand "sigma" + 3)
         (case "sigma(0, ii!1 - 1,
                                                                                                                          LAMBDA (n: below(P`length - 1)):
                                                                                                                            f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)) = 0 AND sigma(1 + ii!1, P`length - 2,
                                                                                                                           LAMBDA (n: below(P`length - 1)):
                                                                                                                             f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)) = 0")
         (("1" (flatten) (assert))
          ("2"
           (hide 2)
           (split)
           (("1"
             (rewrite "sigma_restrict_eq_0")
             (hide 2)
             (skolem 1 "jj")
             (case "char_fun(P`seq(jj), P`seq(1 + jj))(x!1) = 0")
             (("1" (assert))
              ("2"
               (hide 2)
               (typepred "jj")
               (expand "strictly_increasing?")
               (inst-cp "Pinc" "jj" "1+jj")
               (inst "Pinc" "ii!1" "ii!1+1")
               (assert)
               (typepred "P")
               (expand "increasing?")
               (inst - "1+jj" "ii!1")
               (assert)
               (expand "char_fun")
               (lift-if)
               (ground))))
            ("2"
             (rewrite "sigma_restrict_eq_0")
             (hide 2)
             (skolem 1 "jj")
             (expand "strictly_increasing?")
             (inst-cp "Pinc" "jj" "1+jj")
             (inst "Pinc" "ii!1" "ii!1+1")
             (assert)
             (typepred "P")
             (expand "increasing?")
             (inst - "ii!1+1" "jj")
             (assert)
             (expand "char_fun")
             (lift-if)
             (ground))))))))
      ("2"
       (hide 2)
       (hide ("funif" "Pinc" "Pwidth" 2))
       (skolem 1 ("yy" "PP"))
       (flatten)
       (inst-cp - "a" "b" "yy" "PP")
       (assert)
       (assert)
       (inst-cp - "a" "b" "yy" "PP")
       (assert)
       (skosimp*)
       (case "yy = PP`seq(1+ii!1)")
       (("1"
         (case "PP`seq(1+ii!1) = b")
         (("1" (inst + "ii!1") (assert) (expand "char_fun") (propax))
          ("2"
           (inst + "ii!1+1")
           (("1"
             (assert)
             (typepred "PP")
             (expand "increasing?")
             (inst - "1+ii!1" "2+ii!1")
             (assert)
             (expand "strictly_increasing?")
             (inst - "1+ii!1" "2+ii!1")
             (assert)
             (expand "char_fun")
             (propax))
            ("2"
             (typepred "PP")
             (inst - "2+ii!1")
             (("1" (ground)) ("2" (assert))))))))
        ("2"
         (assert)
         (inst - "a" "b" "yy" "PP")
         (assert)
         (skosimp*)
         (inst + "ii!1")
         (assert)
         (expand "char_fun")
         (propax))))))
    ("2"
     (hide 2)
     (lemma "Heine[real,real_dist,real,real_dist]")
     (name "ff" "LAMBDA (xy:real): IF Intab(xy) THEN f(xy) ELSE 0 ENDIF")
     (("1"
       (inst - "Intab" "ff")
       (assert)
       (split -)
       (("1"
         (hide-all-but (-1 1))
         (expand "uniformly_continuous?")
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "x!1" "p!1")
         (("1"
           (assert)
           (expand "ff")
           (case "Intab(x!1) AND Intab(p!1)")
           (("1" (flatten) (assert)) ("2" (expand "Intab") (propax))))
          ("2" (expand "Intab") (propax))
          ("3" (expand "Intab") (propax))))
        ("2"
         (hide 2)
         (hide -1)
         (expand "continuous?")
         (skosimp*)
         (inst - "x!1")
         (("1"
           (expand "continuous_at?")
           (skosimp*)
           (inst - "epsilon!1")
           (skosimp*)
           (inst + "delta!1")
           (skosimp*)
           (inst - "y!1")
           (("1"
             (expand "member")
             (expand "ball")
             (expand "ff")
             (assert))
            ("2"
             (assert)
             (typepred "y!1")
             (expand "Intab")
             (flatten)
             (assert)
             (expand "restrict")
             (propax))))
          ("2"
           (typepred "x!1")
           (expand "Intab")
           (assert)
           (flatten)
           (assert)
           (expand "restrict")
           (propax))))
        ("3"
         (lemma "closed_intervals_compact")
         (inst - "a" "b")
         (expand "Intab")
         (propax))
        ("4"
         (hide-all-but -1)
         (expand "empty?")
         (inst - "a")
         (expand "member")
         (expand "Intab")
         (assert))))
      ("2" (hide-all-but 1) (expand "Intab") (skosimp*) (ground))))
    ("3" (hide-all-but 1) (grind)) ("4" (hide-all-but 1) (grind))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (auto-rewrite + "member")
   (skeep)
   (lemma "Hahn_Banach")
   (inst - "LC")
   (skeep -)
   (name "gg"
         "(LAMBDA (x:INTab): IF x = a THEN 0 ELSE LB(char_fun(a,x)) ENDIF)")
   (("1"
     (label "ggname" -1)
     (label "opeq" -2)
     (label "LBLC" -3)
     (case "(FORALL (P:partition(a,b)): strictly_increasing?(P) IMPLIES variation_on(a,b,P)(gg) <= op_norm[a,b,Continuous_Function[a,b]](LC))")
     (("1"
       (label "VPle" -1)
       (case "total_variation(a,b,gg)(b) <= op_norm[a,b,Continuous_Function[a,b]](LC)")
       (("1"
         (label "TVle" -1)
         (inst + "gg")
         (case "LC = fun_to_op(gg)")
         (("1"
           (assert)
           (case "op_norm[a,b,Continuous_Function[a,b]](LC) <= total_variation(a,b,gg)(b)")
           (("1" (assert))
            ("2"
             (hide 2)
             (hide "TVle")
             (lemma "fun_to_op_bound")
             (typepred "op_norm[a,b,Continuous_Function[a,b]](LC)")
             (inst -3 "total_variation(a,b,gg)(b)")
             (assert)
             (skosimp*)
             (inst - "f!1")
             (inst - "f!1" "gg")
             (assert))))
          ("2"
           (hide 2)
           (case "FORALL (epsil:posreal,ff:Continuous_Function[a,b]): EXISTS (delta:posreal): FORALL (P:partition(a,b),xis:xis?(a,b,P)): width(a,b,P)<delta and strictly_increasing?(P) IMPLIES abs(LB(step_approx(P,xis)(ff))-fun_to_op(gg)(ff)) < epsil")
           (("1"
             (case "FORALL (ff:Continuous_Function[a,b]): LC(ff) = fun_to_op(gg)(ff)")
             (("1" (decompose-equality +))
              ("2"
               (hide 2)
               (skeep)
               (case "FORALL (epsil:posreal): abs(LC(ff)-fun_to_op(gg)(ff)) < 32*epsil")
               (("1"
                 (case "abs(LC(ff)-fun_to_op(gg)(ff)) = 0")
                 (("1" (lemma "abs_eq_0") (inst?) (assert))
                  ("2"
                   (hide 2)
                   (inst - "abs(LC(ff)-fun_to_op(gg)(ff))/64")
                   (("1" (assert)) ("2" (cross-mult 1) (assert))))))
                ("2"
                 (hide 2)
                 (case "FORALL (epsil:posreal,ff:Continuous_Function[a,b]): EXISTS (delta:posreal): FORALL (P:partition(a,b),xis:xis?(a,b,P)):
                                                                                                                                                                                                                                                                                                                                                         strictly_increasing?(P) AND width(a,b,P)<delta IMPLIES abs(LC(ff)-LB(step_approx(P,xis)(ff)))<epsil")
                 (("1"
                   (skeep)
                   (inst - "epsil" "ff")
                   (inst - "epsil" "ff")
                   (skosimp*)
                   (lemma "partition_exists")
                   (inst - "a" "b" "min(delta!1,delta!2)")
                   (assert)
                   (skeep -)
                   (name "SSP" "strictly_sort(P)")
                   (case "width(a,b,SSP) < min(delta!1,delta!2)")
                   (("1"
                     (hide -2)
                     (hide -2)
                     (name "xis" "gen_xis(a,b,SSP)")
                     (inst - "SSP" "xis")
                     (assert)
                     (inst - "SSP" "xis")
                     (assert)
                     (hide-all-but (-3 -4 +))
                     (grind :exclude ("stop_approx" "fun_to_op")))
                    ("2"
                     (lemma "partition_union_is_strictly_sort")
                     (inst - "a" "b")
                     (assert)
                     (inst - "P")
                     (lemma "partition_union_width")
                     (inst - "a" "b")
                     (assert)
                     (inst - "P" "P")
                     (assert))
                    ("3"
                     (lemma "partition_strictly_sort")
                     (inst - "a" "b")
                     (assert)
                     (inst - "P")
                     (flatten)
                     (assert)
                     (skosimp*)
                     (inst - "i!1")
                     (ground))))
                  ("2"
                   (hide 2)
                   (skosimp*)
                   (typepred "LB")
                   (expand "bounded_linear_operator?")
                   (flatten)
                   (expand "bounded_op?")
                   (skosimp*)
                   (lemma "step_approx_def")
                   (inst - "ff!1" "epsil!1/(M!1+1)")
                   (skosimp*)
                   (inst + "delta!1")
                   (skeep)
                   (inst - "P" "xis")
                   (assert)
                   (inst "LBLC" "ff!1")
                   (replace "LBLC" :dir rl)
                   (case "LB(ff!1) - LB(step_approx(P, xis)(ff!1)) = LB(ff!1-step_approx(P,xis)(ff!1))")
                   (("1"
                     (replace -1)
                     (inst -3 "ff!1 - step_approx(P, xis)(ff!1)")
                     (case "fun_norm(ff!1 - step_approx(P, xis)(ff!1)) <= epsil!1/(M!1+1)")
                     (("1" (cross-mult -1) (assert))
                      ("2"
                       (hide 2)
                       (typepred
                        "fun_norm(ff!1 - step_approx(P, xis)(ff!1))")
                       (inst -3 "epsil!1/(M!1+1)")
                       (assert)
                       (skosimp*)
                       (inst -5 "x!1")
                       (expand "-")
                       (assert))))
                    ("2"
                     (expand "linear_op?")
                     (flatten)
                     (expand "additive_op?")
                     (inst - "ff!1" "-1*step_approx(P,xis)(ff!1)")
                     (("1"
                       (expand "const_inv_op?")
                       (inst - "step_approx(P,xis)(ff!1)" "-1")
                       (case "ff!1+-1*step_approx(P,xis)(ff!1) = ff!1-step_approx(P,xis)(ff!1)")
                       (("1" (assert))
                        ("2"
                         (hide-all-but 1)
                         (grind :exclude ("step_approx"))
                         (decompose-equality +))))
                      ("2"
                       (hide-all-but 1)
                       (typepred "step_approx(P,xis)(ff!1)")
                       (assert)
                       (expand "*")
                       (assert)
                       (expand "bounded_on_int?")
                       (skosimp*)
                       (inst + "M!2")
                       (skosimp*)
                       (inst - "x!1")
                       (rewrite "abs_mult")
                       (expand "abs" + 1)
                       (assert))))
                    ("3"
                     (hide-all-but 1)
                     (expand "bounded_on_int?")
                     (typepred "step_approx(P,xis)(ff!1)")
                     (typepred "ff!1")
                     (lemma "continuous_implies_bounded")
                     (inst - "ff!1")
                     (hide -2)
                     (expand "bounded_on_int?")
                     (skosimp*)
                     (inst + "M!2+M!3")
                     (skosimp*)
                     (inst - "x!1")
                     (inst - "x!1")
                     (grind :exclude ("step_approx")))))))))))
            ("2"
             (case "FORALL (ff:Continuous_Function[a,b],P:partition(a,b),xis:xis?(a,b,P)): strictly_increasing?(P) IMPLIES LB(step_approx(P,xis)(ff)) = Rie_sum(a,b,gg,P,xis,ff)")
             (("1"
               (lemma "RS_integrable_cont_BV")
               (skeep)
               (inst - "a" "b" "ff" "gg")
               (assert)
               (split -)
               (("1"
                 (copy -1)
                 (expand "integrable?" -1)
                 (skosimp*)
                 (lemma "integral_def")
                 (inst - "a" "b" "ff" "gg" "S!1")
                 (assert)
                 (case "fun_to_op(gg)(ff) = S!1")
                 (("1"
                   (replace -1)
                   (expand "integral?")
                   (inst - "epsil")
                   (skosimp*)
                   (inst + "delta!1")
                   (skosimp*)
                   (inst - "P!1")
                   (assert)
                   (inst - "Rie_sum(a,b,gg,P!1,xis!1,ff)")
                   (("1"
                     (inst - "ff" "P!1" "xis!1")
                     (assert)
                     (replace -5)
                     (hide-all-but (-3 1))
                     (grind :exclude "Rie_sum"))
                    ("2"
                     (lemma "Riemann?_Rie")
                     (inst - "a" "b" "ff" "gg")
                     (split -)
                     (("1" (inst - "P!1" "xis!1")) ("2" (assert))))))
                  ("2" (expand "fun_to_op" 1) (propax))))
                ("2"
                 (typepred "ff")
                 (hide-all-but (-1 1))
                 (expand "continuous?")
                 (expand "continuous_on_int?")
                 (expand "continuous?")
                 (skosimp*)
                 (inst - "x!1")
                 (("1"
                   (expand "continuous_at?")
                   (skosimp*)
                   (inst - "epsilon!1")
                   (skosimp*)
                   (inst + "delta!1")
                   (skosimp*)
                   (inst - "y!1")
                   (("1" (assert))
                    ("2" (expand "Intab") (expand "restrict") (propax))))
                  ("2" (expand "Intab") (expand "restrict") (propax))))
                ("3"
                 (expand "bounded_variation?")
                 (inst + "op_norm[a,b,Continuous_Function[a,b]](LC)")
                 (skeep)
                 (inst - "strictly_sort(P)")
                 (("1"
                   (assert)
                   (lemma "variation_on_strictly_sort")
                   (inst - "a" "b")
                   (assert)
                   (inst - "P")
                   (assert))
                  ("2"
                   (hide-all-but 1)
                   (lemma "partition_strictly_sort")
                   (inst - "a" "b")
                   (assert)
                   (inst - "P"))))))
              ("2"
               (hide 2)
               (hide 2)
               (skeep)
               (case "LB(step_approx(P, xis)(ff)) = sigma[below(P`length - 1)]
                                                                                                                                                                                                                             (0, P`length - 2,
                                                                                                                                                                                                                              LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                ff(xis`seq(n)) * LB(char_fun(P`seq(n), P`seq(1 + n))))")
               (("1"
                 (replace -1)
                 (hide -1)
                 (expand "Rie_sum" +)
                 (rewrite "sigma_restrict_eq")
                 (hide 2)
                 (decompose-equality +)
                 (("1"
                   (expand "restrict")
                   (lemma "char_fun_minus")
                   (inst - "a" "P`seq(x!1)" "P`seq(1+x!1)")
                   (assert)
                   (case "a <= P`seq(x!1) AND P`seq(x!1) < P`seq(1 + x!1)")
                   (("1"
                     (flatten)
                     (assert)
                     (expand "gg" +)
                     (case "Intab(P`seq(1+x!1)) AND Intab(P`seq(x!1))")
                     (("1"
                       (flatten)
                       (assert)
                       (lift-if)
                       (assert)
                       (ground)
                       (hide 1)
                       (typepred "LB")
                       (expand "bounded_linear_operator?")
                       (expand "linear_op?")
                       (case "LB(char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))) = LB(char_fun(a, P`seq(1 + x!1))) - LB(char_fun(a, P`seq(x!1)))")
                       (("1" (assert))
                        ("2"
                         (hide 2)
                         (flatten)
                         (expand "additive_op?")
                         (inst - "char_fun(a, P`seq(1 + x!1))"
                          "-1*char_fun(a, P`seq(x!1))")
                         (("1"
                           (expand "const_inv_op?")
                           (inst - "char_fun(a,P`seq(x!1))" "-1")
                           (case "char_fun(a, P`seq(1 + x!1)) + -1 * char_fun(a, P`seq(x!1)) = char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))")
                           (("1" (assert))
                            ("2"
                             (decompose-equality +)
                             (expand "-")
                             (expand "+")
                             (expand "*")
                             (assert))))
                          ("2"
                           (expand "bounded_on_int?")
                           (inst + "1")
                           (hide-all-but 1)
                           (grind))))
                        ("3"
                         (hide-all-but 1)
                         (expand "bounded_on_int?")
                         (inst + "2")
                         (grind))))
                      ("2" (hide-all-but 1) (expand "Intab") (propax))))
                    ("2"
                     (expand "strictly_increasing?")
                     (inst - "x!1" "1+x!1")
                     (assert)
                     (ground))))
                  ("2"
                   (hide-all-but 1)
                   (skeep)
                   (expand "bounded_on_int?")
                   (inst + "1")
                   (grind))))
                ("2"
                 (hide 2)
                 (expand "step_approx" +)
                 (case "FORALL (nn:below(P`length-1)): LB(LAMBDA (x:INTab):
                                                                                                                                                                                               sigma[below(P`length - 1)]
                                                                                                                                                                                                   (0, nn,
                                                                                                                                                                                                    LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                      ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x)))
                                                                                                                                                                                           =
                                                                                                                                                                                           sigma[below(P`length - 1)]
                                                                                                                                                                                               (0, nn,
                                                                                                                                                                                                LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                  ff(xis`seq(n)) * LB(char_fun(P`seq(n), P`seq(1 + n))))")
                 (("1" (inst - "P`length-2"))
                  ("2"
                   (hide 2)
                   (induct "nn")
                   (("1"
                     (assert)
                     (expand "sigma")
                     (expand "sigma")
                     (typepred "LB")
                     (expand "bounded_linear_operator?")
                     (expand "linear_op?")
                     (expand "const_inv_op?")
                     (flatten)
                     (inst - "char_fun(P`seq(0),P`seq(1))"
                      "ff(xis`seq(0))")
                     (expand "*")
                     (propax))
                    ("2"
                     (skolem 1 "nn")
                     (flatten)
                     (expand "sigma" +)
                     (replace -2 :dir rl)
                     (typepred "LB")
                     (expand "bounded_linear_operator?")
                     (expand "linear_op?")
                     (expand "additive_op?")
                     (flatten)
                     (inst -
                      "LAMBDA (x:INTab):
                                                                                                                                                                                       sigma(0, nn,
                                                                                                                                                                                             LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                               ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x))"
                      "LAMBDA (x:INTab):
                                                                                                                                                                                       ff(xis`seq(1 + nn)) *
                                                                                                                                                                                         char_fun(P`seq(1 + nn), P`seq(2 + nn))(x)")
                     (("1"
                       (expand "+")
                       (replace -2)
                       (expand "const_inv_op?")
                       (inst - "char_fun(P`seq(1 + nn), P`seq(2 + nn))"
                        "ff(xis`seq(1 + nn))")
                       (expand "*")
                       (assert))
                      ("2"
                       (hide-all-but 1)
                       (expand "bounded_on_int?")
                       (inst + "abs(ff(xis`seq(1+nn)))")
                       (grind))
                      ("3"
                       (hide-all-but 1)
                       (expand "bounded_on_int?")
                       (inst + "fun_norm(ff)*(nn+1)")
                       (skeep)
                       (case "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                                                                                        (0, mm,
                                                                                                                                                                                                                                                                         LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                           ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                                                                                 <= fun_norm(ff) * (mm + 1)")
                       (("1" (inst - "nn"))
                        ("2"
                         (hide 2)
                         (induct "mm")
                         (("1"
                           (assert)
                           (expand "sigma")
                           (expand "sigma")
                           (typepred "fun_norm(ff)")
                           (inst - "xis`seq(0)")
                           (hide -3)
                           (grind))
                          ("2"
                           (skolem 1 "mm")
                           (assert)
                           (flatten)
                           (expand "sigma" +)
                           (lemma "triangle")
                           (inst?)
                           (case "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                                                                                        char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                           (("1" (assert))
                            ("2"
                             (hide 2)
                             (hide -1)
                             (hide -2)
                             (typepred "fun_norm(ff)")
                             (inst - "xis`seq(1+mm)")
                             (hide -3)
                             (grind))))))))))
                    ("3"
                     (hide-all-but 1)
                     (skosimp*)
                     (expand "bounded_on_int?")
                     (inst + "1")
                     (grind))
                    ("4"
                     (hide-all-but 1)
                     (skeep)
                     (expand "bounded_on_int?")
                     (inst + "fun_norm(ff)*(nn+1)")
                     (skeep)
                     (case "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                                                                                  (0, mm,
                                                                                                                                                                                                                                                                   LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                     ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                                                                           <= fun_norm(ff) * (mm + 1)")
                     (("1" (inst - "nn"))
                      ("2"
                       (hide 2)
                       (induct "mm")
                       (("1"
                         (assert)
                         (expand "sigma")
                         (expand "sigma")
                         (typepred "fun_norm(ff)")
                         (inst - "xis`seq(0)")
                         (hide -3)
                         (grind))
                        ("2"
                         (skolem 1 "mm")
                         (assert)
                         (flatten)
                         (expand "sigma" +)
                         (lemma "triangle")
                         (inst?)
                         (case "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                                                                                  char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                         (("1" (assert))
                          ("2"
                           (hide 2)
                           (hide -1)
                           (hide -2)
                           (typepred "fun_norm(ff)")
                           (inst - "xis`seq(1+mm)")
                           (hide -3)
                           (grind))))))))))
                  ("3"
                   (hide-all-but 1)
                   (skosimp*)
                   (expand "bounded_on_int?")
                   (inst + "1")
                   (grind))
                  ("4"
                   (skeep)
                   (hide-all-but 1)
                   (expand "bounded_on_int?")
                   (inst + "fun_norm(ff)*(nn+1)")
                   (skeep)
                   (case "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                                                                            (0, mm,
                                                                                                                                                                                                                                                             LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                               ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                                                                     <= fun_norm(ff) * (mm + 1)")
                   (("1" (inst - "nn"))
                    ("2"
                     (hide 2)
                     (induct "mm")
                     (("1"
                       (assert)
                       (expand "sigma")
                       (expand "sigma")
                       (typepred "fun_norm(ff)")
                       (inst - "xis`seq(0)")
                       (hide -3)
                       (grind))
                      ("2"
                       (skolem 1 "mm")
                       (assert)
                       (flatten)
                       (expand "sigma" +)
                       (lemma "triangle")
                       (inst?)
                       (case "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                                                                            char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                       (("1" (assert))
                        ("2"
                         (hide 2)
                         (hide -1)
                         (hide -2)
                         (typepred "fun_norm(ff)")
                         (inst - "xis`seq(1+mm)")
                         (hide -3)
                         (grind))))))))))
                ("3"
                 (hide-all-but 1)
                 (skeep)
                 (expand "bounded_on_int?")
                 (inst + "1")
                 (grind))))))))))
        ("2"
         (hide 2)
         (typepred "total_variation(a,b,gg)(b)")
         (hide -2)
         (assert)
         (inst -3 "op_norm[a,b,Continuous_Function[a,b]](LC)")
         (assert)
         (skosimp*)
         (inst - "strictly_sort(P!1)")
         (("1"
           (assert)
           (inst - "strictly_sort(P!1)")
           (assert)
           (lemma "variation_on_strictly_sort")
           (inst - "a" "b")
           (assert)
           (inst - "P!1")
           (assert))
          ("2"
           (hide-all-but 1)
           (typepred "b")
           (lemma "partition_strictly_sort")
           (inst - "a" "b")
           (assert)
           (inst - "P!1"))))
        ("3"
         (hide 2)
         (expand "bounded_variation?")
         (inst + "op_norm[a,b,Continuous_Function[a,b]](LC)")
         (skeep)
         (inst - "strictly_sort(P)")
         (("1"
           (assert)
           (lemma "variation_on_strictly_sort")
           (inst - "a" "b")
           (assert)
           (inst - "P")
           (lemma "variation_on_strictly_sort")
           (inst - "a" "b")
           (assert))
          ("2"
           (hide-all-but 1)
           (typepred "b")
           (lemma "partition_strictly_sort")
           (inst - "a" "b")
           (("1" (assert) (inst - "P")) ("2" (assert)) ("3" (assert))))))
        ("4" (typepred "b") (assert)) ("5" (assert)) ("6" (assert))))
      ("2"
       (hide 2)
       (skeep)
       (name "siggy"
             "(# length := P`length-1, seq:= (LAMBDA (nn:nat): IF nn >= P`length THEN default[INTab] ELSE sign(gg(P`seq(nn+1))-gg(P`seq(nn))) ENDIF) #)")
       (case "FORALL (mm: below(P`length - 1)):
                                                                 bounded_on_int?[a, b]
                                                                     (LAMBDA (x:INTab):
                                                                        sigma[below(P`length - 1)]
                                                                            (0, mm,
                                                                             LAMBDA (nn: below(P`length - 1)):
                                                                               siggy`seq(nn) *
                                                                                char_fun(P`seq(nn), P`seq(1 + nn))(x)))")
       (("1"
         (label "blem" -1)
         (hide "blem")
         (case "FORALL (mm:below(P`length-1)): LB(LAMBDA (x:INTab):
                                                                                                                                  sigma[below(P`length - 1)]
                                                                                                                                      (0, mm,
                                                                                                                                       LAMBDA (nn: below(P`length - 1)):
                                                                                                                                         siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x))) =
                                                                                                                                  sigma[below(P`length - 1)]
                                                                                                                                      (0, mm,
                                                                                                                                       LAMBDA (nn: below(P`length - 1)):
                                                                                                                                         siggy`seq(nn) * LB(char_fun(P`seq(nn), P`seq(1 + nn))))")
         (("1"
           (label "alem" -1)
           (hide "alem")
           (name "sigfun"
                 "LAMBDA (x:INTab): sigma[below(P`length-1)](0,P`length-2,LAMBDA (nn:below(P`length-1)): siggy`seq(nn)*char_fun(P`seq(nn),P`seq(1+nn))(x))")
           (case "variation_on(a,b,P)(gg) = LB(sigfun) AND fun_norm(sigfun) <= 1")
           (("1"
             (flatten)
             (name "NN" "op_norm[a, b, Bounded_Function[a,b]](LB)")
             (typepred "NN")
             (inst - "sigfun")
             (expand "abs" -2)
             (assert)
             (mult-by -6 "NN")
             (assert))
            ("2"
             (hide 2)
             (split +)
             (("1"
               (expand "sigfun" +)
               (reveal "alem")
               (copy "alem")
               (hide "alem")
               (inst - "P`length-2")
               (replace -1)
               (hide -1)
               (expand "variation_on" +)
               (assert)
               (rewrite "sigma_restrict_eq")
               (("1"
                 (hide 2)
                 (decompose-equality +)
                 (("1"
                   (expand "restrict")
                   (case "gg(P`seq(1 + x!1)) - gg(P`seq(x!1)) = LB(char_fun(P`seq(x!1), P`seq(1 + x!1)))")
                   (("1"
                     (hide-all-but (-1 1))
                     (replace -1)
                     (expand "siggy")
                     (replace -1)
                     (hide -1)
                     (grind :exclude "char_fun"))
                    ("2"
                     (hide 2)
                     (expand "gg" +)
                     (case "Intab(P`seq(1 + x!1)) AND Intab(P`seq(x!1))")
                     (("1"
                       (flatten)
                       (assert)
                       (lift-if)
                       (lift-if)
                       (lift-if)
                       (assert)
                       (ground)
                       (("1"
                         (name "zerofun" "(LAMBDA (x:INTab): 0)")
                         (case "char_fun(P`seq(x!1),P`seq(1+x!1)) = zerofun")
                         (("1"
                           (replace -1)
                           (typepred "LB")
                           (expand "bounded_linear_operator?")
                           (expand "linear_op?")
                           (expand "additive_op?")
                           (flatten)
                           (inst - "zerofun" "zerofun")
                           (case "zerofun+zerofun = zerofun")
                           (("1" (assert))
                            ("2"
                             (hide-all-but 1)
                             (decompose-equality +)
                             (expand "zerofun")
                             (propax))))
                          ("2"
                           (replace -1 :dir rl)
                           (replace -2)
                           (replace -3)
                           (hide-all-but 1)
                           (grind)
                           (expand "char_fun")
                           (grind)
                           (decompose-equality +))))
                        ("2"
                         (typepred "P")
                         (expand "increasing?")
                         (inst - "x!1" "1+x!1")
                         (assert))
                        ("3"
                         (case "P`seq(x!1) < P`seq(1+x!1)")
                         (("1"
                           (assert)
                           (lemma "char_fun_minus")
                           (expand "Intab")
                           (flatten)
                           (inst - "a" "P`seq(x!1)" "P`seq(1+x!1)")
                           (assert)
                           (replace -1 :dir rl)
                           (hide-all-but 2)
                           (typepred "LB")
                           (expand "bounded_linear_operator?")
                           (expand "linear_op?")
                           (expand "additive_op?")
                           (expand "const_inv_op?")
                           (flatten)
                           (inst - "char_fun(a, P`seq(1 + x!1))"
                            "-1*char_fun(a, P`seq(x!1))")
                           (("1"
                             (inst - "char_fun(a, P`seq(x!1))" "-1")
                             (case "char_fun(a, P`seq(1 + x!1)) + -1 * char_fun(a, P`seq(x!1)) = char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))")
                             (("1" (assert))
                              ("2"
                               (hide-all-but 1)
                               (expand "*")
                               (expand "-")
                               (expand "+")
                               (propax))))
                            ("2"
                             (hide-all-but 1)
                             (expand "bounded_on_int?")
                             (inst + "1")
                             (grind))))
                          ("2"
                           (expand "strictly_increasing?")
                           (inst - "x!1" "1+x!1")
                           (assert)
                           (ground))))))
                      ("2" (expand "Intab") (ground))))))
                  ("2"
                   (hide-all-but 1)
                   (skeep)
                   (expand "bounded_on_int?")
                   (inst + "1")
                   (grind))))
                ("2"
                 (hide-all-but 1)
                 (skeep)
                 (expand "bounded_on_int?")
                 (inst + "1")
                 (grind))))
              ("2"
               (case "FORALL (xy:INTab):abs(sigfun(xy)) <= 1")
               (("1"
                 (hide-all-but (-1 1))
                 (typepred "fun_norm(sigfun)")
                 (inst -3 "1")
                 (assert)
                 (skosimp*)
                 (inst -4 "x!1")
                 (assert))
                ("2"
                 (hide 2)
                 (skeep)
                 (case "sigfun(xy) = 0")
                 (("1" (replace -1) (assert))
                  ("2"
                   (case "FORaLL (jj:below(P`length-1)): char_fun(P`seq(jj),P`seq(1+jj))(xy) = 0")
                   (("1"
                     (expand "sigfun" 1)
                     (rewrite "sigma_restrict_eq_0")
                     (hide 2)
                     (skeep)
                     (inst - "i")
                     (assert))
                    ("2"
                     (skeep)
                     (case "sigfun(xy) = siggy`seq(jj)*char_fun(P`seq(jj), P`seq(1 + jj))(xy)")
                     (("1"
                       (replace -1)
                       (hide-all-but 3)
                       (expand "siggy")
                       (grind))
                      ("2"
                       (hide 4)
                       (expand "sigfun" 1)
                       (lemma "sigma_split[below(P`length-1)]")
                       (inst -
                        "LAMBDA (nn: below(P`length - 1)):
                                                                                                                                 siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(xy)"
                        "P`length-2" "0" "jj")
                       (assert)
                       (replace -1)
                       (hide -1)
                       (expand "sigma" + 1)
                       (case "sigma(0, jj - 1,
                                                                                                                                                             LAMBDA (nn: below(P`length - 1)):
                                                                                                                                                               siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(xy)) = 0")
                       (("1"
                         (replace -1)
                         (hide -1)
                         (assert)
                         (rewrite "sigma_restrict_eq_0")
                         (hide 2)
                         (skeep)
                         (hide-all-but (1 2 -3))
                         (case "a<=P`seq(jj) AND P`seq(jj) < P`seq(1+jj) AND P`seq(1+jj)<= P`seq(i) AND P`seq(i) < P`seq(1+i) AND P`seq(1+i) <= b")
                         (("1" (hide -2) (grind))
                          ("2"
                           (hide-all-but (-1 1))
                           (expand "strictly_increasing?")
                           (inst-cp - "jj" "1+jj")
                           (inst - "i" "1+i")
                           (assert)
                           (typepred "P")
                           (expand "increasing?")
                           (inst - "1+jj" "i")
                           (assert)
                           (inst-cp - "jj")
                           (inst - "1+i")
                           (ground))))
                        ("2"
                         (hide 2)
                         (rewrite "sigma_restrict_eq_0")
                         (hide 2)
                         (skeep)
                         (hide-all-but (1 2 -3))
                         (case "a<=P`seq(i) AND P`seq(i) < P`seq(1+i) AND P`seq(1+i) <= P`seq(jj) AND P`seq(jj) < P`seq(jj+1) AND P`seq(jj+1) <= b")
                         (("1" (hide -2) (grind))
                          ("2"
                           (hide-all-but (-1 1))
                           (expand "strictly_increasing?")
                           (inst-cp - "i" "1+i")
                           (inst - "jj" "1+jj")
                           (assert)
                           (typepred "P")
                           (expand "increasing?")
                           (inst - "1+i" "jj")
                           (inst-cp - "i")
                           (inst - "1+jj")
                           (assert)
                           (ground))))))))))))))))
            ("3"
             (hide-all-but 1)
             (reveal "blem")
             (flatten)
             (expand "sigfun" +)
             (inst - "P`length-2"))
            ("4"
             (hide-all-but 1)
             (reveal "blem")
             (inst - "P`length-2")
             (expand "sigfun")
             (propax))))
          ("2"
           (hide 2)
           (induct "mm")
           (("1"
             (assert)
             (expand "sigma")
             (expand "sigma")
             (typepred "LB")
             (expand "bounded_linear_operator?")
             (expand "linear_op?")
             (expand "const_inv_op?")
             (flatten)
             (inst - "char_fun(P`seq(0), P`seq(1))" "siggy`seq(0)")
             (expand "*")
             (propax))
            ("2"
             (skolem 1 "mm")
             (flatten)
             (assert)
             (expand "sigma" + 2)
             (replace -2 :dir rl)
             (typepred "LB")
             (expand "bounded_linear_operator?")
             (expand "linear_op?")
             (flatten)
             (expand "const_inv_op?")
             (inst - "char_fun(P`seq(1 + mm), P`seq(2 + mm))"
              "siggy`seq(1+mm)")
             (replace -3 :dir rl)
             (expand "additive_op?")
             (inst -
              "lambda (x:INTab): sigma[below(P`length - 1)]
                                                                                              (0, mm,
                                                                                               LAMBDA (nn: below(P`length - 1)):
                                                                                                 siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x))"
              "siggy`seq(1 + mm) * char_fun(P`seq(1 + mm), P`seq(2 + mm))")
             (("1"
               (replace -2 :dir rl)
               (assert)
               (case "(lambda (x:INTab): sigma[below(P`length - 1)]
                                                                                                                                       (0, 1 + mm,
                                                                                                                                        LAMBDA (nn: below(P`length - 1)):
                                                                                                                                          siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x)))=((LAMBDA (x:INTab):
                                                                                                                                     sigma[below(P`length - 1)]
                                                                                                                                         (0, mm,
                                                                                                                                          LAMBDA (nn: below(P`length - 1)):
                                                                                                                                            siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x)))
                                                                                                                                   + siggy`seq(1 + mm) * char_fun(P`seq(1 + mm), P`seq(2 + mm)))")
               (("1" (assert))
                ("2"
                 (hide 2)
                 (decompose-equality +)
                 (expand "+")
                 (expand "sigma" + 1)
                 (assert)
                 (expand "*")
                 (propax))))
              ("2" (hide-all-but 1) (reveal "blem") (inst?))))
            ("3"
             (hide-all-but 1)
             (skeep)
             (expand "bounded_on_int?")
             (inst + "1")
             (grind))
            ("4" (reveal "blem") (propax))))
          ("3"
           (hide-all-but 1)
           (skeep)
           (expand "bounded_on_int?")
           (inst + "1")
           (grind))
          ("4" (reveal "blem") (propax))))
        ("2"
         (hide-all-but 1)
         (skeep)
         (expand "bounded_on_int?")
         (inst + "mm+1")
         (skosimp*)
         (case "FORALL (rr:below(P`length-1)):abs(sigma[below(P`length - 1)]
                                                                                                              (0, rr,
                                                                                                               LAMBDA (nn: below(P`length - 1)):
                                                                                                                 siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x!1)))
                                                                                                       <= rr + 1")
         (("1" (inst - "mm"))
          ("2"
           (hide 2)
           (induct "rr")
           (("1"
             (assert)
             (expand "sigma")
             (expand "sigma")
             (expand "siggy")
             (grind))
            ("2"
             (skolem 1 "rr")
             (flatten)
             (assert)
             (expand "sigma" +)
             (name "CV1"
                   "sigma[below(P`length - 1)]
                                                                                                                                      (0, rr,
                                                                                                                                       LAMBDA (nn: below(P`length - 1)):
                                                                                                                                         siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x!1))")
             (replace -1)
             (hide-all-but (-3 +))
             (expand "siggy")
             (grind))))))))
      ("3" (hide-all-but 1) (skeep) (typepred "P") (assert))
      ("4" (skeep) (assert))))
    ("2"
     (hide-all-but 1)
     (skeep)
     (expand "bounded_on_int?")
     (inst + "1")
     (grind))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("ff" "gg"))
   (flatten)
   (lemma "continuous_implies_bounded[a,b]")
   (inst - "ff")
   (expand "zero_off_int_and_bounded?")
   (ground))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 ("gg" "ff"))
   (lemma "RS_integrable_cont_BV")
   (inst - "a" "b" "ff" "gg")
   (assert)
   (hide 2)
   (typepred "ff")
   (expand "continuous_on_int?")
   (expand "restrict")
   (expand "continuous?")
   (skosimp*)
   (inst - "x!1")
   (("1"
     (expand "continuous_at?")
     (skosimp*)
     (inst - "epsilon!1")
     (skosimp*)
     (inst + "delta!1")
     (skosimp*)
     (inst - "y!1")
     (("1" (assert)) ("2" (expand "Intab") (propax))))
    ("2" (expand "Intab") (propax))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skolem 1 "gg")
   (expand "bounded_linear_operator?")
   (split)
   (("1"
     (expand "bounded_op?")
     (inst + "total_variation(a,b,gg)(b)")
     (("1"
       (skolem 1 "f")
       (lemma "integral_norm_bounded")
       (inst - "f" "gg")
       (assert))
      ("2" (typepred "b") (assert)) ("3" (assert)) ("4" (assert))))
    ("2"
     (expand "linear_op?")
     (split)
     (("1"
       (expand "additive_op?")
       (skolem 1 ("ff" "hh"))
       (lemma "integral_sum")
       (inst?)
       (assert)
       (split -)
       (("1" (expand "+") (assert))
        ("2"
         (hide 2)
         (typepred "ff")
         (lemma "RS_integrable_cont_BV")
         (inst?)
         (assert)
         (hide 2)
         (expand "continuous_on_int?")
         (expand "continuous?")
         (skosimp*)
         (inst - "x!1")
         (("1"
           (expand "continuous_at?")
           (skosimp*)
           (inst - "epsilon!1")
           (skosimp*)
           (inst + "delta!1")
           (skosimp*)
           (inst - "y!1")
           (("1" (assert))
            ("2" (expand "restrict") (expand "Intab") (propax))))
          ("2" (expand "restrict") (expand "Intab") (propax))))
        ("3"
         (hide 2)
         (lemma "RS_integrable_cont_BV")
         (inst?)
         (assert)
         (hide 2)
         (typepred "hh")
         (expand "continuous_on_int?")
         (expand "continuous?")
         (skosimp*)
         (inst - "x!1")
         (("1"
           (expand "continuous_at?")
           (skosimp*)
           (inst - "epsilon!1")
           (skosimp*)
           (inst + "delta!1")
           (skosimp*)
           (inst - "y!1")
           (("1" (assert))
            ("2" (expand "restrict") (expand "Intab") (propax))))
          ("2" (expand "restrict") (expand "Intab") (propax))))))
      ("2"
       (expand "const_inv_op?")
       (skolem 1 ("f" "c"))
       (lemma "integral_scal")
       (inst?)
       (assert)
       (hide 2)
       (lemma "RS_integrable_cont_BV")
       (inst?)
       (assert)
       (hide 2)
       (typepred "f")
       (expand "continuous_on_int?")
       (expand "continuous?")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (expand "continuous_at?")
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "y!1")
         (("1" (assert))
          ("2" (expand "restrict") (expand "Intab") (propax))))
        ("2" (expand "restrict") (expand "Intab") (propax))))))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (typepred "fr")
   (expand "bounded_on_int?")
   (skosimp*)
   (inst + "M!1*(P`length+2)")
   (skosimp*)
   (case "FORALL (nnn:below(P`length-1)): abs(sigma[below(P`length - 1)]
                              (0, nnn,
                               LAMBDA (n: below(P`length - 1)):
                                 fr(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)))
                       <= M!1 * (nnn+4)")
   (("1" (inst?) (assert))
    ("2"
     (hide 2)
     (induct "nnn")
     (("1"
       (flatten)
       (expand "sigma")
       (expand "sigma")
       (inst - "xis`seq(0)")
       (expand "char_fun")
       (lift-if)
       (ground))
      ("2"
       (skolem 1 "nnn")
       (flatten)
       (expand "sigma" +)
       (inst - "xis`seq(1+nnn)")
       (grind :exclude "sigma"))))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "fullset")
   (expand "extend")
   (expand "bounded_linear_subspace?")
   (ground)
   (("1"
     (expand "funs_sum_closed?")
     (skolem 1 ("ff" "gg"))
     (ground)
     (typepred "ff")
     (typepred "gg")
     (lemma "sum_continuous")
     (inst?)
     (assert)
     (expand "continuous_on_int?")
     (inst?)
     (assert))
    ("2"
     (expand "funs_const_closed?")
     (skolem 1 ("ff" "cc"))
     (ground)
     (typepred "ff")
     (lemma "scal_continuous")
     (inst?)
     (assert)
     (expand "continuous_on_int?")
     (inst?)
     (assert))
    ("3"
     (expand "funs_bounded?")
     (skolem 1 "ff")
     (typepred "ff")
     (lemma "continuous_implies_bounded[a,b]")
     (inst - "ff"))
    ("4"
     (expand "funs_contain_constants?")
     (skeep)
     (ground)
     (expand "continuous_on_int?")
     (expand "continuous?")
     (expand "continuous_at?")
     (assert)
     (expand "ball")
     (expand "real_dist")
     (assert))
    ("5"
     (expand "funs_contain_continuous?")
     (skolem 1 "ff")
     (flatten)
     (ground))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: riesz_representation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (expand "fullset")
   (expand "extend")
   (expand "bounded_linear_subspace?")
   (ground)
   (("1"
     (expand "funs_sum_closed?")
     (skolem 1 ("ff" "gg"))
     (ground)
     (typepred "ff")
     (typepred "gg")
     (expand "bounded_on_int?")
     (skosimp*)
     (inst + "M!1+M!2")
     (skosimp*)
     (inst - "x!1")
     (inst - "x!1")
     (grind :exclude "zero_off_int?"))
    ("2"
     (expand "funs_const_closed?")
     (skolem 1 ("ff" "cc"))
     (ground)
     (typepred "ff")
     (expand "bounded_on_int?")
     (skosimp*)
     (inst + "abs(cc)*M!1")
     (skosimp*)
     (inst - "x!1")
     (expand "*")
     (rewrite "abs_mult")
     (mult-by -1 "abs(cc)")
     (assert))
    ("3" (expand "funs_bounded?") (propax))
    ("4"
     (expand "funs_contain_constants?")
     (skeep)
     (ground)
     (expand "bounded_on_int?")
     (inst + "abs(c)")
     (grind))
    ("5"
     (expand "funs_contain_continuous?")
     (skolem 1 "ff")
     (flatten)
     (ground)
     (lemma "continuous_implies_bounded[a,b]")
     (inst - "ff"))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: taylors
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "ii!1=0")
   (("1" (grind))
    ("2"
     (assert)
     (expand "derivable_n_times?")
     (lemma "extensionality" ("f" "f!1" "g" "LAMBDA xx: f!1(xx)"))
     (split -1)
     (("1"
       (skosimp*)
       (assert)
       (lemma "nderiv_derivable[T]" ("f" "f!1" "n" "n!1" "m" "ii!1"))
       (assert)
       (lemma "identity_derivable_fun[T]")
       (expand "I")
       (assert)
       (hide -2)
       (use "nderiv_term_derivable")
       (expand "derivable_n_times?" -1)
       (lemma "derivable_n_times_lem[T]")
       (inst?)
       (inst -1 "n!1")
       (assert))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: polynomial_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skolem 1 ("a"))
     (expand "polynomial")
     (expand "sigma")
     (expand "sigma")
     (lemma "const_derivable_fun[real]" ("b" "a(0)"))
     (expand "const_fun")
     (propax))
    ("2"
     (skolem 1 ("j"))
     (flatten)
     (skolem 1 ("a"))
     (expand "polynomial")
     (expand "sigma" 1)
     (inst - "a")
     (lemma "sum_derivable_fun[real]"
      ("f1"
       "LAMBDA (x: real): sigma(0, j, LAMBDA (i: nat): a(i) * (IF i = 0 THEN 1 ELSE x ^ i ENDIF))"
       "f2"
       "LAMBDA (x: real): a(1 + j) * x ^ (1 + j)"))
     (replace -2 -1)
     (lemma "scal_derivable_fun[real]"
      ("b" "a(1+j)" "f" "LAMBDA (x: real): x ^ (1 + j)"))
     (lemma "deriv_exp_fun[real]" ("f" "LAMBDA (x: real): x" "n" "1+j"))
     (lemma "identity_derivable_fun[real]")
     (expand "I")
     (replace -1 -2)
     (assert)
     (flatten -2)
     (expand "^" -2)
     (replace -2 -4)
     (expand "*" -4)
     (replace -4 -5)
     (expand "+" -5)
     (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: polynomial_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skolem 1 ("a"))
     (expand "polynomial")
     (expand "sigma")
     (expand "sigma")
     (lemma "deriv_const_fun[real]" ("b" "a(0)"))
     (expand "const_fun")
     (propax))
    ("2"
     (skolem 1 ("j"))
     (flatten)
     (skolem 1 ("a"))
     (expand "polynomial")
     (lemma "trichotomy" ("x" "j"))
     (split -1)
     (("1"
       (expand "sigma" 1)
       (inst - "a")
       (assert)
       (lemma "deriv_sum_fun[real]"
        ("ff1"
         "LAMBDA (x: real): sigma(0, j, LAMBDA (i: nat): a(i) * (IF i = 0 THEN 1 ELSE x ^ i ENDIF))"
         "ff2"
         "LAMBDA (x: real): a(1 + j) * x ^ (1 + j)"))
       (("1"
         (expand "+" -1)
         (replace -1 1)
         (replace -3 1)
         (hide -1 -3)
         (lemma "identity_derivable_fun[real]")
         (lemma "deriv_id_fun[real]")
         (expand "I")
         (expand "const_fun")
         (lemma "deriv_exp_fun[real]"
          ("f" "LAMBDA (x: real): x" "n" "1+j"))
         (assert)
         (expand "^" -1)
         (flatten -1)
         (replace -3 -2)
         (lemma "deriv_scal_fun[real]"
          ("b" "a(1+j)" "ff" "LAMBDA (t: real): t ^ (1 + j)"))
         (("1"
           (replace -3 -1)
           (expand "*" -1)
           (replace -1 1)
           (simplify 1)
           (propax))
          ("2" (propax))))
        ("2"
         (hide -2 2)
         (lemma "identity_derivable_fun[real]")
         (expand "I")
         (lemma "deriv_exp_fun[real]"
          ("f" "LAMBDA (x: real): x" "n" "1+j"))
         (assert)
         (expand "^")
         (flatten)
         (lemma "scal_derivable_fun[real]"
          ("b" "a(1+j)" "f" "LAMBDA (t: real): t ^ (1 + j)"))
         (assert)
         (expand "*")
         (expand "^" -1)
         (propax))
        ("3"
         (hide -2 2)
         (lemma "derivable_polynomial" ("a" "a" "n" "j"))
         (expand "polynomial")
         (propax))))
      ("2"
       (assert)
       (replace -1)
       (expand "sigma")
       (expand "sigma")
       (expand "^")
       (expand "expt")
       (expand "expt")
       (lemma "deriv_id_fun[real]")
       (lemma "deriv_const_fun[real]" ("b" "a(0)"))
       (expand "I")
       (expand "const_fun")
       (lemma "deriv_scal_fun[real]"
        ("b" "a(1)" "ff" "LAMBDA (x: real): x"))
       (("1"
         (expand "*" -1)
         (expand "sigma")
         (lemma "deriv_sum_fun[real]"
          ("ff1"
           "LAMBDA (x: real): a(0)"
           "ff2"
           "LAMBDA (x: real): a(1) * x"))
         (("1"
           (expand "+" -1)
           (replace -1 1)
           (replace -2 1)
           (replace -4 1)
           (replace -3 1)
           (simplify 1)
           (propax))
          ("2"
           (lemma "identity_derivable_fun[real]")
           (expand "I")
           (lemma "scal_derivable_fun[real]"
            ("b" "a(1)" "f" "LAMBDA (x: real): x"))
           (assert)
           (expand "*" -1)
           (propax))
          ("3"
           (lemma "const_derivable_fun[real]" ("b" "a(0)"))
           (expand "const_fun")
           (propax))))
        ("2"
         (lemma "identity_derivable_fun[real]")
         (expand "I")
         (propax))))
      ("3" (assert))))
    ("3" (hide 2) (grind))
    ("4"
     (hide 2)
     (skolem 1 ("a" "n"))
     (lemma "derivable_polynomial")
     (inst?))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: polynomial_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1" (skosimp*) (expand "derivable_n_times?") (propax))
    ("2"
     (skosimp*)
     (expand "derivable_n_times?" 1)
     (lemma "derivable_polynomial" ("a" "b!1" "n" "m!1"))
     (replace -1)
     (lemma "deriv_polynomial" ("a" "b!1" "n" "m!1"))
     (case "m!1=0")
     (("1"
       (replace -1)
       (replace -2 1)
       (inst - "LAMBDA (i:nat): 0" "0")
       (expand "polynomial" -4)
       (expand "sigma")
       (assert)
       (expand "sigma")
       (propax))
      ("2"
       (assert)
       (replace -1 2)
       (inst - "LAMBDA (i: nat): b!1(1 + i) + i * b!1(1 + i)"
        "m!1 - 1"))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: polynomial_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "n")
   (("1"
     (skosimp*)
     (assert)
     (expand "nderiv")
     (lemma "extensionality"
      ("f" "b!1" "g" "LAMBDA (i: nat): b!1(i) * C(i, 0)"))
     (split -1)
     (("1" (replace -1 1 rl) (propax))
      ("2" (hide 2) (skolem 1 ("x")) (rewrite "C_0") (assert))))
    ("2"
     (skolem 1 ("j"))
     (flatten)
     (skolem 1 ("b" "m"))
     (expand "nderiv" 1)
     (lemma "deriv_polynomial" ("a" "b" "n" "m"))
     (replace -1 1)
     (case "m=0")
     (("1"
       (hide -2)
       (assert)
       (inst - "LAMBDA (i:nat):0" "0")
       (case "j=0")
       (("1" (expand "nderiv" 1) (assert))
        ("2"
         (assert)
         (expand "polynomial" -2)
         (expand "sigma")
         (expand "sigma")
         (propax))))
      ("2"
       (assert)
       (hide -1)
       (inst - "LAMBDA (i: nat): b(1 + i) + i * b(1 + i)" "m - 1")
       (replace -1 2)
       (hide -1)
       (case "1+j> m")
       (("1" (assert))
        ("2"
         (assert)
         (lemma "extensionality"
          ("f"
           "LAMBDA (i_1: nat):
                                    factorial(j) * b(1 + i_1 + j) * C(i_1 + j, j) +
                                     i_1 * factorial(j) * b(1 + i_1 + j) * C(i_1 + j, j)
                                     + factorial(j) * b(1 + i_1 + j) * C(i_1 + j, j) * j"
           "g"
           "LAMBDA (i: nat):
                                     factorial(1 + j) * b(1 + i + j) * C(1 + i + j,1+j)"))
         (split -1)
         (("1" (replace -1 3) (propax))
          ("2"
           (hide 4)
           (skolem 1 ("i"))
           (name-replace "K1" "b(1 + i + j)")
           (expand "factorial" 1 4)
           (name-replace "K2" "factorial(j)")
           (case "i=0")
           (("1" (replace -1) (rewrite "C_n") (rewrite "C_n") (assert))
            ("2"
             (lemma "C_k_plus_1" ("n" "i+j" "k" "j"))
             (("1"
               (lemma "C_n_plus_1" ("n" "i+j" "k" "j+1"))
               (replace -1 2)
               (assert))
              ("2" (assert))))))))))))
    ("3" (hide 2) (grind))
    ("4"
     (hide 2)
     (lemma "derivable_n_times_polynomial")
     (skosimp*)
     (inst?))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: polynomial_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "derivable_n_times_polynomial" ("n" "n!1" "b" "b!1" "m" "m!1"))
   (propax))


proof_type: f_proof
decl_type: formula
library: analysis
theory: inverse_continuous_functions
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (expand "bijective?")
   (expand "continuous?")
   (skosimp)
   (delete -1)
   (expand "continuous?")
   (expand "surjective?")
   (inst-cp -1 "x0!1")
   (skolem!)
   (case-replace "inverse(g!1)(x0!1) = x!1")
   (("1"
     (delete -1)
     (skolem!)
     (case "EXISTS (d : posreal) : FORALL (u : T1) : x0!1 - g!1(u) < d IMPLIES x!1 - u < epsilon!1")
     (("1"
       (case "EXISTS (d : posreal) : FORALL (u : T1) : g!1(u) - x0!1 < d IMPLIES u - x!1 < epsilon!1")
       (("1"
         (skosimp*)
         (inst 1 "min(d!1, d!2)")
         (skosimp)
         (inst -3 "x!2")
         (skolem!)
         (case-replace "inverse(g!1)(x!2) = x!3")
         (("1"
           (delete -1)
           (inst -1 "x!3")
           (inst -2 "x!3")
           (delete -5)
           (grind :exclude "min"))
          ("2" (rewrite "bijective_inverse") (assert))))
        ("2"
         (delete -1 -2 2)
         (case "EXISTS (v : T1) : x!1 + epsilon!1 = v")
         (("1"
           (skolem!)
           (expand "strict_increasing?")
           (inst-cp -3 "x!1" "v!1")
           (assert)
           (assert)
           (inst 1 "g!1(v!1) - x0!1")
           (skosimp)
           (inst -4 "v!1" "u!1")
           (assert))
          ("2"
           (inst 2 "1")
           (skosimp)
           (lemma "connected_domain")
           (inst -1 "x!1" "u!1" "x!1 + epsilon!1")
           (assert)
           (inst + "epsilon!1 + x!1"))))))
      ("2"
       (delete -1 2)
       (case "EXISTS (v : T1) : x!1 - epsilon!1 = v")
       (("1"
         (skolem!)
         (expand "strict_increasing?")
         (inst-cp -3 "v!1" "x!1")
         (assert)
         (assert)
         (inst 1 "x0!1 - g!1(v!1)")
         (skosimp)
         (inst -4 "u!1" "v!1")
         (assert))
        ("2"
         (inst 2 "1")
         (skosimp)
         (lemma "connected_domain")
         (inst -1 "u!1" "x!1" "x!1 - epsilon!1")
         (assert)
         (inst + "-epsilon!1 + x!1")
         (assert))))))
    ("2" (rewrite "bijective_inverse") (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: inverse_continuous_functions
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (expand "bijective?")
   (expand "continuous?")
   (skosimp)
   (delete -1)
   (expand "continuous?")
   (expand "surjective?")
   (inst-cp -1 "x0!1")
   (skolem!)
   (skolem!)
   (case-replace "inverse(g!1)(x0!1) = x!1")
   (("1"
     (delete -1)
     (case "EXISTS (d : posreal) : FORALL (u : T1) : x0!1 - g!1(u) < d IMPLIES u - x!1 < epsilon!1")
     (("1"
       (case "EXISTS (d : posreal) : FORALL (u : T1) : g!1(u) - x0!1 < d IMPLIES x!1 - u < epsilon!1")
       (("1"
         (skosimp*)
         (inst 1 "min(d!1, d!2)")
         (skosimp)
         (inst -3 "x!2")
         (skolem!)
         (case-replace "inverse(g!1)(x!2) = x!3")
         (("1"
           (delete -1)
           (inst -1 "x!3")
           (inst -2 "x!3")
           (grind :exclude ("min" "strict_decreasing?")))
          ("2" (rewrite "bijective_inverse") (assert))))
        ("2"
         (delete -1 -2 2)
         (case "EXISTS (v : T1) : x!1 - epsilon!1 = v")
         (("1"
           (skolem!)
           (expand "strict_decreasing?")
           (inst-cp -3 "v!1" "x!1")
           (assert)
           (assert)
           (inst 1 "g!1(v!1) - x0!1")
           (skosimp)
           (inst -4 "u!1" "v!1")
           (assert))
          ("2"
           (inst 2 "1")
           (skosimp)
           (lemma "connected_domain")
           (inst -1 "u!1" "x!1" "x!1 - epsilon!1")
           (assert)
           (inst + "-epsilon!1 + x!1")
           (assert))))))
      ("2"
       (delete -1 2)
       (case "EXISTS (v : T1) : x!1 + epsilon!1 = v")
       (("1"
         (skolem!)
         (expand "strict_decreasing?")
         (inst-cp -3 "x!1" "v!1")
         (assert)
         (assert)
         (inst 1 "x0!1 - g!1(v!1)")
         (skosimp)
         (inst -4 "v!1" "u!1")
         (assert))
        ("2"
         (inst 2 "1")
         (skosimp)
         (lemma "connected_domain")
         (inst -1 "x!1" "u!1" "x!1 + epsilon!1")
         (assert)
         (inst + "epsilon!1 + x!1"))))))
    ("2" (rewrite "bijective_inverse") (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: inverse_continuous_functions
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (assert)
   (expand "bijective?")
   (flatten)
   (use "inj_monotone[T1]")
   (("1"
     (ground)
     (("1" (rewrite "inverse_incr")) ("2" (rewrite "inverse_decr"))
      ("3" (expand "injective?") (propax))))
    ("2"
     (lemma "connected_domain")
     (skosimp)
     (inst -1 "x!1" "y!1" "z!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "connected_deriv_domain[T1]")
   (lemma "connected_domain1")
   (lemma not_one_element1)
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "connected_deriv_domain[T2]")
   (lemma "connected_domain2")
   (lemma "not_one_element2")
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: Alternative
script:
  (""
   (skolem 1 ("F" "G" "f" "Y0"))
   (flatten)
   (lemma "derivative_equivalence3" ("f" "F" "D" "f(G(Y0))" "x" "G(Y0)"))
   (("1"
     (name "X0" "G(Y0)")
     (replace -1)
     (case "deriv(F, X0) = f(X0)")
     (("1"
       (case "derivable?(F, X0)")
       (("1"
         (assert)
         (skolem! -4)
         (flatten -4)
         (lemma "derivative_equivalence3"
          ("f" "G" "x" "Y0" "D" "1/f(G(Y0))"))
         (("1"
           (flatten -1)
           (hide -1)
           (split -1)
           (("1" (flatten -1))
            ("2"
             (hide 2)
             (case "FORALL (y: T2): psi!1(G(y)) /= 0")
             (("1"
               (inst + "LAMBDA (y:T2): 1/psi!1(G(y))")
               (split 1)
               (("1"
                 (lemma "cv_in_domain"
                  ("f" "psi!1" "x" "X0" "l" "f(X0)"))
                 (assert)
                 (replace -5 1)
                 (replace -1 1)
                 (replace -5 1 rl)
                 (case "continuous?(LAMBDA (y: T2): 1 / psi!1(G(y)), Y0)")
                 (("1" (rewrite continuity_def))
                  ("2"
                   (hide 2)
                   (lemma "inv_continuous[T2]"
                    ("g" "LAMBDA (y: T2): psi!1(G(y))" "x0" "Y0"))
                   (split -1)
                   (("1" (expand "/" -1) (propax))
                    ("2"
                     (hide 2)
                     (lemma "inverse_continuous[T1,T2]" ("g" "F"))
                     (("1"
                       (replace -10)
                       (case "inverse(F)=LAMBDA (y:T2): G(y)")
                       (("1"
                         (replace -1)
                         (case "continuous?[T1](psi!1,X0)")
                         (("1"
                           (expand "continuous?" -3)
                           (inst - "Y0")
                           (lemma "composition_cont[T2,T1]"
                            ("f" "G" "g" "psi!1" "x0" "Y0"))
                           (expand "o" -1)
                           (replace -9 -1)
                           (replace -2)
                           (split -1)
                           (("1" (propax))
                            ("2"
                             (hide-all-but (-3 1))
                             (expand "continuous?")
                             (propax))))
                          ("2"
                           (expand "convergence")
                           (expand "convergence")
                           (hide 2)
                           (hide -1 -2)
                           (lemma "continuity_def2[T1]"
                            ("f" "psi!1" "x0" "X0"))
                           (expand "convergent?")
                           (replace -1 1)
                           (inst + "f(X0)")
                           (expand "continuous?")
                           (assert))))
                        ("2"
                         (hide 2)
                         (hide-all-but (-10 -12 1))
                         (lemma "extensionality"
                          ("f"
                           "inverse(F)"
                           "g"
                           "(LAMBDA (y: T2): G(y))"))
                         (split -1)
                         (("1" (propax))
                          ("2"
                           (hide 2)
                           (skosimp*)
                           (lemma "bijective_inverse"
                            ("f" "F" "y" "x!1" "x" "G(x!1)"))
                           (lemma "comp_inverse_right_alt"
                            ("f" "F" "g" "G" "r" "x!1"))
                           (assert))))))
                      ("2"
                       (lemma "derivable_cont_fun[T1]" ("f" "F"))
                       (assert))
                      ("3" (inst + "Y0")) ("4" (inst + "X0"))
                      ("5"
                       (lemma "connected_domain1")
                       (expand "connected?")
                       (propax))))))
                  ("3" (propax))))
                ("2"
                 (skolem 1 ("Y1"))
                 (inst -6 "G(Y1)")
                 (lemma "comp_inverse_right_alt"
                  ("f" "F" "g" "G" "r" "Y1"))
                 (replace -1)
                 (lemma "comp_inverse_right_alt"
                  ("f" "F" "g" "G" "r" "Y0"))
                 (replace -6 -8 rl)
                 (replace -1 -8)
                 (lemma "div_cancel4"
                  ("y"
                   "G(Y1) - G(Y0)"
                   "x"
                   "Y1 - Y0"
                   "n0z"
                   "psi!1(G(Y1))"))
                 (assert))))
              ("2"
               (hide 2)
               (skolem 1 ("Y1"))
               (inst -5 "G(Y1)")
               (lemma "comp_inverse_right_alt"
                ("f" "F" "g" "G" "r" "Y1"))
               (lemma "comp_inverse_right_alt"
                ("f" "F" "g" "G" "r" "Y0"))
               (replace -2 -7)
               (replace -5 -7 rl)
               (replace -1)
               (copy -9)
               (expand "bijective?" -1)
               (flatten -1)
               (expand "injective?")
               (case "Y1 = Y0")
               (("1"
                 (lemma "cv_in_domain"
                  ("f" "psi!1" "x" "X0" "l" "f(X0)"))
                 (replace -9 * rl)
                 (replace -2)
                 (assert))
                ("2"
                 (inst -1 "G(Y1)" "G(Y0)")
                 (replace -3 -1)
                 (replace -4 -1)
                 (assert))))))))
          ("2"
           (use "not_one_element2")
           (expand "not_one_element?")
           (propax))
          ("3" (use "deriv_domain2"))))
        ("2" (expand "derivable?" -4) (inst -4 "X0"))))
      ("2" (expand "deriv" -5) (replace -5 1 rl) (assert))
      ("3" (lemma "not_one_element1") (propax))))
    ("2" (use "not_one_element1") (expand "not_one_element?") (propax))
    ("3" (use "deriv_domain1"))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("F" "G" "f"))
   (flatten)
   (lemma "inverse_derivable" ("F" "F" "G" "G" "f" "f"))
   (expand "derivable?" 1)
   (skolem 1 ("x"))
   (inst - "x")
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("F" "G" "f"))
   (flatten)
   (assert)
   (lemma "identity_derivable_fun[T2]")
   (("1"
     (lemma "deriv_id_fun[T2]")
     (expand "I")
     (lemma "composition_derivable_fun[T2,T1]" ("g" "F" "f" "G"))
     (("1"
       (assert)
       (lemma "deriv_comp_fun[T2,T1]")
       (inst - "G" "F")
       (lemma "extensionality"
        ("f" "deriv[T2](G)" "g" "(LAMBDA (x: T2): 1 / f(G(x)))"))
       (split -1)
       (("1" (propax))
        ("2"
         (hide 2)
         (skolem 1 ("x"))
         (lemma "extensionality" ("f" "F o G" "g" "LAMBDA (x: T2): x"))
         (split -1)
         (("1"
           (expand "o")
           (replace -1)
           (replace -4 -2)
           (hide -1 -3 -4 -5)
           (lemma "extensionality_postulate"
            ("f"
             "(LAMBDA (x: T2): 1)"
             "g"
             "(LAMBDA (x: T2): deriv(F)(G(x))) * deriv(G)"))
           (replace -1 -2 rl)
           (hide -1)
           (inst - "x")
           (expand "*" -1)
           (lemma "div_cancel3"
            ("x" "1" "n0z" "f(G(x))" "y" "deriv[T2](G)(x)"))
           (assert))
          ("2"
           (hide 2)
           (expand "o" 1)
           (skolem 1 ("y"))
           (typepred "y")
           (typepred "G(y)")
           (lemma "comp_inverse_right_surj_alt"
            ("f" "F" "g" "G" "r" "y"))
           (("1" (propax)) ("2" (expand "bijective?") (flatten -9))))))))
      ("2"
       (lemma "not_one_element1")
       (expand "not_one_element?")
       (propax))
      ("3" (lemma "deriv_domain1") (propax))
      ("4"
       (lemma "not_one_element2")
       (expand "not_one_element?")
       (propax))))
    ("2" (lemma "not_one_element2") (propax))
    ("3" (lemma "deriv_domain2") (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "inverse_derivable_fun")
   (inst - "F!1" "G!1" "f!1")
   (lemma "deriv_inverse_fun")
   (inst - "F!1" "G!1" "f!1")
   (assert))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem 1 ("F" "G" "f"))
   (flatten)
   (lemma "not_one_element2")
   (expand "not_one_element?")
   (propax))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: derivative_inverse
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "inverse_derivable")
   (assert)
   (expand "derivable?" 1)
   (skosimp*)
   (inst - "F!1" "G!1" "f!1" "x!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: restrict2_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (expand "derivable?")
   (skosimp*)
   (expand "restrict2")
   (inst?)
   (expand "derivable?")
   (expand "convergent?")
   (skosimp*)
   (inst + "l!1")
   (expand "convergence")
   (expand "NQ")
   (expand "convergence")
   (prop)
   (("1"
     (rewrite "deriv_TCC")
     (("1"
       (lemma "not_one_element_T1")
       (expand "not_one_element?")
       (propax))
      ("2" (lemma "deriv_domain_T1") (expand "deriv_domain?") (propax))))
    ("2"
     (skosimp*)
     (inst - "epsilon!1")
     (skosimp*)
     (inst + "delta!1")
     (skosimp*)
     (inst?)
     (("1" (assert))
      ("2"
       (hide 2)
       (expand "A")
       (expand "adh")
       (typepred "x!2")
       (expand "A")
       (assert)
       (typepred "x!1")
       (lemma "sub_dom")
       (inst?))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: restrict2_deriv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "f!1")
   (lemma "restrict2_derivable" ("f" "f!1"))
   (lemma "deriv_comp_fun[T1,T2]" ("ff" "LAMBDA (x:T1): x" "gg" "f!1"))
   (("1"
     (lemma "identity_derivable_fun[T1]")
     (lemma "deriv_id_fun[T1]")
     (expand "I")
     (replace -1)
     (expand "o")
     (expand "*")
     (expand "restrict2")
     (expand "deriv" 1)
     (hide -1 -2)
     (lemma "extensionality_postulate"
      ("f"
       "deriv(LAMBDA (x_1: T1): f!1(x_1))"
       "g"
       "(LAMBDA (x_1: T1): deriv(f!1)(x_1))"))
     (("1"
       (flatten -1)
       (hide -1)
       (split -1)
       (("1" (inst - "a!1") (expand "deriv" -1) (replace -1 1) (propax))
        ("2" (propax))))
      ("2" (propax))))
    ("2" (lemma "identity_derivable_fun[T1]") (expand "I") (propax))
    ("3"
     (hide-all-but 1)
     (lemma "not_one_element_T2")
     (expand "not_one_element?")
     (propax))
    ("4" (lemma "deriv_domain_T2") (propax))
    ("5"
     (lemma "not_one_element_T1")
     (expand "not_one_element?")
     (propax))
    ("6" (lemma "deriv_domain_T1") (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivatives_subtype
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "restrict")
   (expand "derivable?")
   (skosimp*)
   (inst?)
   (expand "derivable?")
   (expand "convergent?")
   (skosimp*)
   (inst + "l!1")
   (expand "convergence")
   (expand "fullset")
   (expand "convergence")
   (flatten)
   (assert)
   (split +)
   (("1"
     (hide -2)
     (hide -1)
     (expand "adh")
     (expand "deriv_domain?")
     (skosimp*)
     (inst - e!1 x!1)
     (skosimp*)
     (inst + "y!1")
     (expand "A")
     (propax))
    ("2"
     (hide -1)
     (skosimp*)
     (inst - "epsilon!1")
     (skosimp*)
     (inst + "delta!1")
     (skosimp*)
     (inst?)
     (("1" (assert) (expand "NQ") (propax))
      ("2" (hide 2) (typepred "x!2") (assert) (expand "A") (flatten))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: derivatives_subtype
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "del_neigh_all_lem[S]")
   (assert)
   (lemma "derivable_subtype")
   (inst?)
   (assert)
   (expand "restrict")
   (expand "deriv" 1 1)
   (apply-extensionality 1 :hide? t)
   (("1"
     (name "L1" "deriv(LAMBDA (s: S): f!1(s), x!1)")
     (replace -1)
     (name "L2" "deriv[T](f!1)(x!1)")
     (replace -1)
     (expand "derivable?")
     (inst?)
     (inst?)
     (expand "derivable?")
     (lemma "lim_e_del[(derivatives_def[S].A(x!1))]")
     (inst - "0" "NQ(LAMBDA (s: S): f!1(s), x!1)" "L1")
     (assert)
     (lemma "lim_e_del[(derivatives_def[T].A(x!1))]")
     (inst - "0" "NQ(f!1, x!1)" "L1")
     (("1"
       (assert)
       (expand "deriv")
       (expand "deriv")
       (assert)
       (hide -2 -3 -4 -5)
       (skosimp*)
       (inst - "e!1")
       (skosimp*)
       (expand "del_neigh_all?")
       (inst -3 "x!1")
       (skosimp*)
       (inst + "min(del!1,del!2)")
       (skosimp*)
       (inst?)
       (("1" (assert) (expand "NQ") (propax))
        ("2"
         (typepred "x!2")
         (expand "A")
         (assert)
         (flatten)
         (inst -4 "x!1+x!2")
         (assert))))
      ("2" (lemma "not_one_element") (propax))
      ("3" (lemma "deriv_domain") (propax))))
    ("2" (skosimp*) (expand "derivable?" -1) (inst?))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: derivatives_subtype
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma derivable_subtype)
   (inst?)
   (assert)
   (lemma "del_neigh_all_lem[S]")
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: deriv_sign
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "derivable?")
   (expand "convergent?")
   (inst + "0")
   (expand "convergence")
   (expand "fullset")
   (expand "convergence")
   (prop)
   (("1"
     (expand "adh")
     (skosimp*)
     (case "x!1 > 0")
     (("1" (inst + "e!1/2") (("1" (grind)) ("2" (grind))))
      ("2" (inst + "-e!1/2") (("1" (grind)) ("2" (grind))))))
    ("2"
     (skosimp*)
     (case "x!1 > 0")
     (("1"
       (expand "NQ")
       (expand "sign")
       (assert)
       (inst + "x!1/2")
       (skosimp*)
       (grind))
      ("2"
       (inst + "-x!1/2")
       (("1" (skosimp*) (grind)) ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: deriv_sign
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "restrict")
   (expand "deriv")
   (apply-extensionality 1 :hide? t)
   (("1"
     (expand "const_fun")
     (lemma "deriv_def")
     (inst?)
     (assert)
     (hide 2)
     (expand "convergence")
     (expand "fullset")
     (expand "NQ")
     (expand "convergence")
     (split +)
     (("1"
       (expand "adh")
       (lemma "deriv_domain_nzreal")
       (expand "deriv_domain?")
       (skosimp*)
       (inst - e!1 x!1)
       (skosimp*)
       (inst?)
       (grind))
      ("2"
       (skosimp*)
       (inst + "min(epsilon!1,abs(x!1/2))")
       (skosimp*)
       (grind))))
    ("2"
     (skosimp*)
     (lemma "sign_derivable")
     (inst?)
     (expand "restrict")
     (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: convex_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (lemma "convex_function_right_lt")
   (name "AA" "A-1")
   (label "aaname" -1)
   (name "CC" "A")
   (label "ccname" -1)
   (case "f(AA) >= f(CC)")
   (("1"
     (label "faacc" -1)
     (case "FORALL (x: real): A<=x AND x<=B IMPLIES f(x) >= ((B - AA) / (CC - AA)) * f(CC) - ((B - CC) / (CC - AA)) * f(AA)")
     (("1"
       (lemma "axiom_of_archimedes")
       (inst -
        "abs(((B - AA) / (CC - AA)) * f(CC) - ((B - CC) / (CC - AA)) * f(AA))")
       (("1"
         (skosimp*)
         (lemma "axiom_of_archimedes")
         (inst - "max(abs(f(A)),abs(f(B)))")
         (skosimp*)
         (case "FORALL (x: real): A <= x AND x <= B IMPLIES f(x) < i!2")
         (("1"
           (case "FORALL (x: real): A <= x AND x <= B IMPLIES f(x) > -i!1")
           (("1"
             (inst + "max(i!1,i!2)")
             (("1"
               (skeep)
               (inst - "x")
               (inst - "x")
               (assert)
               (expand "abs")
               (lift-if)
               (assert))
              ("2" (assert))))
            ("2" (hide 2) (skeep) (inst - "x") (inst - "x") (assert))))
          ("2"
           (lemma "convex_btw_pt_left_lt")
           (skeep)
           (inst - "A" "B" "i!2" "f" "x")
           (assert))))
        ("2" (assert))))
      ("2"
       (skeep)
       (label "xb" -2)
       (hide 2)
       (inst - "AA" "x" "CC" "f")
       (assert)
       (split)
       (("1"
         (field -1)
         (field 1)
         (case "(f(AA)-f(CC))*x<=(f(AA)-f(CC))*B")
         (("1" (assert))
          ("2" (copy "xb") (mult-by -1 "f(AA)-f(CC)") (assert))))
        ("2"
         (case "x = A")
         (("1"
           (replace "aaname" + rl)
           (replace "ccname" + rl)
           (assert)
           (replace -1)
           (field 2)
           (both-sides "-" "f(A)-f(A-1)*B+f(A-1)*A" 2)
           (assert)
           (factor 2)
           (div-by 2 "B-A")
           (assert))
          ("2" (assert))))))
      ("3" (assert))))
    ("2"
     (case "FORALL (x: real): A <= x AND x <= B IMPLIES f(A) <= f(x) AND f(x)<=f(B)")
     (("1"
       (lemma "axiom_of_archimedes")
       (inst - "max(abs(f(A)),abs(f(B)))")
       (skosimp*)
       (inst + "i!1")
       (("1"
         (skosimp*)
         (inst - "x!1")
         (assert)
         (flatten)
         (expand "abs")
         (lift-if)
         (assert))
        ("2" (assert))))
      ("2"
       (case "FORALL (x: real): A <= x AND x <= B IMPLIES f(A) <= f(x)")
       (("1"
         (skosimp*)
         (inst - "x!1")
         (assert)
         (case "f(B) > f(A)")
         (("1"
           (lemma "convex_btw_pt_right_lt")
           (inst - "A" "B" "max(f(B),f(A))" "f" "x!1")
           (assert)
           (expand "max")
           (propax))
          ("2"
           (inst - "A-1" "B" "A" "f")
           (assert)
           (field -6)
           (case "B > A")
           (("1"
             (case "f(A) * B + f(A - 1) * A - f(A) * A - f(A - 1) * B > 0")
             (("1" (assert))
              ("2"
               (both-sides "-" "f(A-1)*A-f(A)*A" 1)
               (assert)
               (factor 1)
               (div-by 1 "f(A)-f(A-1)"))))
            ("2"
             (lemma "axiom_of_archimedes")
             (inst - "abs(f(A))")
             (skosimp*)
             (inst + "i!1")
             (("1" (skosimp*) (assert)) ("2" (assert))))))))
        ("2"
         (skosimp*)
         (inst - "AA" "x!1" "CC" "f")
         (assert)
         (field -7)
         (replace "ccname" - rl)
         (replace "aaname" - rl)
         (assert)
         (both-sides "-" "f(A) - f(A-1)*x!1+f(A-1)*A")
         (case "f(A) * x!1 + f(A - 1) * A - f(A) * A - f(A - 1) * x!1 >= 0")
         (("1" (assert))
          ("2"
           (both-sides "+" "f(A-1)*x!1-f(A-1)*A" 1)
           (assert)
           (factor 1)
           (div-by 1 "x!1-A")
           (assert))))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: convex_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (name "t" "(C-B)/(C-A)")
   (label "tname" -1)
   (case "1-t = (B-A)/(C-A)")
   (("1"
     (label "mtname" -1)
     (expand "convex?")
     (inst - "A" "C" "t")
     (split)
     (("1"
       (case "C + t * A - t * C = B")
       (("1" (replace -1) (replace "tname" -2 rl) (field -2) (field 1))
        ("2" (replace "tname" + rl) (field 1))))
      ("2" (replace "tname" + rl) (cross-mult 1) (assert))
      ("3" (replace "tname" + rl) (cross-mult 1) (assert))))
    ("2" (replace "tname" + rl) (field 1))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: convex_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (name "t" "(B-A)/(C-A)")
   (label "tname" -1)
   (case "1-t = (C-B)/(C-A)")
   (("1"
     (label "mtname" -1)
     (expand "convex?")
     (inst - "C" "A" "t")
     (split)
     (("1"
       (case "A + t * C - t * A = B")
       (("1" (replace -1) (replace "tname" -2 rl) (field -2) (field 1))
        ("2" (replace "tname" + rl) (field 1))))
      ("2" (replace "tname" + rl) (cross-mult 1) (assert))
      ("3" (replace "tname" + rl) (cross-mult 1) (assert))))
    ("2" (replace "tname" + rl) (field 1))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: convex_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skosimp*)
   (lemma "convex_diff_quot_left_lt")
   (inst?)
   (assert)
   (inst - "A!1" "B!1" "C!1")
   (assert)
   (lemma "convex_diff_quot_right_lt")
   (inst?)
   (assert)
   (inst - "A!1" "B!1" "C!1")
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: convex_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (skeep)
   (name "rightquot" "(f(x+epsil)-f(x))/epsil")
   (label "rqname" -1)
   (name "leftquot" "(f(x)-f(x-epsil))/epsil")
   (label "lqname" -1)
   (name "totquot" "(f(x+epsil)-f(x-epsil))/(2*epsil)")
   (label "tqname" -1)
   (lemma "axiom_of_archimedes")
   (inst - "max(abs(totquot),max(abs(leftquot),abs(rightquot)))")
   (skosimp*)
   (inst + "i!1")
   (("1"
     (skeep)
     (label "idef" -1)
     (name "deltaquot" "(f(x+delta)-f(x))/delta")
     (label "dqname" -1)
     (case "deltaquot >= leftquot AND deltaquot <= rightquot")
     (("1"
       (flatten)
       (case-replace
        "abs(f(x + delta) - f(x)) / abs(delta) = abs(deltaquot)")
       (("1"
         (case "abs(deltaquot) <= abs(leftquot) OR abs(deltaquot) <= abs(rightquot)")
         (("1" (split) (("1" (assert)) ("2" (assert))))
          ("2" (flatten) (hide-all-but (-2 -3 1 2)) (grind))))
        ("2"
         (hide-all-but ("dqname" 1))
         (cross-mult 1)
         (cross-mult -1)
         (lemma "abs_mult")
         (inst - "deltaquot" "delta")
         (grind))))
      ("2"
       (split)
       (("1"
         (replace "dqname" + rl)
         (replace "lqname" + rl)
         (case "delta>=0")
         (("1"
           (lemma "convex_diff_quot_increasing")
           (inst?)
           (assert)
           (inst - "x-epsil" "x" "x+delta")
           (assert))
          ("2"
           (lemma "convex_diff_quot_left_lt")
           (inst?)
           (assert)
           (inst - "x-epsil" "x+delta" "x")
           (assert))))
        ("2"
         (replace "dqname" + rl)
         (replace "rqname" + rl)
         (case "delta >=0")
         (("1"
           (lemma "convex_diff_quot_right_lt")
           (inst?)
           (assert)
           (inst - "x" "x+delta" "x+epsil")
           (assert))
          ("2"
           (lemma "convex_diff_quot_increasing")
           (inst?)
           (assert)
           (inst - "delta+x" "x" "epsil+x")
           (assert))))))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: convex_function_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "convex_diff_quot_bounded")
   (inst?)
   (assert)
   (expand "continuous?")
   (expand "continuous?")
   (skeep)
   (inst - "x")
   (expand "continuous_at?")
   (skosimp*)
   (inst - "epsilon!1")
   (skosimp*)
   (case "M!1 > 0")
   (("1"
     (name "delta!1" "epsilon!1/M!1")
     (("1"
       (inst + "delta!1")
       (("1"
         (skeep)
         (expand "member")
         (expand "ball")
         (expand "real_dist")
         (name "newdelt" "y-x")
         (inst - "newdelt")
         (("1"
           (split)
           (("1"
             (cross-mult -1)
             (case "abs(newdelt) < delta!1")
             (("1"
               (both-sides "+" "x" -3)
               (assert)
               (replace -3 - rl)
               (case-replace "epsilon!1 = delta!1*M!1")
               (("1"
                 (mult-by -2 "M!1")
                 (lemma "abs_neg")
                 (inst - "f(x)-f(y)")
                 (assert))
                ("2" (assert))))
              ("2" (lemma "abs_neg") (inst - "y-x") (assert))))
            ("2"
             (lemma "abs_neg")
             (inst - "y-x")
             (assert)
             (case "delta!1 <= epsilon!1")
             (("1" (assert))
              ("2"
               (replace -3 + rl)
               (cross-mult 1)
               (div-by 1 "epsilon!1")
               (assert))))))
          ("2" (assert))))
        ("2"
         (case "delta!1 > 0")
         (("1" (assert))
          ("2" (replace -1 + rl) (cross-mult 1) (assert))))))
      ("2" (assert))))
    ("2" (inst - "epsilon!1") (expand "abs" -1 1) (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: inverse_fun_ms_continuous
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (label "bijf" -3)
   (lemma "continuous_open_sets[T2,d2,T1,d1]")
   (inst - "fullset[T2]" "inverse(f)")
   (expand "continuous?" +)
   (assert)
   (hide 2)
   (skosimp*)
   (rewrite "intersection_full")
   (lemma "open_in_fullset[T2,d2]")
   (inst - "inverse_image(inverse(f), Y!1)")
   (assert)
   (hide 2)
   (case "closed?[T1,d1](complement(Y!1))")
   (("1"
     (lemma "closed_subset_of_compact[T1,d1]")
     (inst - "fullset[T1]" "complement(Y!1)")
     (assert)
     (rewrite "subset_fullset")
     (lemma "continuous_image_of_compact")
     (inst - "complement(Y!1)" "f")
     (assert)
     (lemma "compact_closed[T2,d2]")
     (inst - "image(f,complement(Y!1))")
     (assert)
     (expand "closed?" -1)
     (case "complement(image(f, complement(Y!1))) = inverse_image(inverse(f), Y!1)")
     (("1" (assert))
      ("2"
       (hide 2)
       (hide-all-but ("bijf" 1))
       (lemma "inverse_image_complement[T2,T1]")
       (inst - "complement(Y!1)" "inverse(f)")
       (lemma "complement_complement[T1]")
       (inst - "Y!1")
       (replace -1)
       (hide -1)
       (replace -1)
       (rewrite "complement_equal")
       (name "X" "complement(Y!1)")
       (replace -1)
       (expand "image")
       (expand "inverse_image")
       (expand "member")
       (decompose-equality 1)
       (iff)
       (lemma "bijective_inverse[T1,T2]")
       (ground)
       (("1"
         (skosimp*)
         (typepred "x!2")
         (inst - "x!2" "x!1" "f")
         (assert))
        ("2"
         (inst + "inverse(f)(x!1)")
         (inst - "inverse(f)(x!1)" "x!1" "f")
         (assert))))))
    ("2" (expand "closed?") (rewrite "complement_complement"))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: ms_composition_cont
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (label "finalcont" 1)
   (label "imcont" -2)
   (label "firstcont" -1)
   (expand "continuous?")
   (skosimp*)
   (inst "firstcont" "x!1")
   (inst "imcont" "f!1(x!1)")
   (("1"
     (expand "continuous_at?")
     (skosimp*)
     (inst "imcont" "epsilon!1")
     (skosimp*)
     (inst "firstcont" "delta!1")
     (skosimp*)
     (inst "finalcont" "delta!2")
     (skosimp*)
     (inst "firstcont" "y!1")
     (inst "imcont" "f!1(y!1)")
     (("1" (grind)) ("2" (expand "image") (inst + "y!1"))))
    ("2" (expand "image") (inst + "x!1"))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuity_of_max_min
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "max_fun")
   (expand "min_fun")
   (expand "min")
   (expand "max")
   (prop)
   (("1" (apply-extensionality) (expand "-") (lift-if) (assert))
    ("2" (apply-extensionality) (expand "-") (lift-if) (assert))
    ("3" (apply-extensionality) (expand "-") (lift-if) (assert))
    ("4" (apply-extensionality) (expand "-") (lift-if) (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuity_of_max_min
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous?")
   (skosimp*)
   (inst - "x!1")
   (inst - "x!1")
   (expand "continuous_at?")
   (skosimp*)
   (inst - "epsilon!1/10")
   (inst - "epsilon!1/10")
   (skosimp*)
   (inst + "min(delta!1/10,delta!2/10)")
   (skosimp*)
   (expand "member")
   (inst - "y!1")
   (inst - "y!1")
   (expand "ball")
   (expand "real_dist")
   (expand "max_fun")
   (expand "max")
   (grind))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuity_of_max_min
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "continuous?")
   (skosimp*)
   (inst - "x!1")
   (inst - "x!1")
   (expand "continuous_at?")
   (skosimp*)
   (inst - "epsilon!1/10")
   (inst - "epsilon!1/10")
   (skosimp*)
   (inst + "min(delta!1/10,delta!2/10)")
   (skosimp*)
   (inst - "y!1")
   (inst - "y!1")
   (expand "member")
   (expand "ball")
   (expand "real_dist")
   (expand "min_fun")
   (expand "min")
   (grind))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_spaces
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "fullset_metric_space1")
   (lemma "fullset_metric_space2")
   (expand "metric_space?")
   (expand "space_zero?")
   (expand "space_symmetric?")
   (expand "space_triangle?")
   (prop)
   (("1"
     (skosimp*)
     (expand "d")
     (prop)
     (("1" (grind) (apply-extensionality)) ("2" (grind))))
    ("2" (grind))
    ("3"
     (skosimp*)
     (expand "d")
     (case "FORALL (x, y, z: (fullset[T1])): d1(x, z) <= d1(x, y) + d1(y, z)")
     (("1"
       (inst - "x!1`1" "y!1`1" "z!1`1")
       (("1"
         (case "FORALL (x, y, z: (fullset[T2])): d2(x, z) <= d2(x, y) + d2(y, z)")
         (("1"
           (inst - "x!1`2" "y!1`2" "z!1`2")
           (("1" (assert)) ("2" (expand "fullset") (propax))
            ("3" (expand "fullset") (propax))
            ("4" (expand "fullset") (propax))))
          ("2" (propax))))
        ("2" (expand "fullset") (propax))
        ("3" (expand "fullset") (propax))
        ("4" (expand "fullset") (propax))))
      ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_spaces
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "fullset_metric_space1")
   (lemma "fullset_metric_space2")
   (expand "metric_space?")
   (prop)
   (("1"
     (expand "space_zero?")
     (skosimp*)
     (expand "d_square")
     (lemma "sqrt_eq_0")
     (inst - "sq(d1(x!1`1, y!1`1)) + sq(d2(x!1`2, y!1`2))")
     (prop)
     (("1"
       (expand "sq")
       (typepred "d1(x!1`1, y!1`1)")
       (typepred "d2(x!1`2, y!1`2)")
       (mult-ineq -1 -1)
       (mult-ineq -3 -3)
       (grind)
       (("1"
         (case "x!1 = (x!1`1,x!1`2)")
         (("1"
           (case "y!1 = (y!1`1,y!1`2)")
           (("1" (grind)) ("2" (assert))))
          ("2" (assert))))
        ("2"
         (case "d2(y!1`2, y!1`2)=0")
         (("1"
           (replace -1)
           (lemma "sq_eq_0")
           (inst - "d1(y!1`1, x!1`1)")
           (expand "sq")
           (propax))
          ("2" (assert))))
        ("3"
         (case "d1(y!1`1, y!1`1)=0")
         (("1"
           (replace -1)
           (lemma "sq_eq_0")
           (inst - "d2(y!1`2, x!1`2)")
           (expand "sq")
           (propax))
          ("2" (assert))))
        ("4"
         (swap-rel -1)
         (case "d1(y!1`1, x!1`1) * d1(y!1`1, x!1`1) +
                                                                          d2(y!1`2, x!1`2) * d2(y!1`2, x!1`2)
                                                                          = 0")
         (("1"
           (hide -2)
           (lemma "posreal_times_posreal_is_posreal")
           (inst-cp - "d1(y!1`1, x!1`1)" "d1(y!1`1, x!1`1)")
           (assert))
          ("2" (propax))))))
      ("2"
       (lemma "sqrt_0")
       (case "forall (z: nonneg_real): z = 0 implies sqrt(z) = 0")
       (("1"
         (inst - "sq(d1(x!1`1, y!1`1)) + sq(d2(x!1`2, y!1`2))")
         (prop))
        ("2" (skosimp*) (replace -1) (propax))))
      ("3"
       (case "x!1 = (x!1`1,x!1`2) and y!1 = (y!1`1,y!1`2)")
       (("1"
         (case "x!1`1 = y!1`1 and x!1`2 = y!1`2")
         (("1"
           (prop)
           (replace -1)
           (replace -2)
           (inst - "y!1`2" "y!1`2")
           (("1"
             (inst - "y!1`1" "y!1`1")
             (("1"
               (assert)
               (expand "sq")
               (case "d1(y!1`1, y!1`1) * d1(y!1`1, y!1`1) +
                                                                                                             d2(y!1`2, y!1`2) * d2(y!1`2, y!1`2) = 0")
               (("1" (replace -1) (lemma "sqrt_0") (propax))
                ("2"
                 (case "d2(y!1`2, y!1`2) = 0")
                 (("1"
                   (case "d1(y!1`1, y!1`1) = 0")
                   (("1"
                     (mult-eq -1 -1)
                     (mult-eq -3 -3)
                     (add-formulas -1 -2))
                    ("2" (propax))))
                  ("2" (propax))))))
              ("2" (expand "fullset") (propax))))
            ("2" (expand "fullset") (propax))))
          ("2" (assert))))
        ("2" (assert))))))
    ("2"
     (expand "space_symmetric?")
     (expand "d_square")
     (skosimp*)
     (inst - "x!1`2" "y!1`2")
     (("1"
       (inst - "x!1`1" "y!1`1")
       (("1"
         (case "d2(x!1`2, y!1`2) = d2(y!1`2, x!1`2)")
         (("1"
           (case "d1(x!1`1, y!1`1) = d1(y!1`1, x!1`1)")
           (("1" (replace -1) (replace -2) (propax)) ("2" (propax))))
          ("2" (propax))))
        ("2" (expand "fullset") (propax))
        ("3" (expand "fullset") (propax))))
      ("2" (expand "fullset") (propax))
      ("3" (expand "fullset") (propax))))
    ("3"
     (expand "space_triangle?")
     (expand "d_square")
     (skosimp*)
     (inst - "x!1`2" "y!1`2" "z!1`2")
     (("1"
       (inst - "x!1`1" "y!1`1" "z!1`1")
       (("1"
         (name "A" "d2(x!1`2, z!1`2)")
         (name "B" "d2(x!1`2, y!1`2)")
         (name "C" "d2(y!1`2, z!1`2)")
         (name "D" "d1(x!1`1, z!1`1)")
         (name "E" "d1(x!1`1, y!1`1)")
         (name "F" "d1(y!1`1, z!1`1)")
         (replace -1)
         (replace -2)
         (replace -3)
         (replace -4)
         (replace -5)
         (replace -6)
         (typepred "A")
         (typepred "B")
         (typepred "C")
         (typepred "D")
         (typepred "E")
         (typepred "F")
         (lemma "sqrt_cauchy")
         (inst - "B" "E" "C" "F")
         (add-formulas -1 -1)
         (case "A <= B + C")
         (("1"
           (case "D <= E + F")
           (("1"
             (mult-ineq -1 -1)
             (mult-ineq -3 -3)
             (expand "sq")
             (add-formulas -1 -2 :auto-step (skip))
             (lemma "sq_le")
             (inst - "sqrt(A * A + D * D)"
              "sqrt(B * B + E * E) + sqrt(C * C + F * F)")
             (prop)
             (expand "sq")
             (lemma "sqrt_def")
             (inst-cp - "A*A + D*D")
             (replace -2)
             (inst-cp - "B*B + E*E")
             (replace -2)
             (inst-cp - "C*C + F*F")
             (replace -2)
             (assert))
            ("2" (propax))))
          ("2" (propax))))
        ("2" (expand "fullset") (propax))
        ("3" (expand "fullset") (propax))
        ("4" (expand "fullset") (propax))))
      ("2" (expand "fullset") (propax)) ("3" (expand "fullset") (propax))
      ("4" (expand "fullset") (propax))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_spaces
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (mult-ineq -1 -1)
   (lemma "sqrt_def")
   (inst - "sq(a!1) + sq(b!1)")
   (replace -1)
   (case "sq(a!1) < (r!1 / 2) * (r!1 / 2) and sq(b!1) < (r!1 / 2) * (r!1 / 2)")
   (("1"
     (prop)
     (lemma "sq_rew")
     (inst - "(r!1 / 2)")
     (rewrite -1)
     (lemma "sq_lt")
     (inst-cp - "a!1" "(r!1/2)")
     (inst-cp - "b!1" "(r!1/2)")
     (prop)
     (case "a!1 < (r!1 / 2)")
     (("1"
       (case "b!1 < (r!1 / 2)")
       (("1" (add-formulas -1 -2)) ("2" (propax))))
      ("2" (propax))))
    ("2"
     (typepred "sq(b!1)")
     (swap-rel -1)
     (case "sq(a!1) + sq(b!1) < (r!1 / 2) * (r!1 / 2)")
     (("1" (add-formulas -1 -2) (assert)) ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_spaces
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "open_in?")
   (expand "subset?")
   (expand "intersection")
   (expand "ball")
   (expand "member")
   (prop)
   (("1"
     (skosimp*)
     (typepred "s!1")
     (inst - "s!1")
     (skosimp*)
     (inst + "r!1/2")
     (skosimp*)
     (inst - "x!1")
     (expand "d_square")
     (lemma "euclic_linear_lemma")
     (inst - "d1(s!1`1, x!1`1)" "d2(s!1`2, x!1`2)" "r!1")
     (prop)
     (typepred "d2(s!1`2, x!1`2)")
     (swap-rel -1)
     (expand "d")
     (propax))
    ("2"
     (skosimp*)
     (inst - "s!1")
     (skosimp*)
     (expand "d_square")
     (expand "d")
     (inst + "r!1")
     (skosimp*)
     (mult-ineq -1 -1)
     (lemma "sq_rew")
     (assert)
     (inst-cp - "d1(s!1`1, x!1`1)")
     (inst-cp - "d2(s!1`2, x!1`2)")
     (replace -2)
     (replace -3)
     (typepred "d1(s!1`1, x!1`1) * d2(s!1`2, x!1`2)")
     (case "sq(d1(s!1`1, x!1`1)) + d1(s!1`1, x!1`1) * d2(s!1`2, x!1`2) +
                           d1(s!1`1, x!1`1) * d2(s!1`2, x!1`2) + sq(d2(s!1`2, x!1`2))
                           < r!1 * r!1")
     (("1"
       (swap-rel -2)
       (copy -2)
       (add-formulas -2 -3)
       (add-formulas -1 -2)
       (assert)
       (both-sides "-" "2 * (d1(s!1`1, x!1`1) * d2(s!1`2, x!1`2))" -1)
       (assert)
       (lemma "sqrt_lt")
       (inst - "sq(d1(s!1`1, x!1`1)) + sq(d2(s!1`2, x!1`2))" "r!1 * r!1")
       (prop)
       (case "FORALL (x: [T1, T2]):
                                sqrt(sq(d1(s!1`1, x`1)) + sq(d2(s!1`2, x`2))) < r!1 AND U!1(x) =>
                                 V!1(x)")
       (("1" (inst - "x!1") (assert)) ("2" (propax))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_spaces
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "metric_equivalence")
   (inst - "fullset[[T1,T2]]" "V!1")
   (lemma "open_in_fullset[[T1,T2],d]")
   (lemma "open_in_fullset[[T1,T2],d_square]")
   (inst - "V!1")
   (inst - "V!1")
   (replace -1)
   (replace -2)
   (propax))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_cont
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "continuous?")
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (inst - "epsilon!1/4")
     (skosimp*)
     (expand "member")
     (expand "ball")
     (inst + "delta!1/4")
     (skosimp*)
     (inst - "y!1")
     (prop)
     (("1" (cross-mult -1) (grind)) ("2" (expand "d") (grind))))
    ("2"
     (expand "continuous?")
     (expand "continuous_at?")
     (expand "member")
     (expand "ball")
     (skosimp*)
     (typepred "x!1")
     (inst - "x!1" "epsilon!1")
     (skosimp*)
     (inst + "delta!1")
     (skosimp*)
     (inst - "y!1")
     (expand "d")
     (grind))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_cont
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (skosimp*)
     (lemma "product_cont_equiv")
     (assert)
     (inst - "fullset[[(X!1),(Y!1)]]" "f!1")
     (prop)
     (typepred "x!1")
     (inst - "(x!1,y!1)" "epsilon!1")
     (("1"
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (typepred "z!1")
       (typepred "w!1")
       (inst - "(z!1,w!1)")
       (("1" (prop))
        ("2" (expand "extend") (expand "fullset") (propax))))
      ("2" (expand "extend") (expand "fullset") (propax))))
    ("2"
     (expand "continuous?")
     (skosimp*)
     (expand "continuous_at?")
     (expand "member")
     (expand "ball")
     (skosimp*)
     (typepred "x!1")
     (inst - "x!1`1" "x!1`2" "epsilon !1")
     (("1"
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (typepred "y!1")
       (expand "d")
       (inst - "y!1`1" "y!1`2")
       (("1"
         (prop)
         (("1"
           (case "x!1 = (x!1`1,x!1`2)")
           (("1"
             (replace -1 1)
             (case "y!1 = (y!1`1,y!1`2)")
             (("1" (replace -1 1) (expand "restrict") (propax))
              ("2" (expand "restrict") (assert))))
            ("2" (assert))))
          ("2" (expand "restrict") (grind))
          ("3" (expand "restrict") (grind))))
        ("2" (assert) (grind)) ("3" (expand "restrict") (grind))))
      ("2" (grind)) ("3" (grind))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_cont
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "uniformly_continuous_in_first?")
     (skosimp*)
     (inst 2 "epsilon!1/2")
     (inst 2 "y1!1")
     (inst 2
      "(LAMBDA (n: posint): Let pointy = choose({point: [T1,T1,T2] | X!1(point`1) AND X!1(point`2) AND Y!1(point`3)
                      AND d1(point`1, point`2) < 1 / n
                      AND d2(y1!1, point`3) < 1 / n
                      AND d3(f!1(point`1, y1!1), f!1(point`2, point`3)) >
                           epsilon!1 / 2}) in pointy)")
     (("1"
       (skosimp*)
       (prop)
       (("1" (assert)) ("2" (assert)) ("3" (assert)) ("4" (assert))
        ("5" (assert)) ("6" (assert))))
      ("2"
       (skosimp*)
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (inst + "1/(n!1+1)")
       (skosimp*)
       (inst - "(x1!1,x2!1,y2!1)")
       (prop)
       (("1" (assert)) ("2" (assert)) ("3" (assert))
        ("4"
         (case "1/(n!1+1) < 1/n!1")
         (("1" (assert)) ("2" (cross-mult +) (assert))))
        ("5"
         (case "1/(n!1+1) < 1/n!1")
         (("1" (assert)) ("2" (cross-mult +) (assert))))
        ("6" (assert))))))
    ("2"
     (expand "uniformly_continuous_in_first?")
     (skosimp*)
     (inst -2 "y!1" "epsilon!1/2")
     (skosimp*)
     (lemma "archimedean")
     (inst - "delta!1")
     (skosimp*)
     (inst - "n!1")
     (prop)
     (inst - "seq!1(n!1)`1" "seq!1(n!1)`2" "seq!1(n!1)`3")
     (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_cont
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "uniformly_continuous?")
   (expand "uniformly_continuous_in_first?")
   (skosimp*)
   (inst - "y!1" "epsilon!1")
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst - "x!1" "p!1" "y!1")
   (assert)
   (lemma "fullset_metric_space2")
   (expand "metric_space?")
   (expand "space_zero?")
   (prop)
   (inst - "y!1" "y!1")
   (("1" (assert)) ("2" (expand "fullset") (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_uniform_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (label "comp" -1)
   (label "cont" -2)
   (label "unif" 1)
   (lemma "one_variable_unif_cont_sequence")
   (label "epsq" -1)
   (inst "epsq" "X!1" "Y!1" "f!1")
   (assert)
   (skosimp*)
   (lemma "compact_sequence_limit[T1,d1]")
   (label "csl" -1)
   (inst "csl" "X!1")
   (assert)
   (prop)
   (("1"
     (inst "csl"
      "(LAMBDA (n: nat): IF n = 0 THEN seq!1(1)`1 ELSE seq!1(n)`1 ENDIF)")
     (("1"
       (skosimp*)
       (lemma "product_cont_product_subset")
       (label "pcps" -1)
       (inst "pcps" "X!1" "Y!1" "f!1")
       (assert)
       (inst "pcps" "p!1" "y!1" "epsilon!1/2")
       (skosimp*)
       (lemma "archimedean")
       (label "arch" -1)
       (inst "arch" "delta!1/2")
       (skosimp *)
       (inst "csl" "1/n!1" "n!1")
       (skosimp*)
       (typepred "n!2")
       (label "n!2T" -1)
       (lemma "fullset_metric_space1")
       (expand "metric_space?")
       (prop)
       (label "sz1" -1)
       (label "sym1" -2)
       (label "tri1" -3)
       (lemma "fullset_metric_space3")
       (expand "metric_space?")
       (prop)
       (label "sz3" -1)
       (label "sym3" -2)
       (label "tri3" -3)
       (expand "space_symmetric?")
       (expand "space_triangle?")
       (hide "sz1" "sz3")
       (lemma "fullset_metric_space2")
       (expand "metric_space?")
       (prop)
       (hide -2 -3)
       (label "sz2" -1)
       (expand "space_zero?")
       (copy "tri1")
       (hide "tri1")
       (inst-cp -1 "seq!1(n!2)`2" "seq!1(n!2)`1" "p!1")
       (("1"
         (label "tri1a" -1)
         (label "tri1inst" -2)
         (inst "epsq" "n!2")
         (copy "epsq")
         (hide "epsq")
         (prop)
         (label "mbs1" -1)
         (label "mbs2" -2)
         (label "mbs3" -3)
         (hide "mbs1" "mbs2" "mbs3")
         (label "s12lt" -1)
         (label "s3ylt" -2)
         (label "d3gt" -3)
         (copy "csl")
         (label "cls2" -1)
         (copy "sym1")
         (inst -1 "seq!1(n!2)`1" "seq!1(n!2)`2")
         (("1"
           (replace -1 "s12lt")
           (hide -1)
           (copy "cls2")
           (label "cls3" -1)
           (add-formulas "s12lt" "cls3")
           (label "tri_inst1" -1)
           (add-formulas "tri_inst1" "tri1inst")
           (label "tri_inst2" -1)
           (both-sides "-"
            "d1(seq!1(n!2)`1, p!1) + d1(seq!1(n!2)`2, seq!1(n!2)`1)"
            "tri_inst2")
           (assert)
           (copy "arch")
           (label "arch2" -1)
           (add-formulas "arch2" "arch2")
           (add-formulas -1 "tri_inst2")
           (assert)
           (lemma "both_sides_div_pos_lt2")
           (label "both_sides_div_pos_lt2" -1)
           (inst "both_sides_div_pos_lt2" "n!2" "n!1" "1")
           (prop)
           (("1"
             (hide -2)
             (add-formulas -1 -2)
             (both-sides "-" "2 * (1 / n!1) + 1 / n!2" -1)
             (("1"
               (assert)
               (label "d1sp1" -1)
               (copy "pcps")
               (hide "pcps")
               (label "pcps2" -1)
               (copy "pcps2")
               (label "pcps3" -1)
               (inst "pcps3" "seq!1(n!2)`2" "seq!1(n!2)`3")
               (("1"
                 (prop)
                 (("1"
                   (inst "pcps2" "seq!1(n!2)`1" "y!1")
                   (("1"
                     (inst "sym1" "p!1" "seq!1(n!2)`1")
                     (("1"
                       (replace "sym1")
                       (inst "sz2" "y!1" "y!1")
                       (("1"
                         (copy "arch")
                         (label "arch3" -1)
                         (add-formulas "cls2" "arch")
                         (assert)
                         (assert)
                         (both-sides "-" "1/n!1" -1)
                         (("1"
                           (assert)
                           (inst "tri3" "f!1(seq!1(n!2)`1,y!1)"
                            "f!1(p!1,y!1)"
                            "f!1(seq!1(n!2)`2, seq!1(n!2)`3)")
                           (("1"
                             (hide-all-but
                              ("pcps3"
                               "pcps2"
                               "tri3"
                               "sym3"
                               "d3gt"
                               "arch3"))
                             (inst "sym3" "f!1(seq!1(n!2)`1, y!1)"
                              "f!1(p!1, y!1)")
                             (("1"
                               (replace "sym3")
                               (add-formulas "tri3" "pcps3"))
                              ("2" (expand "fullset") (propax))
                              ("3" (expand "fullset") (propax))))
                            ("2" (expand "fullset") (propax))
                            ("3" (expand "fullset") (propax))
                            ("4" (expand "fullset") (propax))))
                          ("2"
                           (iff)
                           (prop)
                           (("1"
                             (hide-all-but (1 "arch3" "csl"))
                             (name-replace "A" "d1(seq!1(n!2)`1, p!1)")
                             (typepred "A")
                             (cancel-by 1 "n!1*n!1"))
                            ("2"
                             (hide-all-but (1 "arch3" "csl"))
                             (name-replace "A" "d1(seq!1(n!2)`1, p!1)")
                             (cross-mult -2)
                             (add-formulas "csl" "csl")
                             (add-formulas -1 1)
                             (both-sides "-" "2 * (A * n!1)" -1)
                             (assert)
                             (both-sides "-" "2" -1)
                             (assert)
                             (case "2 * (delta!1 / 2) / 2 = delta!1/2")
                             (("1"
                               (replace -1)
                               (mult-ineq -2 -3)
                               (assert))
                              ("2" (assert))))))))
                        ("2" (expand "fullset") (propax))))
                      ("2" (expand "fullset") (propax))
                      ("3" (expand "fullset") (propax))))
                    ("2" (reveal "mbs1") (propax))))
                  ("2"
                   (inst "sym1" "p!1" "seq!1(n!2)`2")
                   (("1"
                     (replace "sym1")
                     (reveal "arch2")
                     (add-formulas "csl" "arch2"))
                    ("2" (expand "fullset") (propax))
                    ("3" (expand "fullset") (propax))))
                  ("3"
                   (add-formulas "cls2" "arch")
                   (reveal -)
                   (assert))))
                ("2" (reveal "mbs3") (propax))
                ("3" (reveal "mbs2") (propax))))
              ("2" (assert))))
            ("2" (assert))))
          ("2" (expand "fullset") (propax))
          ("3" (expand "fullset") (propax))))
        ("2" (expand "fullset") (propax))
        ("3" (expand "fullset") (propax))
        ("4" (expand "fullset") (propax))))
      ("2" (skosimp*) (inst "epsq" "n!1") (assert))
      ("3" (skosimp*) (assert))
      ("4" (skosimp*) (inst "epsq" "1") (assert))))
    ("2"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst "csl" "seq!1(1)`1")
     (inst "epsq" "1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_uniform_continuity
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "multiary_Heine")
   (inst?)
   (assert)
   (expand "uniformly_continuous_in_first?")
   (inst - "y1!1" "epsilon!1")
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst - "x!1" "x!1" "y2!1")
   (prop)
   (lemma "fullset_metric_space1")
   (expand "metric_space?")
   (expand "space_zero?")
   (prop)
   (inst?)
   (("1" (assert)) ("2" (expand "fullset") (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_real_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (label "nonempty" -1)
   (label "cont" -2)
   (label "compact" -3)
   (label "t1in" -4)
   (label "final" 1)
   (lemma "cont_on_compact_min")
   (inst - "X!1" "(LAMBDA (x: T1): f!1(x,t!1))")
   (lemma "curried_is_uniform")
   (inst - "X!1" "Y!1" "f!1")
   (lemma "multiary_Heine")
   (inst - "X!1" "Y!1" "f!1")
   (lemma "unif_cont_implies_cont")
   (inst - "X!1" "(LAMBDA (x: T1): f!1(x,t!1))")
   (assert)
   (inst - "t!1")
   (assert)
   (expand "nonempty?")
   (assert)
   (label "contLam" -1)
   (label "ucif" -2)
   (label "uclam" -3)
   (label "min_exists" -4)
   (prop)
   (("1"
     (expand "empty?")
     (expand "member")
     (skosimp*)
     (inst "final" "f!1(x!1,t!1)")
     (inst + "x!1"))
    ("2"
     (expand "below_bounded")
     (lemma "axiom_of_archimedes")
     (skosimp*)
     (inst -1 "-f!1(s!1,t!1)")
     (skosimp*)
     (inst + "-i!1-2")
     (expand "lower_bound")
     (skosimp*)
     (typepred "z!1")
     (skosimp*)
     (inst "min_exists" "x!1")
     (assert))
    ("3"
     (expand "ext")
     (skosimp*)
     (inst + "s!1")
     (lemma "inf_def")
     (inst -1 "{r: real | EXISTS (x: (X!1)): r = f!1(x, t!1)}"
      "f!1(s!1,t!1)")
     (("1"
       (replace -1)
       (expand "greatest_lower_bound")
       (expand "lower_bound")
       (split)
       (("1"
         (skosimp*)
         (typepred "z!1")
         (skosimp*)
         (inst "min_exists" "x!1")
         (assert))
        ("2" (skosimp*) (inst - "f!1(s!1,t!1)") (inst + "s!1"))))
      ("2"
       (expand "nonempty?")
       (split)
       (("1"
         (expand "empty?")
         (expand "member")
         (skosimp*)
         (inst - "f!1(x!1,t!1)")
         (inst + "x!1"))
        ("2"
         (expand "below_bounded")
         (lemma "axiom_of_archimedes")
         (inst - "-f!1(s!1,t!1)")
         (skosimp*)
         (inst + "-i!1-2")
         (expand "lower_bound")
         (skosimp*)
         (typepred "z!1")
         (skosimp*)
         (inst "min_exists" "x!1")
         (assert))))))
    ("4" (skosimp*) (inst + "s!1") (skosimp*) (inst - "y!1") (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cross_metric_real_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (label "compact" -1)
   (label "continuous" -2)
   (label "nonempty" -3)
   (label "final" 1)
   (assert)
   (lemma "multi_Heine_Corollary1")
   (inst?)
   (assert)
   (lemma "cont_on_compact_min")
   (label "cocm" -1)
   (label "mhc1" -2)
   (lemma "curried_is_uniform")
   (label "cmic" -1)
   (lemma "multiary_Heine")
   (inst?)
   (assert)
   (label "ucif" -1)
   (inst "cmic" "X!1" "Y!1" "f!1")
   (assert)
   (expand "continuous?" "final")
   (skosimp*)
   (typepred "x!1")
   (label "tpx!1" -1)
   (expand "continuous_at?")
   (expand "member")
   (expand "ball")
   (expand "real_dist")
   (skosimp*)
   (inst "mhc1" "x!1" "epsilon!1")
   (skosimp*)
   (inst "final" "delta!1")
   (skosimp*)
   (typepred "y!1")
   (label "tpy!1" -1)
   (name "main_min"
         "min({r: real | EXISTS (x: (X!1)): r = f!1(x, x!1)})")
   (("1"
     (label "main_min" -1)
     (name "sec_min"
           "min({r: real | EXISTS (x: (X!1)): r = f!1(x, y!1)})")
     (("1"
       (label "sec_min" -1)
       (replace "main_min")
       (replace "sec_min")
       (name "main_slice"
             "{r: real | EXISTS (x: (X!1)): r = f!1(x, x!1)}")
       (label "main_slice" -1)
       (name "sec_slice"
             "{r: real | EXISTS (x: (X!1)): r = f!1(x, y!1)}")
       (label "sec_slice" -1)
       (replace "main_slice")
       (replace "sec_slice")
       (inst-cp "cmic" "x!1")
       (inst "cmic" "y!1")
       (lemma "unif_cont_implies_cont")
       (inst-cp -1 "X!1" "LAMBDA (t: T1): f!1(t, y!1)")
       (inst-cp -1 "X!1" "LAMBDA (t: T1): f!1(t, x!1)")
       (hide -1)
       (label "cmicx" -1)
       (label "cmicy" -2)
       (hide "cmic")
       (copy "cocm")
       (hide "cocm")
       (inst-cp -1 "X!1" "LAMBDA (t: T1): f!1(t, x!1)")
       (label "cocmx" -2)
       (inst -1 "X!1" "LAMBDA (t: T1): f!1(t, y!1)")
       (label "comcy" -1)
       (hide ("tpy!1" "tpx!1"))
       (lemma "curried_is_uniform")
       (inst?)
       (assert)
       (expand "nonempty?")
       (prop)
       (("1"
         (skosimp*)
         (expand "min")
         (lemma "inf_def")
         (inst-cp -1 "main_slice" "f!1(s!1,x!1)")
         (inst -1 "sec_slice" "f!1(s!2,y!1)")
         (prop)
         (("1"
           (hide (-2 -4))
           (label "inf_main_slice" -1)
           (label "inf_sec_slice" -2)
           (inst "mhc1" "y!1")
           (assert)
           (copy "mhc1")
           (hide "mhc1")
           (inst-cp -1 "s!1")
           (inst -1 "s!2")
           (label "sec_applic" -1)
           (label "main_applic" -2)
           (inst "cocmx" "s!2")
           (inst "comcy" "s!1")
           (hide
            ("nonempty"
             "continuous"
             "compact"
             "ucif"
             "sec_slice"
             "main_slice"
             "cmicy"
             "cmicx"))
           (grind))
          ("2"
           (hide-all-but (1 "main_slice" "cocmx"))
           (expand "greatest_lower_bound")
           (expand "lower_bound")
           (prop)
           (("1"
             (skosimp*)
             (typepred "z!1")
             (replace "main_slice" - rl)
             (assert)
             (skosimp*)
             (inst "cocmx" "x!2")
             (assert))
            ("2"
             (skosimp*)
             (inst - "f!1(s!1,x!1)")
             (replace "main_slice" + rl)
             (assert)
             (inst + "s!1"))))
          ("3"
           (hide-all-but (1 "sec_slice" "comcy"))
           (expand "greatest_lower_bound")
           (prop)
           (("1"
             (expand "lower_bound")
             (skosimp*)
             (typepred "z!1")
             (replace "sec_slice" - rl)
             (assert)
             (skosimp*)
             (inst "comcy" "x!2")
             (assert))
            ("2"
             (skosimp*)
             (expand "lower_bound")
             (inst -1 "f!1(s!2,y!1)")
             (replace "sec_slice" + rl)
             (assert)
             (inst + "s!2"))))
          ("4"
           (hide-all-but (1 "cocmx" "main_slice"))
           (expand "greatest_lower_bound")
           (expand "lower_bound")
           (prop)
           (("1"
             (skosimp*)
             (typepred "z!1")
             (replace "main_slice" - rl)
             (assert)
             (skosimp*)
             (inst "cocmx" "x!2")
             (assert))
            ("2"
             (skosimp*)
             (inst -1 "f!1(s!1,x!1)")
             (replace "main_slice" + rl)
             (assert)
             (inst + "s!1"))))))
        ("2" (inst - "y!1")) ("3" (inst - "x!1")) ("4" (inst - "y!1"))
        ("5" (inst - "x!1")) ("6" (inst - "y!1")) ("7" (inst - "y!1"))
        ("8" (inst - "y!1")) ("9" (inst - "y!1"))))
      ("2"
       (prop)
       (("1"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (skosimp*)
         (inst -1 "f!1(x!2,y!1)")
         (inst + "x!2"))
        ("2"
         (expand "below_bounded")
         (expand "lower_bound")
         (expand "nonempty?")
         (copy "cmic")
         (inst -1 "y!1")
         (label "cmic2" -1)
         (lemma "unif_cont_implies_cont")
         (label "ucic1" -1)
         (inst "ucic1" "X!1" "LAMBDA (t: T1): f!1(t, y!1)")
         (assert)
         (copy "cocm")
         (label "cocm2" -1)
         (inst "cocm2" "X!1" "LAMBDA (t: T1): f!1(t, y!1)")
         (assert)
         (skosimp*)
         (inst + "f!1(s!1,y!1)")
         (skosimp*)
         (typepred "z!1")
         (skosimp*)
         (inst "cocm2" "x!2")
         (assert))
        ("3"
         (expand "ext")
         (lemma "inf_def")
         (label "inf_def" -1)
         (lemma "unif_cont_implies_cont")
         (label "ucic2" -1)
         (inst "ucic2" "X!1" "LAMBDA (t: T1): f!1(t, y!1)")
         (inst "cmic" "y!1")
         (assert)
         (inst "cocm" "X!1" "LAMBDA (t: T1): f!1(t, y!1)")
         (assert)
         (expand "nonempty?")
         (assert)
         (skosimp*)
         (inst "inf_def" "{r: real | EXISTS (x: (X!1)): r = f!1(x, y!1)}"
          "f!1(s!1,y!1)")
         (("1"
           (assert)
           (inst + "s!1")
           (assert)
           (expand "greatest_lower_bound")
           (expand "lower_bound")
           (prop)
           (("1"
             (skosimp*)
             (typepred "z!1")
             (skosimp*)
             (inst "cocm" "x!2")
             (assert))
            ("2" (skosimp*) (inst -1 "f!1(s!1,y!1)") (inst + "s!1"))))
          ("2"
           (prop)
           (("1"
             (expand "nonempty?")
             (expand "empty?")
             (skosimp*)
             (expand "member")
             (inst -1 "f!1(x!2,y!1)")
             (inst + "x!2"))
            ("2"
             (expand "below_bounded")
             (expand "lower_bound")
             (lemma "axiom_of_archimedes")
             (inst -1 "-f!1(s!1,y!1)")
             (skosimp*)
             (inst + "-i!1-2")
             (skosimp*)
             (typepred "z!1")
             (skosimp*)
             (inst "cocm" "x!2")
             (assert))))))))))
    ("2"
     (lemma "unif_cont_implies_cont")
     (inst "cmic" "x!1")
     (inst -1 "X!1" "LAMBDA (t: T1): f!1(t, x!1)")
     (assert)
     (inst "cocm" "X!1" "LAMBDA (t: T1): f!1(t, x!1)")
     (expand "nonempty?")
     (assert)
     (skosimp*)
     (lemma "axiom_of_archimedes")
     (label "aoa" -1)
     (inst "aoa" "-f!1(s!1,x!1)")
     (skosimp*)
     (prop)
     (("1"
       (expand "empty?")
       (expand "member")
       (typepred "s!1")
       (inst - "f!1(s!1,x!1)")
       (inst + "s!1"))
      ("2"
       (expand "below_bounded")
       (inst + "-i!1-2")
       (expand "lower_bound")
       (skosimp*)
       (typepred "z!1")
       (skosimp*)
       (inst "cocm" "x!2")
       (assert))
      ("3"
       (expand "ext")
       (inst + "s!1")
       (lemma "inf_def")
       (inst -1 "{r: real | EXISTS (x: (X!1)): r = f!1(x, x!1)}"
        "f!1(s!1,x!1)")
       (("1"
         (assert)
         (expand "greatest_lower_bound")
         (prop)
         (("1"
           (expand "lower_bound")
           (skosimp*)
           (typepred "z!1")
           (skosimp*)
           (inst-cp "cocm" "x!2")
           (assert))
          ("2"
           (skosimp*)
           (expand "lower_bound")
           (inst - "f!1(s!1,x!1)")
           (inst + "s!1"))))
        ("2"
         (prop)
         (("1"
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (inst - "f!1(s!1,x!1)")
           (inst + "s!1"))
          ("2"
           (expand "below_bounded")
           (inst + "-i!1-2")
           (expand "lower_bound")
           (skosimp*)
           (typepred "z!1")
           (skosimp*)
           (inst "cocm" "x!2")
           (assert))))))))))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: cross_metric_real_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "metric_space?")
   (expand "space_zero?")
   (expand "space_symmetric?")
   (expand "space_triangle?")
   (grind))


proof_type: t_proof
decl_type: tcc
library: analysis
theory: cross_metric_real_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (label "nonempty" -1)
   (label "cont" -2)
   (label "compact" -3)
   (label "t1in" -4)
   (label "final" 1)
   (lemma "cont_on_compact_min")
   (inst - "X!1" "(LAMBDA (x: T1): f!1(x,t!1))")
   (lemma "curried_is_uniform")
   (inst - "X!1" "Y!1" "f!1")
   (lemma "multiary_Heine")
   (inst - "X!1" "Y!1" "f!1")
   (lemma "unif_cont_implies_cont")
   (inst - "X!1" "(LAMBDA (x: T1): f!1(x,t!1))")
   (assert)
   (inst - "t!1")
   (assert)
   (expand "nonempty?")
   (assert)
   (label "contLam" -1)
   (label "ucif" -2)
   (label "uclam" -3)
   (label "min_exists" -4)
   (prop)
   (("1"
     (expand "empty?")
     (expand "member")
     (skosimp*)
     (inst "final" "f!1(x!1,t!1)")
     (inst + "x!1"))
    ("2"
     (expand "below_bounded")
     (lemma "axiom_of_archimedes")
     (skosimp*)
     (inst -1 "-f!1(s!1,t!1)")
     (skosimp*)
     (inst + "-i!1-2")
     (expand "lower_bound")
     (skosimp*)
     (typepred "z!1")
     (skosimp*)
     (inst "min_exists" "x!1")
     (assert))
    ("3"
     (expand "ext")
     (skosimp*)
     (inst + "s!1")
     (lemma "inf_def")
     (inst -1 "{r: real | EXISTS (x: (X!1)): r = f!1(x, t!1)}"
      "f!1(s!1,t!1)")
     (("1"
       (replace -1)
       (expand "greatest_lower_bound")
       (expand "lower_bound")
       (split)
       (("1"
         (skosimp*)
         (typepred "z!1")
         (skosimp*)
         (inst "min_exists" "x!1")
         (assert))
        ("2" (skosimp*) (inst - "f!1(s!1,t!1)") (inst + "s!1"))))
      ("2"
       (expand "nonempty?")
       (split)
       (("1"
         (expand "empty?")
         (expand "member")
         (skosimp*)
         (inst - "f!1(x!1,t!1)")
         (inst + "x!1"))
        ("2"
         (expand "below_bounded")
         (lemma "axiom_of_archimedes")
         (inst - "-f!1(s!1,t!1)")
         (skosimp*)
         (inst + "-i!1-2")
         (expand "lower_bound")
         (skosimp*)
         (typepred "z!1")
         (skosimp*)
         (inst "min_exists" "x!1")
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: real_fun_continuity_equiv
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous?")
   (expand "continuous?")
   (prop)
   (("1"
     (skeep)
     (inst - "x0")
     (("1"
       (skosimp*)
       (expand "continuous_at?")
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "x!1")
       (("1"
         (expand "member")
         (expand "ball")
         (expand "real_dist")
         (split)
         (("1" (grind)) ("2" (grind))))
        ("2" (expand "fullset") (propax))))
      ("2" (hide 2) (expand "fullset") (propax))))
    ("2"
     (expand "continuous_at?")
     (skosimp*)
     (inst - "x!1")
     (inst - "epsilon!1")
     (skosimp*)
     (inst + "delta!1")
     (skosimp*)
     (inst - "y!1")
     (expand "member")
     (expand "ball")
     (expand "real_dist")
     (grind))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: weierstrass_approximation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "FORALL (pp: nat):      FORALL (kz: nat): pp<=2 AND kz+1 > pp IMPLIES
                                                 sigma(0,kz+1,LAMBDA (i:nat): IF i > kz+1 THEN 0 ELSE i^pp*C(kz+1,i)*(-1)^(kz+1-i) ENDIF) = 0")
   (("1" (inst - "p") (inst - "k-1") (assert))
    ("2"
     (hide 2)
     (hide -1)
     (hide -1)
     (induct "pp")
     (("1"
       (skosimp*)
       (assert)
       (lemma "binomial_theorem")
       (inst - "kz!1+1" "1" "-1")
       (assert)
       (expand "^" -1 1)
       (expand "expt" -1 1)
       (lemma "sigma_restrict_eq")
       (inst -
        "LAMBDA (i: nat):
                                         IF i > kz!1+1 THEN 0 ELSE C(kz!1+1, i) * 1 ^ i * (-1) ^ (kz!1+1 - i) ENDIF"
        "LAMBDA (i: nat):
                                        IF i > kz!1+1 THEN 0 ELSE C(kz!1+1, i) * i ^ 0 * (-1) ^ (kz!1+1 - i) ENDIF"
        "kz!1+1" "0")
       (("1"
         (assert)
         (hide 2)
         (decompose-equality)
         (("1"
           (expand "restrict")
           (lift-if)
           (ground)
           (rewrite "expt_1i")
           (expand "^" +)
           (expand "expt" +)
           (propax))
          ("2" (skosimp*) (assert))))
        ("2" (skosimp*) (assert))))
      ("2"
       (skosimp*)
       (lemma "sigma_split")
       (inst -
        "LAMBDA (i: nat):
                                  IF i > kz!1 + 1 THEN 0
                                  ELSE (i ^ (j!1 + 1)) * C(kz!1 + 1, i) * (-1) ^ (kz!1 + 1 - i)
                                  ENDIF"
        "kz!1 + 1" "0" "0")
       (("1"
         (assert)
         (replace -1)
         (hide -1)
         (expand "sigma" 1 1)
         (expand "sigma" 1 1)
         (case "0^(1+j!1) = 0")
         (("1"
           (replace -1)
           (hide -1)
           (assert)
           (case "NOT (LAMBDA (i: nat):
                                                             IF i > 1 + kz!1 THEN 0
                                                             ELSE C(1 + kz!1, i) * (i ^ (1 + j!1)) * (-1) ^ (1 - i + kz!1)
                                                             ENDIF) = (LAMBDA (i: nat):
                                                             -(1+kz!1)*IF i > 1 + kz!1 or i = 0 THEN 0
                                                             ELSE C(kz!1, i-1) * (i ^ j!1) * (-1) ^ (kz!1-i)
                                                             ENDIF)")
           (("1"
             (hide 2)
             (hide -1)
             (decompose-equality)
             (("1"
               (lift-if)
               (lift-if)
               (lift-if)
               (assert)
               (ground)
               (("1"
                 (replace -1)
                 (case "0^(1+j!1) = 0")
                 (("1" (assert))
                  ("2" (expand "^" 1) (expand "expt" 1) (assert))))
                ("2"
                 (expand "C")
                 (case "(-1) ^ (1 - x!1 + kz!1) = -(-1)^(kz!1-x!1)")
                 (("1"
                   (replace -1)
                   (hide -1)
                   (expand "factorial" 2 1)
                   (expand "factorial" 2 3)
                   (case "x!1^(1+j!1) = x!1*x!1^j!1")
                   (("1" (replace -1) (hide -1) (assert))
                    ("2" (expand "^" 1) (expand "expt" 1 1) (propax))))
                  ("2"
                   (case "kz!1 = x!1")
                   (("1"
                     (replace -1)
                     (assert)
                     (expand "^" 1)
                     (expand "expt")
                     (expand "expt")
                     (assert))
                    ("2"
                     (case "kz!1 = x!1 -1")
                     (("1"
                       (replace -1)
                       (assert)
                       (expand "^" 2)
                       (expand "expt" 2)
                       (expand "expt" 2)
                       (propax))
                      ("2"
                       (expand "^" 3)
                       (assert)
                       (expand "expt" 3 1)
                       (assert))))))))))
              ("2" (skosimp*) (assert)) ("3" (skosimp*) (assert))))
            ("2"
             (replace -1)
             (hide -1)
             (lemma "sigma_shift_T2")
             (inst -
              "(LAMBDA (i: nat):
                                                     -(1 + kz!1) *
                                                      IF i > 1 + kz!1 OR i = 0 THEN 0
                                                      ELSE C(kz!1, i - 1) * (i ^ j!1) * (-1) ^ (kz!1 - i)
                                                      ENDIF)"
              "kz!1" "0" "1")
             (("1"
               (assert)
               (replace -1)
               (hide -1)
               (lemma "sigma_scal")
               (inst -
                "LAMBDA (i_1: nat):
                                                           IF 1 + i_1 > 1 + kz!1 THEN 0
                                                           ELSE (C(kz!1, i_1) * (-1) ^ (- i_1 + kz!1)) *
                                                                 ((1 + i_1) ^ j!1)
                                                           ENDIF"
                "(1+kz!1)" "kz!1" "0")
               (("1"
                 (lemma "sigma_restrict_eq")
                 (inst -
                  "LAMBDA (i: nat):
                                                (1 + kz!1) *
                                                 IF 1 + i > 1 + kz!1 THEN 0
                                                 ELSE (C(kz!1, i) * (-1) ^ (-i + kz!1)) * ((1 + i) ^ j!1)
                                                 ENDIF"
                  "LAMBDA (i_1: nat):
                                                -(1 + kz!1) *
                                                 IF 1 + i_1 > 1 + kz!1 THEN 0
                                                 ELSE (C(kz!1, i_1) * (-1) ^ (-1 - i_1 + kz!1)) *
                                                       ((1 + i_1) ^ j!1)
                                                 ENDIF"
                  "kz!1" "0")
                 (("1"
                   (split -1)
                   (("1"
                     (replace -1)
                     (hide -1)
                     (replace -1)
                     (hide -1)
                     (inst - "kz!1-1")
                     (name "AA"
                           "LAMBDA (i_1: nat):
                                                                   IF 1 + i_1 > 1 + kz!1 THEN 0
                                                                   ELSE (C(kz!1, i_1) * (-1) ^ (-i_1 + kz!1)) *
                                                                         ((1 + i_1) ^ j!1)
                                                                   ENDIF")
                     (("1"
                       (replace -1)
                       (case "sigma(0,kz!1,AA) = 0")
                       (("1" (assert))
                        ("2"
                         (hide 2)
                         (assert)
                         (name "BB"
                               "LAMBDA (i: nat):
                                                                          IF i > kz!1 THEN 0
                                                                          ELSE C(kz!1, i) * i ^ j!1 * (-1) ^ (kz!1 - i)
                                                                          ENDIF")
                         (("1"
                           (replace -1)
                           (case "j!1 = 0")
                           (("1"
                             (replace -1)
                             (assert)
                             (case "AA = BB")
                             (("1" (assert))
                              ("2"
                               (hide 2)
                               (decompose-equality)
                               (expand "AA" +)
                               (expand "BB" +)
                               (lift-if)
                               (lift-if)
                               (assert)
                               (ground)
                               (replace -1)
                               (expand "^" 2)
                               (expand "expt" 2 2)
                               (expand "expt" 2 3)
                               (assert))))
                            ("2"
                             (case "j!1 = 1")
                             (("1"
                               (replace -1)
                               (hide 1)
                               (hide -1)
                               (expand "^" -1 1)
                               (expand "expt" -1)
                               (expand "expt" -1)
                               (expand " ^" -2 2)
                               (expand "expt" -2)
                               (expand "expt" -2)
                               (name "CC"
                                     "(LAMBDA (i_1: nat):
                                                                                 IF 1 + i_1 > 1 + kz!1 THEN 0
                                                                                 ELSE C(kz!1, i_1) * (-1) ^ (-i_1 + kz!1)
                                                                                 ENDIF)")
                               (case "AA = BB + CC")
                               (("1"
                                 (replace -1)
                                 (hide -1)
                                 (lemma "sigma_sum")
                                 (inst - "BB" "CC" "kz!1" "0")
                                 (expand "+" +)
                                 (replace -1 :dir rl)
                                 (hide -1)
                                 (case "sigma(0,kz!1,CC) = 0")
                                 (("1" (assert))
                                  ("2"
                                   (hide 2)
                                   (replace -1 + :dir rl)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (lemma "binomial_theorem")
                                   (inst - "kz!1" "1" "-1")
                                   (assert)
                                   (expand "^" -1 1)
                                   (expand "expt" -1)
                                   (case
                                    "(LAMBDA (i: nat):
                                                                                     IF i > kz!1 THEN 0
                                                                                     ELSE C(kz!1, i) * 1 ^ i * (-1) ^ (kz!1 - i)
                                                                                     ENDIF) = (LAMBDA (i_1: nat):
                                                                                     IF 1 + i_1 > 1 + kz!1 THEN 0
                                                                                     ELSE C(kz!1, i_1) * (-1) ^ (-i_1 + kz!1)
                                                                                     ENDIF)")
                                   (("1" (assert))
                                    ("2"
                                     (hide 2)
                                     (decompose-equality)
                                     (("1"
                                       (hide -1)
                                       (lift-if)
                                       (lift-if)
                                       (assert)
                                       (ground)
                                       (case "1^x!1 = 1")
                                       (("1" (assert))
                                        ("2" (rewrite "expt_1i"))))
                                      ("2" (skosimp*) (assert))
                                      ("3" (skosimp*) (assert))))))))
                                ("2"
                                 (replace -1 + :dir rl)
                                 (hide -1)
                                 (replace -1 + :dir rl)
                                 (hide -1)
                                 (replace -1 + :dir rl)
                                 (hide -1)
                                 (expand "+" 1)
                                 (decompose-equality)
                                 (("1"
                                   (hide 2)
                                   (lift-if)
                                   (lift-if)
                                   (assert))
                                  ("2" (skosimp*) (assert))
                                  ("3" (skosimp*) (assert))))))
                              ("2" (assert))))))
                          ("2" (skosimp*) (assert))))))
                      ("2" (skosimp*) (assert))))
                    ("2"
                     (hide 2)
                     (decompose-equality)
                     (("1"
                       (expand "restrict")
                       (lift-if)
                       (ground)
                       (case "(-1) ^ (-1 - x!1 + kz!1) = -(-1) ^ (- x!1 + kz!1)")
                       (("1" (assert))
                        ("2"
                         (hide 3)
                         (case "x!1 = kz!1")
                         (("1"
                           (replace -1)
                           (assert)
                           (expand "^" 1)
                           (expand "expt" 1)
                           (expand "expt" 1)
                           (propax))
                          ("2"
                           (case "-1 - x!1 + kz!1  >= 0")
                           (("1"
                             (expand "^" 2)
                             (assert)
                             (expand "expt" 2 2)
                             (assert))
                            ("2" (assert))))))))
                      ("2" (skosimp*) (assert))))))
                  ("2" (skosimp*) (assert))))
                ("2" (skosimp*) (assert))))
              ("2" (skosimp*) (assert))))
            ("3" (skosimp*) (assert)) ("4" (skosimp*) (assert))))
          ("2" (expand "^" 1) (expand "expt" 1) (assert))))
        ("2" (skosimp*) (assert))))
      ("3" (skosimp*) (assert))))
    ("3" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: weierstrass_approximation
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "closed_intervals_compact")
   (inst?)
   (label "intcompact" -1)
   (label "fcont" -2)
   (label "approx" 1)
   (case "empty?(closed_intv(0,1))")
   (("1" (expand "empty?" -1) (inst - "1/2") (expand "member") (propax))
    ("2"
     (label "nonempty" 1)
     (case "NOT EXISTS (M: posreal): FORALL (x: (closed_intv(0,1))): abs(f(x)) < M")
     (("1"
       (hide "approx")
       (lemma "cont_on_compact_max")
       (inst?)
       (assert)
       (lemma "cont_on_compact_min")
       (inst?)
       (assert)
       (skosimp*)
       (name "Mz" "max(abs(f(s!1))+1,abs(f(s!2))+1)")
       (inst + "Mz")
       (skosimp*)
       (expand "abs" +)
       (lift-if)
       (ground)
       (("1" (inst - "x!1") (expand "abs" -2 1) (assert))
        ("2"
         (inst - "x!1")
         (inst - "x!1")
         (expand "abs" -1 2)
         (assert))))
      ("2"
       (lemma "Heine")
       (inst - "closed_intv(0,1)" "f")
       (assert)
       (label "Mdef" -2)
       (label "funif" -1)
       (copy "funif")
       (label "funif2" -1)
       (expand "uniformly_continuous?" "funif2")
       (skosimp*)
       (inst - "epsilon!1/2")
       (skosimp*)
       (expand "real_dist" "funif2")
       (case "EXISTS (N:above(5)): N>(M!1/(delta!1^2*epsilon!1))")
       (("1"
         (skosimp*)
         (label "Ndef" -1)
         (name "fbseq"
               "(# index:= N!1,bern_seq := (LAMBDA (pj: upto(N!1)): f(pj/N!1)) #)")
         (label "fbsname" -1)
         (name "BNf" "Bern_poly(fbseq)")
         (("1"
           (label "BNfname" -1)
           (case "FORALL (x:(closed_intv(0,1))): abs(BNf(x)-f(x)) <= (epsilon!1/2) + (M!1/(2*sq(delta!1)*N!1))")
           (("1"
             (lemma "Bern_poly_inverse_def")
             (inst - "fbseq")
             (inst + "Bern_poly_inverse(fbseq)" "fbseq`index")
             (skosimp*)
             (inst - "x!1")
             (case "(epsilon!1 / 2) + (M!1 / (2 * sq(delta!1) * N!1)) < epsilon!1")
             (("1" (assert))
              ("2"
               (hide "approx")
               (hide -1)
               (hide -1)
               (case "(M!1 / (2 * sq(delta!1) * N!1)) < epsilon!1/2")
               (("1" (assert))
                ("2"
                 (cross-mult 1)
                 (copy "Ndef")
                 (cross-mult -1)
                 (expand "^")
                 (expand "expt")
                 (expand "expt")
                 (expand "expt")
                 (mult-by -1 "2")
                 (expand "sq")
                 (assert))))))
            ("2"
             (hide "approx")
             (label "bernapprox" 1)
             (case "FORALL (x,y:(closed_intv(0,1))): abs(BNf(x)-f(y)) <= (epsilon!1/2) + ((2*M!1)/sq(delta!1))*sq(x-y) + ((2*M!1)/sq(delta!1))*(1/N!1)*(x-sq(x))")
             (("1"
               (skosimp*)
               (inst - "x!1" "x!1")
               (assert)
               (case "x!1 - sq(x!1) <= 1/4")
               (("1"
                 (mult-by -1
                  "((2 * M!1) / sq(delta!1)) * sq(x!1 - x!1) +
                                                                                                                                          ((2 * M!1) / sq(delta!1)) * (1 / N!1)")
                 (assert))
                ("2"
                 (hide-all-but 1)
                 (cross-mult 1)
                 (typepred "sq(2*x!1-1)")
                 (expand "sq")
                 (assert))))
              ("2"
               (hide "bernapprox")
               (label "bapprox2" 1)
               (skosimp*)
               (name "sqdiffseq"
                     "(# index:= N!1, bern_seq := (LAMBDA (pj:upto(N!1)): sq((pj/N!1)-y!1)) #)")
               (label "sqdiffseqdef" -1)
               (name "BNdiff" "Bern_poly(sqdiffseq)")
               (("1"
                 (label "BNdiffname" -1)
                 (case "abs(BNf(x!1)-f(y!1)) <= ((2*M!1)/sq(delta!1))*BNdiff(x!1) + epsilon!1/2")
                 (("1"
                   (case "BNdiff(x!1) = sq(x!1)+(1/N!1)*(x!1-sq(x!1))-2*y!1*x!1+sq(y!1)")
                   (("1"
                     (replace -1 -2)
                     (hide -1)
                     (case "((2 * M!1) / sq(delta!1)) *
                                                                                                                                                                                                                  (sq(x!1) + (1 / N!1) * (x!1 - sq(x!1)) - 2 * y!1 * x!1 + sq(y!1))
                                                                                                                                                                                                                  + epsilon!1 / 2 = (epsilon!1 / 2) + ((2 * M!1) / sq(delta!1)) * sq(x!1 - y!1) +
                                                                                                                                                                                                                  ((2 * M!1) / sq(delta!1)) * (1 / N!1) * (x!1 - sq(x!1))")
                     (("1" (assert))
                      ("2" (hide "bapprox2") (expand "sq" 1) (field 1))))
                    ("2"
                     (lemma "Bern_poly_inverse_def")
                     (inst - "sqdiffseq")
                     (hide "bapprox2")
                     (hide "nonempty")
                     (hide "fcont")
                     (hide "intcompact")
                     (hide "Mdef")
                     (hide "funif")
                     (hide "funif2")
                     (hide "Ndef")
                     (hide "fbsname")
                     (hide "BNfname")
                     (replace -1 :dir rl)
                     (replace "BNdiffname" :dir rl)
                     (hide -1)
                     (hide -1)
                     (hide -1)
                     (expand "Bern_poly_inverse")
                     (expand "polynomial")
                     (replace "sqdiffseqdef" :dir rl)
                     (assert)
                     (case "NOT (LAMBDA (i_1: nat):
                                                                                                                                                                                                                            IF i_1 > N!1 THEN 0
                                                                                                                                                                                                                            ELSE sigma(0, i_1,
                                                                                                                                                                                                                                       LAMBDA (i: nat):
                                                                                                                                                                                                                                         IF i > i_1 THEN 0
                                                                                                                                                                                                                                         ELSE sq((i / N!1) - y!1) * C(i_1, i) *
                                                                                                                                                                                                                                               C(N!1, i_1)
                                                                                                                                                                                                                                               * (-1) ^ (i_1 - i)
                                                                                                                                                                                                                                         ENDIF)
                                                                                                                                                                                                                            ENDIF
                                                                                                                                                                                                                             * (IF i_1 = 0 THEN 1 ELSE x!1 ^ i_1 ENDIF)) = (LAMBDA (i_1: nat):
                                                                                                                                                                                                                            IF i_1 > 3 THEN 0
                                                                                                                                                                                                                            ELSE sigma(0, i_1,
                                                                                                                                                                                                                                       LAMBDA (i: nat):
                                                                                                                                                                                                                                         IF i > i_1 THEN 0
                                                                                                                                                                                                                                         ELSE sq((i / N!1) - y!1) * C(i_1, i) *
                                                                                                                                                                                                                                               C(N!1, i_1)
                                                                                                                                                                                                                                               * (-1) ^ (i_1 - i)
                                                                                                                                                                                                                                         ENDIF)
                                                                                                                                                                                                                            ENDIF
                                                                                                                                                                                                                             * (IF i_1 = 0 THEN 1 ELSE x!1 ^ i_1 ENDIF))")
                     (("1"
                       (hide 2)
                       (decompose-equality)
                       (("1"
                         (lift-if)
                         (lift-if)
                         (lift-if)
                         (case "x!2 > 3 ")
                         (("1"
                           (assert)
                           (ground)
                           (lemma "Weierstrass_approx_combin1")
                           (name "AA"
                                 "LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                               IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                               ELSE sq((i / N!1) - y!1) * C(N!1, x!2) * C(x!2, i) *
                                                                                                                                                                                                                                                                                                     (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                                               ENDIF")
                           (("1"
                             (replace -1)
                             (name "BB"
                                   "LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                                                 IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                                                 ELSE sq(i / N!1) * C(N!1, x!2) * C(x!2, i) *
                                                                                                                                                                                                                                                                                                                       (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                                                                 ENDIF")
                             (name "CC"
                                   "LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                                                 IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                                                 ELSE -2*(i / N!1)*y!1 * C(N!1, x!2) * C(x!2, i) *
                                                                                                                                                                                                                                                                                                                       (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                                                                 ENDIF")
                             (name "DD"
                                   "LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                                                 IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                                                 ELSE sq(y!1) * C(N!1, x!2) * C(x!2, i) *
                                                                                                                                                                                                                                                                                                                       (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                                                                 ENDIF")
                             (case "NOT AA = BB+CC+DD")
                             (("1"
                               (decompose-equality)
                               (expand "+" 1)
                               (replace -1 :dir rl)
                               (hide -1)
                               (replace -1 :dir rl)
                               (hide -1)
                               (replace -1 :dir rl)
                               (hide -1)
                               (replace -1 :dir rl)
                               (hide -1)
                               (assert)
                               (lift-if)
                               (assert)
                               (ground)
                               (hide 4)
                               (grind :exclude "C"))
                              ("2"
                               (replace -1)
                               (lemma "sigma_sum")
                               (inst - "BB+CC" "DD" "x!2" "0")
                               (expand "+" +)
                               (expand "+" -1)
                               (replace -1 + :dir rl)
                               (hide -1)
                               (lemma "sigma_sum")
                               (inst - "BB" "CC" "x!2" "0")
                               (replace -1 :dir rl)
                               (hide -1)
                               (case "sigma(0,x!2,DD) = 0 AND sigma(0,x!2,BB) = 0 AND sigma(0,x!2,CC) = 0")
                               (("1" (flatten) (assert))
                                ("2"
                                 (hide 3)
                                 (hide -1)
                                 (split +)
                                 (("1"
                                   (replace -1 :dir rl)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (inst - "x!2" "0")
                                   (assert)
                                   (mult-by -1 "sq(y!1)*C(N!1,x!2)")
                                   (("1"
                                     (lemma "sigma_scal")
                                     (inst
                                      -
                                      "LAMBDA (i: nat):
                                                                                                                                                                                                                                                                  IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                  ELSE C(x!2, i) * i ^ 0 * (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                  ENDIF"
                                      "sq(y!1)*C(N!1,x!2)"
                                      "x!2"
                                      "0")
                                     (("1"
                                       (replace -1 :dir rl)
                                       (hide -1)
                                       (case
                                        "(LAMBDA (i_1: nat):
                                                                                                                                                                                                                                                                                sq(y!1) * C(N!1, x!2) *
                                                                                                                                                                                                                                                                                 IF i_1 > x!2 THEN 0
                                                                                                                                                                                                                                                                                 ELSE C(x!2, i_1) * i_1 ^ 0 * (-1) ^ (x!2 - i_1)
                                                                                                                                                                                                                                                                                 ENDIF) = (LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                ELSE sq(y!1) * C(N!1, x!2) * C(x!2, i) * (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                                ENDIF)")
                                       (("1" (assert))
                                        ("2"
                                         (hide 2)
                                         (decompose-equality)
                                         (("1"
                                           (lift-if)
                                           (ground)
                                           (case "x!3^0 = 1")
                                           (("1" (assert))
                                            ("2"
                                             (expand "^" 1)
                                             (expand "expt")
                                             (propax))))
                                          ("2" (skosimp*) (assert))))))
                                      ("2" (skosimp*) (assert))))
                                    ("2" (skosimp*) (assert))))
                                  ("2"
                                   (replace -3 :dir rl)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (inst - "x!2" "2")
                                   (assert)
                                   (mult-by -1 "(1/sq(N!1))*C(N!1,x!2)")
                                   (("1"
                                     (lemma "sigma_scal")
                                     (inst
                                      -
                                      "LAMBDA (i: nat):
                                                                                                                                                                                                                                                                  IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                  ELSE C(x!2, i) * i ^ 2 * (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                  ENDIF"
                                      "((1 / sq(N!1)) * C(N!1, x!2))"
                                      "x!2"
                                      "0")
                                     (("1"
                                       (replace -1 :dir rl)
                                       (hide -1)
                                       (case
                                        "(LAMBDA (i_1: nat):
                                                                                                                                                                                                                                                                                ((1 / sq(N!1)) * C(N!1, x!2)) *
                                                                                                                                                                                                                                                                                 IF i_1 > x!2 THEN 0
                                                                                                                                                                                                                                                                                 ELSE C(x!2, i_1) * i_1 ^ 2 * (-1) ^ (x!2 - i_1)
                                                                                                                                                                                                                                                                                 ENDIF) = (LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                ELSE sq(i / N!1) * C(N!1, x!2) * C(x!2, i) * (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                                ENDIF)")
                                       (("1" (assert))
                                        ("2"
                                         (hide 2)
                                         (decompose-equality)
                                         (("1"
                                           (lift-if)
                                           (ground)
                                           (case "x!3^2 = sq(x!3)")
                                           (("1"
                                             (replace -1)
                                             (hide -1)
                                             (hide -1)
                                             (grind :exclude ("C" "^")))
                                            ("2"
                                             (hide-all-but 1)
                                             (grind))))
                                          ("2" (skosimp*) (assert))))))
                                      ("2" (skosimp*) (assert))))
                                    ("2" (skosimp*) (assert))))
                                  ("3"
                                   (replace -2 :dir rl)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (inst - "x!2" "1")
                                   (assert)
                                   (mult-by -1 "(-2*y!1/N!1)*C(N!1,x!2)")
                                   (("1"
                                     (lemma "sigma_scal")
                                     (inst
                                      -
                                      "(LAMBDA (i: nat):
                                                                                                                                                                                                                                                                  IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                  ELSE C(x!2, i) * i ^ 1 * (-1) ^ (x!2 - i)
                                                                                                                                                                                                                                                                  ENDIF)"
                                      "((-2 * y!1 / N!1) * C(N!1, x!2))"
                                      "x!2"
                                      "0")
                                     (("1"
                                       (replace -1 :dir rl)
                                       (hide -1)
                                       (case
                                        "(LAMBDA (i_1: nat):
                                                                                                                                                                                                                                                                                ((-2 * y!1 / N!1) * C(N!1, x!2)) *
                                                                                                                                                                                                                                                                                 IF i_1 > x!2 THEN 0
                                                                                                                                                                                                                                                                                 ELSE C(x!2, i_1) * i_1 ^ 1 * (-1) ^ (x!2 - i_1)
                                                                                                                                                                                                                                                                                 ENDIF) = (LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                IF i > x!2 THEN 0
                                                                                                                                                                                                                                                                                ELSE -2 *
                                                                                                                                                                                                                                                                                      (C(N!1, x!2) * C(x!2, i) * (-1) ^ (x!2 - i) * (i / N!1)
                                                                                                                                                                                                                                                                                        * y!1)
                                                                                                                                                                                                                                                                                ENDIF)")
                                       (("1" (assert) (grind-reals))
                                        ("2"
                                         (hide 2)
                                         (decompose-equality)
                                         (("1"
                                           (lift-if)
                                           (ground)
                                           (case "x!3^1 = x!3")
                                           (("1"
                                             (replace -1)
                                             (hide -1)
                                             (assert))
                                            ("2"
                                             (expand "^" 1)
                                             (expand "expt")
                                             (expand "expt")
                                             (propax))))
                                          ("2" (skosimp*) (assert))))))
                                      ("2" (skosimp*) (assert))))
                                    ("2" (skosimp*) (assert))))))))))
                            ("2" (skosimp*) (assert))))
                          ("2" (assert))))
                        ("2" (skosimp*) (assert))
                        ("3" (skosimp*) (assert))
                        ("4" (skosimp*) (assert))
                        ("5" (skosimp*) (assert))))
                      ("2"
                       (replace -1)
                       (hide -1)
                       (hide "sqdiffseqdef")
                       (name "AA"
                             "(LAMBDA (i_1: nat):
                                                                                                                                                        IF i_1 > 3 THEN 0
                                                                                                                                                        ELSE sigma(0, i_1,
                                                                                                                                                                   LAMBDA (i: nat):
                                                                                                                                                                     IF i > i_1 THEN 0
                                                                                                                                                                     ELSE sq((i / N!1) - y!1) * C(i_1, i) *
                                                                                                                                                                           C(N!1, i_1)
                                                                                                                                                                           * (-1) ^ (i_1 - i)
                                                                                                                                                                     ENDIF)
                                                                                                                                                        ENDIF
                                                                                                                                                         * (IF i_1 = 0 THEN 1 ELSE x!1 ^ i_1 ENDIF))")
                       (replace -1)
                       (lemma "sigma_split")
                       (inst - "AA" "N!1" "0" "3")
                       (assert)
                       (replace -1)
                       (hide -1)
                       (case "sigma(4,N!1,AA) = 0")
                       (("1"
                         (replace -1)
                         (assert)
                         (hide -1)
                         (replace -1 :dir rl)
                         (hide -1)
                         (expand "sigma")
                         (expand "sigma")
                         (expand "sigma")
                         (expand "sigma")
                         (assert)
                         (case "C(N!1,0) = 1 AND C(N!1,1) = N!1 AND C(N!1,2) = N!1*(N!1-1)/2 AND C(N!1,3) = N!1*(N!1-1)*(N!1-2)/6")
                         (("1"
                           (flatten)
                           (replace -1)
                           (hide -1)
                           (replace -1)
                           (hide -1)
                           (replace -1)
                           (hide -1)
                           (replace -1)
                           (hide -1)
                           (mult-by 1 "sq(N!1)")
                           (grind))
                          ("2"
                           (hide 2)
                           (split +)
                           (("1" (expand "C") (assert))
                            ("2"
                             (expand "C")
                             (expand "factorial" 1 1)
                             (assert))
                            ("3"
                             (expand "C")
                             (expand "factorial" 1 1)
                             (expand "factorial" 1 1)
                             (expand "factorial" 1 3)
                             (assert))
                            ("4"
                             (expand "C")
                             (expand "factorial" 1 1)
                             (expand "factorial" 1 1)
                             (expand "factorial" 1 1)
                             (expand "factorial" 1 2)
                             (assert)
                             (case "factorial(3) = 6")
                             (("1" (replaces -1) (assert))
                              ("2" (hide 2) (grind))))))))
                        ("2"
                         (lemma "sigma_restrict_eq")
                         (inst - "AA" "LAMBDA (i:nat): 0" "N!1" "4")
                         (split -1)
                         (("1"
                           (lemma "sigma_zero")
                           (inst - "N!1" "4")
                           (assert))
                          ("2"
                           (hide 3)
                           (decompose-equality)
                           (expand "restrict")
                           (lift-if)
                           (hide 2)
                           (replace -1 + :dir rl)
                           (hide -1)
                           (ground))))))
                      ("3" (skosimp*) (assert)) ("4" (skosimp*) (assert))
                      ("5" (skosimp*) (assert))
                      ("6" (skosimp*) (assert))))))
                  ("2"
                   (name "sqdiffzzz"
                         "(# index := N!1,bern_seq := (LAMBDA (pj: upto(N!1)): 2*M!1*sq(((pj/N!1)-y!1)/delta!1) + epsilon!1/2) #)")
                   (label "sqdiffzzzname" -1)
                   (name "BNzzz" "Bern_poly(sqdiffzzz)")
                   (("1"
                     (label "BNzzzname" -1)
                     (case "abs(BNf(x!1)-f(y!1)) <= BNzzz(x!1)")
                     (("1"
                       (case "BNzzz(x!1) = ((2 * M!1) / sq(delta!1)) * BNdiff(x!1) + epsilon!1 / 2")
                       (("1" (assert) (replace -1) (propax))
                        ("2"
                         (assert)
                         (hide 2)
                         (hide "bapprox2")
                         (hide -1)
                         (replace "BNzzzname" 1 :dir rl)
                         (replace "sqdiffzzzname" 1 :dir rl)
                         (hide -1)
                         (hide -1)
                         (replace "BNdiffname" :dir rl)
                         (replace "sqdiffseqdef" 1 :dir rl)
                         (hide "BNdiffname")
                         (hide "sqdiffseqdef")
                         (hide "BNfname")
                         (hide "fbsname")
                         (hide "fcont")
                         (hide "intcompact")
                         (hide "funif")
                         (hide "nonempty")
                         (expand "Bern_poly")
                         (lemma "sigma_scal")
                         (inst -
                          "LAMBDA (i: nat):
                                                                                           IF i > N!1 THEN 0
                                                                                           ELSE sq((i / N!1) - y!1) * Bern(i, N!1)(x!1)
                                                                                           ENDIF"
                          "((2 * M!1) / sq(delta!1))" "N!1" "0")
                         (("1"
                           (replace -1 :dir rl)
                           (hide -1)
                           (lemma "Bernstein_partition_of_unity")
                           (inst - "N!1" "x!1")
                           (mult-by -1 "epsilon!1/2")
                           (("1"
                             (lemma "sigma_scal")
                             (inst -
                              "LAMBDA (i: nat):
                                                                                                    IF i > N!1 THEN 0 ELSE Bern(i, N!1)(x!1) ENDIF"
                              "epsilon!1/2" "N!1" "0")
                             (("1"
                               (replace -1 :dir rl)
                               (hide -1)
                               (name "AA"
                                     "LAMBDA (i: nat):
                                                                                                                         IF i > N!1 THEN 0
                                                                                                                         ELSE Bern(i, N!1)(x!1) * (epsilon!1 / 2) +
                                                                                                                               2 *
                                                                                                                                (Bern(i, N!1)(x!1) * sq(((i / N!1) - y!1) / delta!1) *
                                                                                                                                  M!1)
                                                                                                                         ENDIF")
                               (("1"
                                 (replace -1)
                                 (name
                                  "BB"
                                  "LAMBDA (i_1: nat):
                                                                                                                epsilon!1 / 2 *
                                                                                                                 IF i_1 > N!1 THEN 0 ELSE Bern(i_1, N!1)(x!1) ENDIF")
                                 (replace -1)
                                 (hide -1)
                                 (name
                                  "CC"
                                  "LAMBDA (i_1: nat):
                                                                                                                  ((2 * M!1) / sq(delta!1)) *
                                                                                                                   IF i_1 > N!1 THEN 0
                                                                                                                   ELSE sq((i_1 / N!1) - y!1) * Bern(i_1, N!1)(x!1)
                                                                                                                   ENDIF")
                                 (replace -1)
                                 (replace -3 :dir rl)
                                 (case "AA = BB + CC")
                                 (("1"
                                   (replace -1)
                                   (hide -1)
                                   (expand "+" 1 1)
                                   (lemma "sigma_sum")
                                   (inst?)
                                   (assert))
                                  ("2"
                                   (hide 2)
                                   (decompose-equality)
                                   (expand "+" 1)
                                   (expand "AA" +)
                                   (expand "BB" +)
                                   (expand "CC" +)
                                   (lift-if)
                                   (assert)
                                   (ground)
                                   (hide -1)
                                   (hide -1)
                                   (hide -1)
                                   (hide "funif2")
                                   (hide "Mdef")
                                   (grind :exclude "Bern"))))
                                ("2" (skosimp*) (assert))))
                              ("2" (skosimp*) (assert))))
                            ("2" (skosimp*) (assert))))
                          ("2" (skosimp*) (assert))))))
                      ("2"
                       (hide 2)
                       (name "BNfdiffseq"
                             "(# index:= N!1, bern_seq := (LAMBDA (pj:upto(N!1)): f(pj/N!1) - f(y!1)) #)")
                       (label "BNfdiffseq" -1)
                       (name "BNfdiff" "Bern_poly(BNfdiffseq)")
                       (("1"
                         (label "BNfdiffname" -1)
                         (label "BNfdiffseqname" -2)
                         (case "abs(BNf(x!1)-f(y!1)) = abs(BNfdiff(x!1))")
                         (("1"
                           (case "abs(BNfdiff(x!1)) <= BNzzz(x!1)")
                           (("1" (assert))
                            ("2"
                             (hide 2)
                             (hide -1)
                             (replace "BNfdiffname" 1 :dir rl)
                             (replace "BNzzzname" 1 :dir rl)
                             (expand "BNfdiffseq" 1)
                             (expand "sqdiffzzz" 1)
                             (expand "Bern_poly" 1)
                             (hide "bapprox2")
                             (hide "nonempty")
                             (hide "BNfname")
                             (hide "fbsname")
                             (hide "sqdiffseqdef")
                             (hide "sqdiffzzzname")
                             (lemma "sigma_abs")
                             (inst -
                              "(LAMBDA (i: nat):
                                                                                                        IF i > N!1 THEN 0
                                                                                                        ELSE Bern(i, N!1)(x!1) * f(i / N!1) -
                                                                                                              Bern(i, N!1)(x!1) * f(y!1)
                                                                                                        ENDIF)"
                              "N!1" "0")
                             (("1"
                               (lemma "sigma_le")
                               (inst -
                                "LAMBDA (n: nat):
                                                                                                           abs(IF n > N!1 THEN 0
                                                                                                               ELSE Bern(n, N!1)(x!1) * f(n / N!1) -
                                                                                                                     Bern(n, N!1)(x!1) * f(y!1)
                                                                                                               ENDIF)"
                                "LAMBDA (i: nat):
                                                                                                           IF i > N!1 THEN 0
                                                                                                           ELSE Bern(i, N!1)(x!1) * (epsilon!1 / 2) +
                                                                                                                 2 *
                                                                                                                  (Bern(i, N!1)(x!1) * sq(((i / N!1) - y!1) / delta!1)
                                                                                                                    * M!1)
                                                                                                           ENDIF"
                                "N!1" "0")
                               (("1"
                                 (assert)
                                 (hide 2)
                                 (hide -1)
                                 (skosimp*)
                                 (case
                                  "FORALL (x1,y1: (closed_intv(0,1))): abs(f(x1)-f(y1)) <= 2*M!1*sq((x1-y1)/delta!1) + epsilon!1/2")
                                 (("1"
                                   (inst - "n!1/N!1" "y!1")
                                   (("1"
                                     (lemma "Bern_nonnegative")
                                     (inst - "x!1")
                                     (assert)
                                     (inst - "n!1" "N!1")
                                     (mult-by -2 "Bern(n!1,N!1)(x!1)")
                                     (case
                                      "abs(Bern(n!1,N!1)(x!1)) = Bern(n!1,N!1)(x!1)")
                                     (("1"
                                       (replace -1 -2 :dir rl)
                                       (hide -1)
                                       (rewrite "abs_mult" :dir rl)
                                       (expand "abs" -1 2)
                                       (assert))
                                      ("2" (expand "abs" 1) (assert))))
                                    ("2" (assert) (cross-mult 1))))
                                  ("2"
                                   (assert)
                                   (hide 2)
                                   (skosimp*)
                                   (case "abs(x1!1-y1!1) < delta!1")
                                   (("1"
                                     (inst "funif2" "x1!1" "y1!1")
                                     (assert))
                                    ("2"
                                     (case
                                      "sq((x1!1 - y1!1)/delta!1) >= 1")
                                     (("1"
                                       (mult-by -1 "2*M!1")
                                       (case
                                        "abs(f(x1!1)-f(y1!1)) <= 2*M!1")
                                       (("1" (assert))
                                        ("2"
                                         (lemma "triangle")
                                         (inst - "f(x1!1)" "-f(y1!1)")
                                         (rewrite "abs_neg")
                                         (copy "Mdef")
                                         (inst-cp - "x1!1")
                                         (inst - "y1!1")
                                         (assert))))
                                      ("2"
                                       (lemma "sq_lt")
                                       (inst
                                        -
                                        "abs(x1!1-y1!1)"
                                        "delta!1")
                                       (rewrite "sq_abs")
                                       (assert)
                                       (rewrite "sq_div")
                                       (cross-mult 2))))))))
                                ("2" (assert) (skosimp*) (assert))))
                              ("2" (skosimp*) (assert))))))
                          ("2"
                           (case "BNf(x!1) - f(y!1) = BNfdiff(x!1)")
                           (("1" (assert))
                            ("2"
                             (hide 2)
                             (hide 2)
                             (hide 2)
                             (hide 2)
                             (replace "BNfname" 1 :dir rl)
                             (replace "BNfdiffname" 1 :dir rl)
                             (replace "fbsname" 1 :dir rl)
                             (replace "BNfdiffseqname" 1 :dir rl)
                             (expand "Bern_poly" 1)
                             (hide "fcont")
                             (hide "intcompact")
                             (hide "Mdef")
                             (hide "funif")
                             (hide "funif2")
                             (lemma "Bernstein_partition_of_unity")
                             (inst - "N!1" "x!1")
                             (mult-by -1 "-f(y!1)")
                             (("1"
                               (lemma "sigma_scal")
                               (inst -
                                "LAMBDA (i: nat):
                                                                            IF i > N!1 THEN 0 ELSE Bern(i, N!1)(x!1) ENDIF"
                                "-f(y!1)" "N!1" "0")
                               (("1"
                                 (replace -1 :dir rl)
                                 (hide -1)
                                 (hide "sqdiffzzzname")
                                 (hide "BNfdiffseqname")
                                 (name
                                  "AA"
                                  "LAMBDA (i: nat):
                                                                                 IF i > N!1 THEN 0
                                                                                 ELSE Bern(i, N!1)(x!1) * f(i / N!1) -
                                                                                       Bern(i, N!1)(x!1) * f(y!1)
                                                                                 ENDIF")
                                 (("1"
                                   (replace -1)
                                   (name
                                    "BB"
                                    "LAMBDA (i: nat):
                                                                                    IF i > N!1 THEN 0 ELSE f(i / N!1) * Bern(i, N!1)(x!1) ENDIF")
                                   (replace -1)
                                   (name
                                    "CC"
                                    "LAMBDA (i_1: nat):
                                                                                    -f(y!1) * IF i_1 > N!1 THEN 0 ELSE Bern(i_1, N!1)(x!1) ENDIF")
                                   (replace -1)
                                   (case "AA = BB + CC")
                                   (("1"
                                     (lemma "sigma_sum")
                                     (replace -2 1)
                                     (expand "+" +)
                                     (inst - "BB" "CC" "N!1" "0")
                                     (assert))
                                    ("2"
                                     (hide 2)
                                     (decompose-equality)
                                     (expand "+" 1)
                                     (expand "AA" +)
                                     (expand "BB" +)
                                     (expand "CC" +)
                                     (lift-if)
                                     (ground))))
                                  ("2" (skosimp*) (assert))))
                                ("2" (skosimp*) (assert))))
                              ("2" (skosimp*) (assert))))))))
                        ("2" (skosimp*) (ground))))))
                    ("2"
                     (skosimp*)
                     (hide 2)
                     (hide 2)
                     (hide 2)
                     (assert)
                     (split +)
                     (("1" (skosimp*) (ground))
                      ("2" (skosimp*) (assert))))))))
                ("2" (ground) (skosimp*) (ground))))))))
          ("2"
           (lemma "archimedean")
           (inst - "1/max(5,(M!1 / (delta!1 ^ 2 * epsilon!1)))")
           (skosimp*)
           (cross-mult -1)
           (expand "max")
           (lift-if)
           (ground))))
        ("2"
         (lemma "archimedean")
         (inst - "1/max(5,(M!1 / (delta!1 ^ 2 * epsilon!1)))")
         (skosimp*)
         (inst + "n!1")
         (("1" (cross-mult -1) (expand "max") (lift-if) (ground))
          ("2" (cross-mult -1) (expand "max") (lift-if) (ground))))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cont_if_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "discont_pts")
   (expand "continuous?")
   (inst - "1")
   (skosimp*)
   (expand "b2n")
   (lift-if)
   (case "P(a)")
   (("1"
     (assert)
     (inst + "delta!1")
     (flatten)
     (skosimp*)
     (assert)
     (inst - "x!1")
     (assert)
     (expand "abs")
     (assert))
    ("2"
     (assert)
     (inst + "delta!1")
     (skosimp*)
     (assert)
     (inst - "x!2")
     (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cont_if_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "continuous?")
   (skeep)
   (rewrite continuity_def)
   (expand "if_fun")
   (expand "continuous?")
   (expand "convergence")
   (expand "convergence")
   (expand "fullset")
   (prop)
   (("1" (hide -) (expand "adh") (skosimp*) (inst + x0) (assert))
    ("2"
     (skosimp*)
     (inst - "x0")
     (inst -2 "x0")
     (inst - "epsilon!1/2")
     (inst - "epsilon!1/2")
     (skosimp*)
     (inst -3 "x0")
     (case "discont_pts(P)(x0)")
     (("1"
       (inst + "min(delta!1,delta!2)")
       (skosimp*)
       (case "P(x0)")
       (("1"
         (assert)
         (case "P(x!1)")
         (("1" (assert) (inst -5 "x!1") (assert))
          ("2" (assert) (inst -5 "x!1") (assert))))
        ("2"
         (case "P(x!1)")
         (("1" (assert) (inst -4 "x!1") (assert))
          ("2" (assert) (inst -4 "x!1") (assert))))))
      ("2"
       (hide -3)
       (lemma "discont_pts_lem")
       (inst?)
       (assert)
       (skosimp*)
       (split -1)
       (("1"
         (case "P(x0)")
         (("1"
           (assert)
           (inst + "min(delta!1,delta!3)")
           (hide -4)
           (skosimp*)
           (assert)
           (inst - "x!1")
           (inst - "x!1")
           (assert))
          ("2" (grind))))
        ("2"
         (inst + "min(delta!2,delta!3)")
         (skosimp*)
         (inst - "x!1")
         (assert)
         (case "P(x0)")
         (("1" (assert) (reveal -1) (inst - "x0") (assert))
          ("2" (assert) (inst -3 "x!1") (assert))))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cont_if_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "discont_pts")
   (expand "b2n")
   (expand "continuous?")
   (expand "continuous?")
   (skosimp*)
   (lift-if)
   (case "P!1(x!1)")
   (("1"
     (assert)
     (inst - "x!1")
     (inst -3 "x!1")
     (replace -4 * lr)
     (hide -4)
     (assert)
     (flatten)
     (inst - "f1!1(x!1)/2")
     (("1"
       (inst - "f2!1(x!1)/2")
       (("1"
         (skosimp*)
         (inst + "min(delta!1,delta!2)")
         (skosimp*)
         (lift-if)
         (prop)
         (("1" (assert)) ("2" (inst -4 "x!2") (assert) (assert) (grind))
          ("3" (inst -4 "x!2") (assert) (grind))))
        ("2" (prop) (("1" (assert)) ("2" (assert))))))
      ("2" (prop) (("1" (assert)) ("2" (assert))))))
    ("2"
     (assert)
     (inst - "x!1")
     (inst -2 "x!1")
     (replace -3 * lr)
     (assert)
     (split 1)
     (("1"
       (inst - "-f1!1(x!1)/2")
       (("1"
         (case "f2!1(x!1) > 0")
         (("1"
           (inst - "f2!1(x!1)/2")
           (("1"
             (skosimp*)
             (inst + "min(delta!1,delta!2)")
             (skosimp*)
             (inst - "x!2")
             (inst - "x!2")
             (assert)
             (grind))
            ("2" (assert))))
          ("2"
           (inst - "-f2!1(x!1)/2")
           (("1"
             (skosimp*)
             (inst + "min(delta!1,delta!2)")
             (skosimp*)
             (inst - "x!2")
             (inst - "x!2")
             (assert)
             (grind))
            ("2" (assert))))))
        ("2" (assert))))
      ("2"
       (assert)
       (inst -2 "-f2!1(x!1)/2")
       (case "f1!1(x!1) > 0")
       (("1"
         (inst - "f1!1(x!1)/2")
         (("1"
           (skosimp*)
           (inst + "min(delta!1,delta!2)")
           (skosimp*)
           (inst - "x!2")
           (inst - "x!2")
           (assert)
           (grind))
          ("2" (assert))))
        ("2"
         (inst - "-f1!1(x!1)/2")
         (("1"
           (skosimp*)
           (inst + "min(delta!1,delta!2)")
           (skosimp*)
           (inst - "x!2")
           (inst - "x!2")
           (assert)
           (grind))
          ("2" (assert))))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: cont_if_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (lemma "discont_pts_simple")
   (inst?)
   (inst - "x")
   (assert)
   (split -1)
   (("1" (replace -1) (assert)) ("2" (replace -1) (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: linear_functions
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "linear?")
   (skosimp*)
   (inst + "m!1+m!2" "k!1+k!2")
   (expand "+ ")
   (replace -1 * lr)
   (hide -1)
   (replace -1 * lr)
   (hide -1)
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "linear?")
   (skosimp*)
   (replace -1 * lr)
   (hide -1)
   (expand "continuous?")
   (skosimp*)
   (lemma "identity_continuous[T]")
   (inst -1 "x0!1")
   (lemma "scal_continuous[T]")
   (inst -1 "I[T]" "m!1" "x0!1")
   (assert)
   (hide -2)
   (lemma "sum_continuous[T]")
   (inst -1 "m!1 * I[T]" "const_fun(k!1)" "x0!1")
   (assert)
   (split -1)
   (("1"
     (expand "*")
     (expand "const_fun")
     (expand "+ ")
     (expand "I")
     (propax))
    ("2" (rewrite "const_continuous[T]"))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous_in?")
   (skosimp*)
   (rewrite continuity_def)
   (expand "convergence")
   (expand "convergence")
   (expand "fullset")
   (expand "linear_on?")
   (skosimp*)
   (prop)
   (("1"
     (expand "adh")
     (skosimp*)
     (inst + "min(x!1+e!1/2,(x!1+b!1)/2)")
     (("1" (hide -1) (grind))
      ("2"
       (expand "min")
       (ground)
       (("1"
         (lemma "connected_domain")
         (inst?)
         (inst -1 "a!1" "b!1")
         (assert))
        ("2"
         (lemma "connected_domain")
         (inst?)
         (inst -1 "a!1" "b!1")
         (assert))))))
    ("2"
     (skosimp*)
     (case-replace "m!1 = 0")
     (("1"
       (inst + "min(epsilon!1,min(abs(x!1-a!1),abs(b!1-x!1)))")
       (("1"
         (skosimp*)
         (inst-cp -3 "x!1")
         (inst - "x!2")
         (assert)
         (split -3)
         (("1" (replace -1) (hide -1) (replace -3) (assert))
          ("2"
           (expand "abs")
           (assert)
           (hide -1 -3 2)
           (case "abs(x!2 - x!1) < abs(x!1 - a!1)")
           (("1" (hide -2) (grind))
            ("2" (expand "min") (lift-if) (ground))))
          ("3"
           (case "abs(x!2 - x!1) < abs(b!1 - x!1)")
           (("1" (hide -3) (grind)) ("2" (hide 3) (grind))))))
        ("2" (grind))))
      ("2"
       (inst + "min(epsilon!1/abs(m!1),min(abs(x!1-a!1),abs(b!1-x!1)))")
       (("1"
         (skosimp*)
         (inst-cp - "x!1")
         (inst - "x!2")
         (assert)
         (split -2)
         (("1"
           (replace -1)
           (hide -1)
           (replace -2)
           (hide -2)
           (assert)
           (case-replace "m!1 * x!2 - m!1 * x!1 = m!1 * (x!2 - x!1)")
           (("1"
             (rewrite "abs_mult")
             (case "abs(x!2 - x!1) < epsilon!1 / abs(m!1)")
             (("1" (hide -3) (cross-mult -1) (assert))
              ("2" (hide-all-but (-2 1)) (grind))))
            ("2" (assert))))
          ("2"
           (ground)
           (case "abs(x!2 - x!1) <
                                                      abs(x!1 - a!1)")
           (("1" (hide -2 3) (grind)) ("2" (hide 4) (grind))))
          ("3"
           (case "abs(x!2 - x!1) <      abs(b!1 - x!1)")
           (("1" (hide -1 3) (grind)) ("2" (hide 4) (grind))))))
        ("2"
         (case "epsilon!1 / abs(m!1) > 0")
         (("1" (name-replace "EOM" "epsilon!1 / abs(m!1)") (grind))
          ("2" (hide 2) (cross-mult 1) (grind)) ("3" (hide 2) (grind))))
        ("3" (hide -1) (lemma "abs_eq_0") (inst?) (assert))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (assert)
   (rewrite continuity_def)
   (expand "convergence")
   (expand "fullset")
   (expand "linear_on?")
   (skosimp*)
   (expand "convergence")
   (prop)
   (("1"
     (expand "adh")
     (skosimp*)
     (inst + "b!1")
     (expand "abs")
     (assert))
    ("2"
     (skosimp*)
     (case "m!1 = 0 AND m!2 = 0")
     (("1"
       (flatten)
       (replace -1)
       (replace -2)
       (assert)
       (inst + "min(abs(b!1-a!1),abs(c!1-b!1))")
       (("1"
         (skosimp*)
         (lift-if)
         (ground)
         (("1"
           (hide -9)
           (inst-cp - "x!1")
           (inst - "b!1")
           (assert)
           (replace -8)
           (split -9)
           (("1" (replace -1) (assert))
            ("2" (expand "abs") (assert) (hide 2) (grind))))
          ("2"
           (hide -7)
           (inst-cp - "x!1")
           (inst - "b!1")
           (assert)
           (replace -4 * rl)
           (replace -7)
           (split -8)
           (("1" (replace -1) (expand "abs") (assert))
            ("2" (hide 3) (grind))))))
        ("2" (grind))))
      ("2"
       (name "Mabc" "min(abs(b!1-a!1),abs(c!1-b!1))")
       (case-replace "m!1 = 0")
       (("1"
         (assert)
         (hide -1)
         (inst + "min(epsilon!1/abs(m!2), Mabc)")
         (("1"
           (skosimp*)
           (lift-if)
           (case "x!1 <= b!1")
           (("1"
             (assert)
             (replace -2 * rl)
             (hide -2)
             (hide -7)
             (inst-cp - "x!1")
             (inst - "b!1")
             (assert)
             (replace -6)
             (split -7)
             (("1" (replace -1) (assert))
              ("2" (expand "abs") (assert) (grind))))
            ("2"
             (assert)
             (hide -6)
             (hide -2)
             (replace -2)
             (inst-cp - "x!1")
             (inst - "b!1")
             (assert)
             (replace -5)
             (split -6)
             (("1"
               (replace -1)
               (assert)
               (case-replace "m!2 * x!1 - m!2 * b!1 = m!2 * (x!1 - b!1)")
               (("1"
                 (rewrite "abs_mult")
                 (div-by 3 "abs(m!2)")
                 (grind :exclude "abs"))
                ("2" (assert))))
              ("2" (hide 4) (grind))))))
          ("2"
           (case "epsilon!1 / abs(m!2) > 0")
           (("1" (grind))
            ("2"
             (case "abs(m!2) = 0")
             (("1" (expand "abs" -1) (assert) (lift-if) (ground))
              ("2" (mult-by 2 "abs(m!2)") (assert))))
            ("3"
             (expand "abs" 1)
             (assert)
             (ground)
             (("1" (lift-if) (ground)) ("2" (lift-if) (ground))))))
          ("3" (expand "abs" 1) (lift-if) (ground))))
        ("2"
         (assert)
         (case-replace "m!2 = 0")
         (("1"
           (hide -1)
           (inst + "min(epsilon!1/abs(m!1), Mabc)")
           (("1"
             (skosimp*)
             (assert)
             (lift-if)
             (case "x!1 <= b!1")
             (("1"
               (assert)
               (replace -2 * rl)
               (hide -2)
               (hide -7)
               (inst-cp - "x!1")
               (inst - "b!1")
               (replace -1)
               (split -6)
               (("1"
                 (replace -1)
                 (split -7)
                 (("1"
                   (replace -1)
                   (assert)
                   (case-replace
                    "m!1 * x!1 - m!1 * b!1 = m!1 * (x!1 - b!1)")
                   (("1"
                     (hide -1)
                     (rewrite "abs_mult")
                     (div-by 2 "abs(m!1)")
                     (grind :exclude "abs"))
                    ("2" (assert))))
                  ("2" (hide 3) (grind))))
                ("2" (assert)) ("3" (assert))))
              ("2"
               (assert)
               (replace -1 * rl)
               (hide -1)
               (hide -5)
               (replace -2)
               (inst-cp - "x!1")
               (inst - "b!1")
               (assert)
               (replace -5)
               (split -6)
               (("1" (replace -1) (expand "abs") (assert))
                ("2" (hide 4) (grind))))))
            ("2"
             (case "epsilon!1 / abs(m!1) > 0")
             (("1" (grind))
              ("2"
               (hide 2)
               (case "abs(m!1) = 0")
               (("1" (expand "abs") (lift-if) (ground))
                ("2" (cross-mult 2) (assert))))
              ("3" (assert))))
            ("3"
             (expand "abs" 1)
             (assert)
             (flatten)
             (expand "abs")
             (lift-if)
             (ground))))
          ("2"
           (assert)
           (case-replace "abs(m!1) > 0 AND abs(m!2) > 0")
           (("1"
             (flatten)
             (name "MEPS" "min(epsilon!1/abs(m!1),epsilon!1/abs(m!2))")
             (("1"
               (inst + "min(MEPS,Mabc)")
               (("1"
                 (skosimp*)
                 (lift-if)
                 (case "x!1 <= b!1")
                 (("1"
                   (assert)
                   (hide -11)
                   (inst-cp - "x!1")
                   (inst - "b!1")
                   (assert)
                   (replace -10)
                   (split -11)
                   (("1"
                     (replace -1)
                     (case-replace
                      "m!1 * x!1 - m!1 * b!1 = m!1 * (x!1 - b!1)")
                     (("1"
                       (rewrite "abs_mult")
                       (div-by 3 "abs(m!1)")
                       (case-replace "abs((x!1 - b!1)) < MEPS")
                       (("1"
                         (replace -5 * rl)
                         (hide-all-but (-1 1 2 3))
                         (expand "min")
                         (lift-if)
                         (ground))
                        ("2" (hide 4) (hide -7) (grind :exclude "abs"))))
                      ("2" (assert))))
                    ("2"
                     (assert)
                     (assert)
                     (hide 4)
                     (hide -2)
                     (hide -2 -3)
                     (replace -2 * rl)
                     (hide -2)
                     (grind))))
                  ("2"
                   (assert)
                   (hide -9)
                   (replace -6)
                   (hide -6)
                   (inst-cp - "x!1")
                   (inst - "b!1")
                   (assert)
                   (split -9)
                   (("1"
                     (replace -1)
                     (hide -1)
                     (replace -8)
                     (hide -8)
                     (assert)
                     (case-replace
                      "m!2 * x!1 - m!2 * b!1 = m!2 * (x!1 - b!1)")
                     (("1"
                       (rewrite "abs_mult")
                       (div-by 4 "abs(m!2)")
                       (hide -1 -3 -5)
                       (grind :exclude "abs"))
                      ("2" (assert))))
                    ("2" (hide 5) (hide -1) (grind))))))
                ("2"
                 (case "MEPS > 0 AND Mabc > 0")
                 (("1" (flatten) (expand "min" 1) (lift-if) (ground))
                  ("2"
                   (hide 2)
                   (split +)
                   (("1"
                     (case-replace
                      "epsilon!1 / abs(m!1) > 0 AND epsilon!1 / abs(m!2) > 0 ")
                     (("1" (hide -3) (hide -4) (grind :exclude "abs"))
                      ("2"
                       (prop)
                       (("1"
                         (case "abs(m!1) > 0")
                         (("1" (cross-mult 1) (assert)) ("2" (propax))))
                        ("2" (cross-mult 1) (assert))))))
                    ("2"
                     (expand "abs" -2)
                     (lift-if)
                     (ground)
                     (("1" (hide -1) (hide -2 -8 -9) (grind))
                      ("2" (hide -2 -8 -9) (grind))))))))))
              ("2" (assert)) ("3" (assert))))
            ("2"
             (expand "abs" 1)
             (lift-if)
             (ground)
             (("1" (lift-if) (ground)) ("2" (lift-if) (ground))
              ("3" (lift-if) (ground))
              ("4" (lift-if) (ground))))))))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite continuity_def)
   (rewrite continuity_def)
   (expand "convergence")
   (expand "fullset")
   (expand "convergence")
   (flatten)
   (prop)
   (skosimp*)
   (inst -5 "epsilon!1")
   (assert)
   (skosimp*)
   (inst + "min(delta!1,min(x!1 -a!1,b!1-x!1))")
   (("1"
     (skosimp*)
     (inst-cp - "x!1")
     (inst - "x!2")
     (inst - "x!2")
     (assert))
    ("2" (assert) (hide -5 -6 2) (grind))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "top")
   (assert)
   (typepred "lub(extend[real, T, bool, FALSE](fullset[T]))")
   (("1"
     (expand "least_upper_bound?")
     (flatten)
     (expand "upper_bound?")
     (inst?)
     (expand "extend")
     (expand "fullset")
     (propax))
    ("2"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "a!1")
     (expand "extend")
     (expand "fullset")
     (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "top")
   (assert)
   (lift-if)
   (ground)
   (("1"
     (typepred "lub(extend[real, T, bool, FALSE](fullset[T]))")
     (("1"
       (expand "least_upper_bound?")
       (flatten)
       (inst - "y!1")
       (assert))
      ("2"
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (inst -1 "a!1")
       (expand "extend")
       (expand "fullset")
       (propax))))
    ("2"
     (expand "upper_bound?")
     (inst -1 "a!1")
     (expand "extend")
     (expand "fullset")
     (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "bot")
   (assert)
   (typepred "glb(extend[real, T, bool, FALSE](fullset[T]))")
   (("1"
     (expand "greatest_lower_bound?")
     (flatten)
     (expand "lower_bound?")
     (inst?)
     (expand "extend")
     (expand "fullset")
     (propax))
    ("2"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "a!1")
     (expand "extend")
     (expand "fullset")
     (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "bot")
   (assert)
   (lift-if)
   (prop)
   (("1"
     (typepred "glb(extend[real, T, bool, FALSE](fullset[T]))")
     (("1"
       (expand "greatest_lower_bound?")
       (flatten)
       (inst - "y!1")
       (assert))
      ("2"
       (assert)
       (expand "nonempty?")
       (expand "empty?")
       (expand "member")
       (inst - "a!1")
       (assert)
       (expand "extend")
       (expand "fullset")
       (propax))))
    ("2"
     (expand "lower_bound?")
     (inst?)
     (expand "extend")
     (expand "fullset")
     (propax))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (stop-rewrite "abs_0")
   (skosimp*)
   (rewrite continuity_def)
   (expand "convergence")
   (expand "fullset")
   (expand "convergence")
   (prop)
   (("1"
     (expand "adh")
     (skosimp*)
     (inst + "IF x!1 - a!1 < e!1 THEN a!1 ELSE x!1 - e!1/2 ENDIF")
     (("1" (lift-if) (expand "abs") (lift-if) (ground))
      ("2"
       (flatten)
       (lemma "connected_domain")
       (inst -1 "a!1" "x!1" "_")
       (inst?)
       (assert))))
    ("2"
     (skosimp*)
     (expand "linear_on?")
     (skosimp*)
     (inst +
      "IF m!1 = 0 THEN min(epsilon!1,x!1-a!1)
                                              ELSE min(epsilon!1/abs(m!1),x!1-a!1)
                                              ENDIF")
     (("1"
       (skosimp*)
       (inst-cp - "x!1")
       (inst - "x!2")
       (assert)
       (split -6)
       (("1"
         (split -7)
         (("1"
           (replace -1)
           (hide -1)
           (replace -1)
           (hide -1)
           (assert)
           (case-replace "m!1 * x!2 - m!1 * x!1 = m!1 * (x!2 - x!1)")
           (("1"
             (rewrite "abs_mult")
             (hide -1)
             (lift-if)
             (ground)
             (case "abs(x!2 - x!1) < epsilon!1 / abs(m!1)")
             (("1" (cross-mult -1) (assert))
              ("2" (hide 2) (expand "min") (lift-if) (ground))))
            ("2" (hide 2) (assert))))
          ("2"
           (hide 2)
           (lemma "top_lem")
           (inst?)
           (assert)
           (expand "fullset")
           (inst?))))
        ("2" (hide 2) (hide -4 -5) (grind))
        ("3"
         (hide 2)
         (lemma "top_lem")
         (inst?)
         (expand "fullset")
         (inst?))))
      ("2"
       (flatten)
       (hide -3 -5)
       (assert)
       (case "min(epsilon!1 / abs(m!1), x!1 - a!1) > 0")
       (("1" (assert))
        ("2"
         (hide 3)
         (grind)
         (("1" (cross-mult 2) (assert)) ("2" (cross-mult 3) (assert))
          ("3" (cross-mult 2) (assert)) ("4" (cross-mult 3) (assert))))))
      ("3" (expand "abs") (ground) (lift-if) (ground))
      ("4" (flatten) (hide -4 -5 -6) (grind))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (rewrite continuity_def)
   (hide -4)
   (expand "convergence")
   (expand "fullset")
   (expand "convergence")
   (prop)
   (("1"
     (expand "adh")
     (skosimp*)
     (inst + "IF a!1 - x!1 < e!1 THEN a!1 ELSE x!1 + e!1/2 ENDIF")
     (("1" (lift-if) (expand "abs") (lift-if) (ground))
      ("2"
       (flatten)
       (lemma "connected_domain")
       (inst -1 "x!1" "a!1" "_")
       (inst?)
       (assert))))
    ("2"
     (skosimp*)
     (expand "linear_on?")
     (skosimp*)
     (inst +
      "IF m!1 = 0 THEN min(epsilon!1,a!1-x!1)
                                                      ELSE min(epsilon!1/abs(m!1),a!1-x!1)
                                                      ENDIF")
     (("1"
       (skosimp*)
       (inst-cp - "x!1")
       (inst - "x!2")
       (assert)
       (split -5)
       (("1"
         (split -6)
         (("1"
           (replace -1)
           (hide -1)
           (replace -1)
           (hide -1)
           (assert)
           (case-replace "m!1 * x!2 - m!1 * x!1 = m!1 * (x!2 - x!1)")
           (("1"
             (rewrite "abs_mult")
             (hide -1)
             (lift-if)
             (ground)
             (case "abs(x!2 - x!1) < epsilon!1 / abs(m!1)")
             (("1" (cross-mult -1) (assert))
              ("2" (hide 3) (expand "min") (lift-if) (ground))))
            ("2" (hide 2) (assert))))
          ("2"
           (lemma "bot_lem")
           (inst?)
           (assert)
           (expand "fullset")
           (inst?))))
        ("2" (lemma "bot_lem") (expand "fullset") (inst?))
        ("3" (hide -4 -5 2) (grind))))
      ("2"
       (flatten)
       (hide -3 -4)
       (case "min(epsilon!1 / abs(m!1), a!1 - x!1) > 0")
       (("1" (assert))
        ("2"
         (hide 3)
         (grind)
         (("1" (cross-mult 2) (assert)) ("2" (cross-mult 3) (assert))))
        ("3" (hide 3) (expand "abs") (lift-if) (ground))))
      ("3" (flatten) (expand "abs" -1) (lift-if) (ground))
      ("4" (flatten) (hide -4 -5) (grind))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: continuous_linear
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous?")
   (skosimp*)
   (expand "piecewise_linear?")
   (inst?)
   (split -1)
   (("1"
     (lemma "cont_in_linear")
     (expand "on_linear_part?")
     (skosimp*)
     (inst?)
     (assert)
     (expand "continuous_in?")
     (inst?)
     (assert))
    ("2"
     (expand "on_linear_top?")
     (skosimp*)
     (typepred "x0!1")
     (lemma "cont_upto_lub")
     (inst?)
     (assert)
     (inst -1 "a!1")
     (assert)
     (expand "top")
     (propax))
    ("3"
     (expand "on_linear_bottom?")
     (flatten)
     (typepred "x0!1")
     (skosimp*)
     (lemma "cont_downto_glb")
     (inst?)
     (inst -1 "a!1")
     (assert))
    ("4"
     (expand "on_junction?")
     (skosimp*)
     (lemma "piecewise")
     (inst - "a!1" "x0!1" "c!1" "(LAMBDA (y: T): k1!1 + m1!1 * y)"
      "(LAMBDA (y: T): k2!1 + m2!1 * y)")
     (assert)
     (split -1)
     (("1"
       (lemma "cont_piece")
       (inst -1 "a!1" "c!1" "_" "f!1" "x0!1")
       (inst?)
       (assert)
       (skosimp*)
       (lift-if)
       (ground)
       (("1" (inst - "y!1") (assert))
        ("2" (inst - "y!1") (inst - "y!1") (assert))))
      ("2"
       (expand "linear_on?")
       (inst + "m1!1" "k1!1")
       (skosimp*)
       (inst - "x!1")
       (assert))
      ("3"
       (expand "linear_on?")
       (inst + "m2!1" "k2!1")
       (skosimp*)
       (inst - "x!1")
       (inst - "x!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skeep)
   (lemma "interm_value2")
   (case "p<q")
   (("1"
     (inst - "p" "q" "x")
     (assert)
     (name "fpq" "(LAMBDA (xy:closed_interval(p,q)): f(xy))")
     (inst - "fpq")
     (split -)
     (("1" (skosimp*) (inst + "c!1") (assert) (expand "fpq") (propax))
      ("2"
       (hide 2)
       (hide -1)
       (expand "continuous?")
       (skosimp*)
       (inst - "x0!1")
       (expand "continuous?")
       (skosimp*)
       (inst - "epsilon!1")
       (skosimp*)
       (inst + "delta!1")
       (skosimp*)
       (inst - "x!1")
       (assert)
       (expand "fpq")
       (propax))
      ("3" (expand "fpq") (propax)) ("4" (expand "fpq") (propax))))
    ("2"
     (hide -1)
     (lemma "interm_value4")
     (inst - "q" "p" "x")
     (case "q/=p")
     (("1"
       (flatten)
       (assert)
       (name "fqp" "(LAMBDA (xy:closed_interval(q,p)): f(xy))")
       (inst - "fqp")
       (split -)
       (("1" (skosimp*) (inst + "c!1") (assert) (expand "fqp") (propax))
        ("2"
         (hide 4)
         (hide -1)
         (expand "continuous?")
         (skosimp*)
         (inst - "x0!1")
         (expand "continuous?")
         (skosimp*)
         (inst - "epsilon!1")
         (skosimp*)
         (inst + "delta!1")
         (skosimp*)
         (inst - "x!1")
         (assert)
         (expand "fqp")
         (propax))
        ("3" (expand "fqp") (propax)) ("4" (expand "fqp") (propax))))
      ("2" (flatten) (inst + "p") (ground))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous?")
   (skosimp*)
   (inst - "x0!1")
   (expand "continuous?")
   (skosimp*)
   (inst - "epsilon!1")
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "intermediate_value1[a!1,b!1]")
   (("1"
     (inst?)
     (assert)
     (split -1)
     (("1" (propax))
      ("2" (hide 2) (assert) (expand "restrict") (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "intermediate_value2[a!1,b!1]")
   (("1"
     (inst?)
     (assert)
     (split -1)
     (("1" (propax))
      ("2" (hide 2) (assert) (expand "restrict") (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "intermediate_value3[a!1,b!1]")
   (("1"
     (inst?)
     (assert)
     (split -1)
     (("1" (propax))
      ("2" (hide 2) (assert) (expand "restrict") (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "intermediate_value4[a!1,b!1]")
   (("1"
     (inst?)
     (assert)
     (split -1)
     (("1" (propax))
      ("2" (hide 2) (assert) (expand "restrict") (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (skosimp*)
   (case-replace "x!1 < x!2")
   (("1"
     (lemma "intermediate_value1[x!1,x!2]")
     (("1"
       (inst - "(LAMBDA (x:J[x!1, x!2]): f(x))" "0")
       (("1"
         (assert)
         (split -1)
         (("1" (skosimp*) (inst - "c!1") (assert))
          ("2" (assert) (lemma "cont_intv") (inst?) (assert))
          ("3" (assert) (inst -5 "x!1") (assert))
          ("4" (assert) (inst -5 "x!2") (assert))))
        ("2" (assert))))
      ("2" (assert))))
    ("2"
     (case "x!2 = x!1")
     (("1" (assert) (inst - "x!2") (assert))
      ("2"
       (lemma "intermediate_value4[x!2,x!1]")
       (("1"
         (inst - "(LAMBDA (x:J[x!2, x!1]): f(x))" "0")
         (("1"
           (assert)
           (split -1)
           (("1" (skosimp*) (assert) (inst - "c!1") (assert))
            ("2" (assert) (lemma "cont_intv") (inst?) (assert))))
          ("2" (assert))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: interm_value_thm
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "x!1 < y!1")
   (("1"
     (case "f!1(x!1) > 0")
     (("1"
       (lemma "interm_value4")
       (inst -1 "x!1" "y!1" "0")
       (assert)
       (inst -1 "LAMBDA (z:closed_interval[real](x!1,y!1)): f!1(z)")
       (split -1)
       (("1"
         (skeep -1)
         (inst -5 "c")
         (("1" (assert))
          ("2" (typepred "ab!1") (inst -1 "x!1" "y!1" "c") (assert))))
        ("2" (lemma "cont_intv") (inst -1 "x!1" "y!1" "f!1") (assert))
        ("3" (mult-cases 2)) ("4" (assert))))
      ("2"
       (lemma "interm_value2")
       (inst -1 "x!1" "y!1" "0")
       (assert)
       (inst -1 "LAMBDA (z:closed_interval[real](x!1,y!1)): f!1(z)")
       (split -1)
       (("1"
         (skeep -1)
         (inst -4 "c")
         (("1" (assert))
          ("2" (typepred "ab!1") (inst -1 "x!1" "y!1" "c") (assert))))
        ("2" (lemma "cont_intv") (inst -1 "x!1" "y!1" "f!1") (assert))
        ("3" (assert)) ("4" (mult-cases 3) (inst -3 "x!1") (assert))))))
    ("2"
     (case "x!1 > y!1")
     (("1"
       (case "f!1(y!1) > 0")
       (("1"
         (lemma "interm_value4")
         (inst -1 "y!1" "x!1" "0")
         (assert)
         (inst -1 "LAMBDA (z:closed_interval[real](y!1,x!1)): f!1(z)")
         (split -1)
         (("1"
           (skeep -1)
           (inst -5 "c")
           (("1" (assert))
            ("2" (typepred "ab!1") (inst -1 "y!1" "x!1" "c") (assert))))
          ("2" (lemma "cont_intv") (inst -1 "y!1" "x!1" "f!1") (assert))
          ("3" (mult-cases 3)) ("4" (assert))))
        ("2"
         (lemma "interm_value2")
         (inst -1 "y!1" "x!1" "0")
         (assert)
         (inst -1 "LAMBDA (z:closed_interval[real](y!1,x!1)): f!1(z)")
         (split -1)
         (("1"
           (skeep -1)
           (inst -4 "c")
           (("1" (assert))
            ("2" (typepred "ab!1") (inst -1 "y!1" "x!1" "c") (assert))))
          ("2" (lemma "cont_intv") (inst -1 "y!1" "x!1" "f!1") (assert))
          ("3" (assert))
          ("4" (mult-cases 4) (inst -3 "y!1") (assert))))))
      ("2"
       (case-replace "x!1 = y!1")
       (("1"
         (inst -3 "y!1")
         (rewrite "sq" :dir rl)
         (assert)
         (lemma "sq_gt_0")
         (inst?)
         (assert))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: analysis
theory: restriction_continuous2
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (auto-rewrite "sub_dom")
   (expand "continuous?")
   (skolem!)
   (inst?)
   (expand "continuous?")
   (expand "restrict2")
   (skolem!)
   (inst -1 "epsilon!1")
   (skolem!)
   (inst 1 "delta!1")
   (skosimp)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: restriction_cont_fun
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (auto-rewrite "sub_dom")
   (expand "continuous?")
   (skosimp*)
   (expand "restrict2")
   (inst?)
   (assert)
   (expand "continuous?")
   (skosimp*)
   (inst -1 "epsilon!1")
   (skolem!)
   (inst 1 "delta!1")
   (skosimp)
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: analysis
theory: restriction_continuous
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "continuous?")
   (skosimp*)
   (inst?)
   (expand "continuous?")
   (skosimp*)
   (inst - "epsilon!1")
   (skosimp*)
   (inst + "delta!1")
   (skosimp*)
   (inst - x!1)
   (assert)
   (expand "restrict")
   (propax))


proof_type: j_proof
decl_type: tcc
library: sets_aux
theory: relation_extension
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "rel_extension")
     (prop)
     (("1"
       (typepred "le_T!1")
       (expand "equivalence?")
       (prop)
       (expand "reflexive?")
       (inst?))
      ("2"
       (typepred "le_U!1")
       (expand "equivalence?")
       (prop)
       (expand "reflexive?")
       (inst?))))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (prop)
     (expand "rel_extension")
     (prop)
     (("1"
       (hide -2)
       (typepred "le_T!1")
       (expand "equivalence?")
       (prop)
       (expand "symmetric?")
       (inst -2 "x!1`1" "y!1`1")
       (prop))
      ("2"
       (hide -1)
       (typepred "le_U!1")
       (expand "equivalence?")
       (prop)
       (expand "symmetric?")
       (inst -2 "x!1`2" "y!1`2")
       (prop))))
    ("3"
     (expand "transitive?")
     (skolem!)
     (prop)
     (expand "rel_extension")
     (prop)
     (("1"
       (hide -2 -4)
       (typepred "le_T!1")
       (expand "equivalence?")
       (prop)
       (expand "transitive?")
       (inst -3 "x!1`1" "y!1`1" "z!1`1")
       (prop))
      ("2"
       (hide -1 -3)
       (typepred "le_U!1")
       (expand "equivalence?")
       (prop)
       (expand "transitive?")
       (inst -3 "x!1`2" "y!1`2" "z!1`2")
       (prop))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (flatten)
   (expand "nonempty?")
   (expand "empty?")
   (inst?)
   (expand "member")
   (expand "equivClass")
   (expand "equivalence?")
   (prop)
   (expand "reflexive?")
   (expand "equivClass")
   (expand "image_inverse")
   (inst?))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (expand "nonempty?")
   (expand "empty?")
   (inst?)
   (expand "member")
   (expand "equivClass")
   (expand "equivClass")
   (expand "image_inverse")
   (propax))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (prop)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "image_inverse")
     (expand "reflexive?")
     (skolem!)
     (inst?))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (expand "image_inverse")
     (inst -2 "f!1(x!1)" "f!1(y!1)"))
    ("3"
     (expand "transitive?")
     (skolem!)
     (expand "image_inverse")
     (inst? -3))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (inst 1 "=")
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "image_inverse")
     (propax))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (flatten)
     (expand "image_inverse")
     (replace -1 1 :dir rl)
     (propax))
    ("3"
     (expand "transitive?")
     (skolem!)
     (prop)
     (expand "image_inverse")
     (replace -2 1 rl)
     (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "image_inverse")
     (propax))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (prop)
     (expand "image_inverse")
     (replace -1 1 :dir rl)
     (propax))
    ("3"
     (expand "transitive?")
     (skolem!)
     (prop)
     (expand "image_inverse")
     (replace -2 1 :dir rl)
     (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "EquivalenceKernel")
     (expand "image_inverse")
     (expand "image_inverse")
     (propax))
    ("2"
     (expand "image_inverse")
     (expand "EquivalenceKernel")
     (expand "image_inverse")
     (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (skolem!)
   (flatten)
   (expand "surjective?")
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (inst?)
     (skolem!)
     (inst?)
     (expand "image_inverse")
     (replace -1 1 rl)
     (propax))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (inst-cp -1 "x!1")
     (inst -1 "y!1")
     (skolem!)
     (skolem!)
     (replace -1 1 rl)
     (replace -2 1 rl)
     (inst -4 "x!3" "x!2")
     (expand "image_inverse")
     (propax))
    ("3"
     (expand "transitive?")
     (skolem!)
     (inst-cp -1 "x!1")
     (inst-cp -1 "y!1")
     (inst -1 "z!1")
     (skolem!)
     (skolem!)
     (skolem!)
     (replace -1 1 rl)
     (replace -2 1 rl)
     (replace -3 1 rl)
     (inst -6 "x!4" "x!3" "x!2")
     (expand "image_inverse")
     (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (prop)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "right_inverse?")
     (inst?)
     (expand "image_inverse")
     (replace -1 1 rl)
     (inst?))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (expand "right_inverse?")
     (inst-cp -1 "x!1")
     (inst -1 "y!1")
     (replace -1 1 rl)
     (replace -2 1 rl)
     (expand "image_inverse")
     (expand "inverse")
     (inst -4 "(epsilon! (x: T): f!1(x) = x!1)"
      "(epsilon! (x: T): f!1(x) = y!1)"))
    ("3"
     (expand "transitive?")
     (skolem!)
     (expand "right_inverse?")
     (inst-cp -1 "x!1")
     (inst-cp -1 "y!1")
     (inst -1 "z!1")
     (replace -1 1 rl)
     (replace -2 1 rl)
     (replace -3 1 rl)
     (expand "image_inverse")
     (expand "inverse")
     (inst -6 "(epsilon! (x: T): f!1(x) = x!1)"
      "(epsilon! (x: T): f!1(x) = y!1)"
      "(epsilon! (x: T): f!1(x) = z!1)"))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (iff)
   (split)
   (("1"
     (use "inv_img_surj_impl_codom_eq")
     (prop)
     (expand "image_inverse")
     (expand "image_inverse")
     (propax))
    ("2"
     (use "inverse_image_of_equivalence")
     (prop)
     (expand "image_inverse")
     (expand "image_inverse")
     (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_inverse_image
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (flatten)
   (iff)
   (prop)
   (("1"
     (use " inv_img_surj_impl_codom_eq")
     (("1" (prop))
      ("2"
       (expand "surjective?")
       (expand "right_inverse?")
       (skolem!)
       (inst? -2)
       (inst 1 "inverse(f!1)(y!1)"))))
    ("2"
     (expand "equivalence?")
     (prop)
     (("1"
       (expand "reflexive?")
       (skolem!)
       (expand "image_inverse")
       (inst?))
      ("2"
       (expand "symmetric?")
       (skolem!)
       (expand "image_inverse")
       (inst -2 "f!1(x!1)" "f!1(y!1)"))
      ("3"
       (expand "transitive?")
       (skolem!)
       (expand "image_inverse")
       (inst -3 "f!1(x!1)" "f!1(y!1)" "f!1(z!1)"))))))


proof_type: j_proof
decl_type: tcc
library: sets_aux
theory: relation_inverse_extension
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (expand "l_T")
     (skolem!)
     (expand "image_inverse")
     (inst?))
    ("2"
     (expand "symmetric?")
     (expand "l_T")
     (expand "image_inverse")
     (skolem!)
     (inst -2 "f!1(x!1)" "f!1(y!1)"))
    ("3"
     (expand "transitive?")
     (expand "l_T")
     (expand "image_inverse")
     (skolem!)
     (inst -3 "f!1(x!1)" "f!1(y!1)" "f!1(z!1)"))))


proof_type: j_proof
decl_type: tcc
library: sets_aux
theory: relation_inverse_extension
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (expand "l_U")
     (skolem!)
     (expand "image_inverse")
     (inst?))
    ("2"
     (expand "symmetric?")
     (expand "l_U")
     (expand "image_inverse")
     (skolem!)
     (inst -2 "g!1(x!1)" "g!1(y!1)"))
    ("3"
     (expand "transitive?")
     (expand "l_U")
     (expand "image_inverse")
     (skolem!)
     (inst -3 "g!1(x!1)" "g!1(y!1)" "g!1(z!1)"))))


proof_type: j_proof
decl_type: tcc
library: sets_aux
theory: relation_inverse_extension
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "rel_inv_extension")
     (prop)
     (("1"
       (expand "l_T")
       (expand "image_inverse")
       (typepred "re_U!1")
       (expand "equivalence?")
       (prop)
       (expand "reflexive?")
       (inst?))
      ("2"
       (expand "l_U")
       (expand "image_inverse")
       (typepred "re_T!1")
       (expand "equivalence?")
       (prop)
       (expand "reflexive?")
       (inst?))))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (flatten)
     (expand "rel_inv_extension")
     (prop)
     (("1"
       (expand "l_T")
       (expand "image_inverse")
       (hide -2)
       (typepred "re_U!1")
       (expand "equivalence?")
       (prop)
       (expand "symmetric?")
       (inst -2 "f!1(y!1`1)" "f!1(x!1`1)")
       (prop))
      ("2"
       (expand "l_U")
       (expand "image_inverse")
       (hide -1)
       (typepred "re_T!1")
       (expand "equivalence?")
       (prop)
       (expand "symmetric?")
       (inst -2 "g!1(y!1`2)" "g!1(x!1`2)")
       (prop))))
    ("3"
     (expand "transitive?")
     (skolem!)
     (prop)
     (expand "rel_inv_extension")
     (prop)
     (("1"
       (expand "l_T")
       (expand "image_inverse")
       (hide -4 -2)
       (typepred "re_U!1")
       (expand "equivalence?")
       (prop)
       (hide -1 -2)
       (expand "transitive?")
       (inst -1 "f!1(z!1`1)" "f!1(y!1`1)" "f!1(x!1`1)")
       (prop))
      ("2"
       (expand "l_U")
       (expand "image_inverse")
       (hide -1 -3)
       (typepred "re_T!1")
       (expand "equivalence?")
       (prop)
       (hide -1 -2)
       (expand "transitive?")
       (inst -1 "g!1(z!1`2)" "g!1(y!1`2)" "g!1(x!1`2)")
       (prop))))))


proof_type: j_proof
decl_type: tcc
library: sets_aux
theory: relation_inverse_extension
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (prop)
     (("1"
       (typepred "re_T!1")
       (expand "equivalence?")
       (prop)
       (expand "reflexive?")
       (inst?))
      ("2"
       (typepred "re_U!1")
       (expand "equivalence?")
       (prop)
       (expand "reflexive?")
       (inst?))))
    ("2"
     (expand "symmetric?")
     (skolem!)
     (prop)
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (prop)
     (("1"
       (hide -2)
       (typepred "re_T!1")
       (expand "equivalence?")
       (prop)
       (expand "symmetric?")
       (inst -2 "g!1(y!1`2)" "g!1(x!1`2)")
       (prop))
      ("2"
       (hide -1)
       (typepred "re_U!1")
       (expand "equivalence?")
       (prop)
       (expand "symmetric?")
       (inst -2 "f!1(y!1`1)" "f!1(x!1`1)")
       (prop))))
    ("3"
     (expand "transitive?")
     (skolem!)
     (prop)
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (prop)
     (("1"
       (hide -2 -4)
       (typepred "re_T!1")
       (expand "equivalence?")
       (prop)
       (hide -1 -2)
       (expand "transitive?")
       (inst -1 "g!1(z!1`2)" "g!1(y!1`2)" "g!1(x!1`2)")
       (prop))
      ("2"
       (hide -1 -3)
       (typepred "re_U!1")
       (expand "equivalence?")
       (prop)
       (hide -1 -2)
       (expand "transitive?")
       (inst -1 "f!1(z!1`1)" "f!1(y!1`1)" "f!1(x!1`1)")
       (prop))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: rr_rel
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (prop)
   (expand "RR")
   (prop)
   (expand "rel_extension")
   (prop)
   (("1"
     (typepred "le_T!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("2"
     (typepred "le_T!1")
     (expand "equivalence?")
     (prop)
     (expand "symmetric?")
     (inst?)
     (prop))
    ("3"
     (typepred "le_T!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("4"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: rr_rel
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (prop)
   (expand "RR")
   (expand "rel_extension")
   (prop)
   (("1"
     (typepred "le_T!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("2"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "symmetric?")
     (inst?)
     (prop))
    ("3"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("4"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("5"
     (typepred "le_T!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("6"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "symmetric?")
     (inst?)
     (prop))
    ("7"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?))
    ("8"
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "symmetric?")
     (inst?)
     (prop))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: rr_rel
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (assert)
   (skolem!)
   (prop)
   (("1"
     (expand "RR2")
     (prop)
     (expand "RR")
     (prop)
     (("1"
       (expand "rel_extension")
       (prop)
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop))
      ("2"
       (expand "rel_extension")
       (prop)
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (("1"
         (typepred "le_T!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))
        ("2"
         (typepred "le_T!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))
        ("3"
         (typepred "le_T!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))
        ("4"
         (typepred "le_T!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))))
      ("3"
       (expand "rel_extension")
       (prop)
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (("1"
         (typepred "le_U!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))
        ("2"
         (typepred "le_U!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst -2 "f!1(g!1(n!1`2))" "f!1(n!1`1)")
         (prop))))))
    ("2"
     (expand "RR")
     (expand "RR2")
     (prop)
     (("1" (expand "rel_inv_extension2") (propax))
      ("2"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (("1"
         (typepred "le_U!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst -2 "f!1(n!1`1)" "f!1(g!1(n!1`2))")
         (prop))
        ("2"
         (typepred "le_U!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))
        ("3"
         (typepred "le_U!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))
        ("4"
         (typepred "le_U!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))))
      ("3"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (("1"
         (typepred "le_T!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst -2 "g!1(n!1`2)" "g!1(f!1(n!1`1))")
         (prop))
        ("2"
         (typepred "le_T!1")
         (expand "equivalence?")
         (prop)
         (expand "symmetric?")
         (inst?)
         (prop))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: finite_to_infinite_finite_equival_infinite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref11")
     (expand "RR")
     (expand "rel_extension")
     (prop)
     (("1" (smash) (expand "e11") (expand "equivT") (propax))
      ("2"
       (expand "even?")
       (replace -2 1 lr)
       (expand "g11")
       (expand "equivU")
       (prop)
       (expand "even?")
       (propax))
      ("3"
       (expand "equivT")
       (expand "odd?")
       (expand "e11")
       (smash)
       (expand "even?")
       (propax))
      ("4" (expand "equivU") (propax)) ("5" (expand "equivT") (grind))
      ("6" (grind)) ("7" (expand "equivT") (grind)) ("8" (grind))
      ("9" (grind)) ("10" (grind)) ("11" (grind)) ("12" (grind))
      ("13" (grind)) ("14" (grind)) ("15" (grind)) ("16" (grind))))
    ("2"
     (expand "ref11")
     (expand "RR")
     (expand "rel_extension")
     (expand "equivT")
     (expand "odd?")
     (expand "even?")
     (expand "e11")
     (expand "equivU")
     (expand "odd?")
     (expand "g11")
     (expand "even?")
     (smash)
     (("1" (inst?) (smash) (skolem!) (smash))
      ("2" (inst 1 "0") (assert) (inst 2 "0") (assert))
      ("3"
       (inst 2 "0")
       (assert)
       (inst 1 "0")
       (smash)
       (inst 1 "0")
       (assert))
      ("4" (inst 1 "0") (smash))
      ("5" (inst 1 "0") (smash) (inst 2 "0") (smash))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: finite_to_infinite_finite_equival_infinite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "RR2")
     (prop)
     (expand "ref11")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "equivU")
     (expand "e11")
     (expand "g11")
     (expand "even?")
     (smash)
     (("1" (expand "odd?") (propax)) ("2" (expand "odd?") (propax))
      ("3" (expand "odd?") (propax)) ("4" (expand "odd?") (grind))
      ("5" (expand "odd?") (propax)) ("6" (expand "odd?") (propax))))
    ("2"
     (expand "ref11")
     (expand "RR2")
     (prop)
     (("1"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (expand "equivT")
       (expand "equivU")
       (expand "g11")
       (expand "e11")
       (expand "even?")
       (smash))
      ("2"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (expand "equivU")
       (expand "equivT")
       (expand "g11")
       (expand "e11")
       (expand "even?")
       (smash)
       (("1" (expand "odd?") (propax)) ("2" (expand "odd?") (grind))))
      ("3"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (expand "equivT")
       (expand "equivU")
       (expand "e11")
       (expand "g11")
       (expand "even?")
       (smash))
      ("4" (grind))
      ("5"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (expand "equivT")
       (expand "equivU")
       (expand "e11")
       (expand "g11")
       (expand "even?")
       (smash))
      ("6"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (expand "equivU")
       (expand "equivT")
       (expand "e11")
       (expand "g11")
       (expand "even?")
       (smash)
       (("1" (expand "odd?") (propax)) ("2" (expand "odd?") (grind))
        ("3" (grind))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_infinite_infinite_equival_finite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "RR")
     (expand "rel_extension")
     (prop)
     (("1" (expand "ref10") (expand "e10") (expand "equivT") (propax))
      ("2"
       (expand "ref10")
       (replace -1 1 lr)
       (expand "g10")
       (expand "equivU")
       (assert))
      ("3" (expand "equivT") (propax)) ("4" (expand "equivU") (propax))
      ("5" (expand "equivT") (propax)) ("6" (expand "ref10") (grind))
      ("7" (expand "equivU") (propax)) ("8" (expand "equivU") (propax))))
    ("2"
     (expand "ref10")
     (expand "RR")
     (expand "rel_extension")
     (expand "equivU")
     (expand "g10")
     (expand "equivT")
     (expand "e10")
     (assert))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_infinite_infinite_equival_finite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1" (grind))
    ("2"
     (expand "RR2")
     (prop)
     (("1"
       (expand "ref10")
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (expand "equivT")
       (prop)
       (expand "equivU")
       (expand "g10")
       (expand "e10")
       (replace -1 1 lr)
       (replace -2 1 rl)
       (replace -1 1 lr)
       (assert))
      ("2"
       (expand "rel_inv_extension2")
       (expand "ref10")
       (expand "rel_extension")
       (prop)
       (expand "equivU")
       (expand "equivT")
       (expand "e10")
       (expand "g10")
       (assert))
      ("3"
       (expand "ref10")
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (prop)
       (expand "equivT")
       (expand "g10")
       (expand "e10")
       (expand "equivU")
       (replace -1 1 lr)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_infinite_infinite_equival_infinite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref9")
     (expand "RR")
     (expand "rel_extension")
     (expand "e9")
     (expand "equivT")
     (expand "equivU")
     (expand "g9")
     (replace -1 1 rl)
     (propax))
    ("2"
     (expand "ref9")
     (expand "RR")
     (expand "rel_extension")
     (expand "e9")
     (expand "equivT")
     (expand "equivU")
     (expand "g9")
     (prop)
     (replace -1 1 rl)
     (assert))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_finite_infinite_equival_finite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "RR")
     (expand "ref8")
     (prop)
     (("1"
       (expand "rel_extension")
       (prop)
       (("1" (expand "equivT") (propax))
        ("2"
         (expand "e8")
         (expand "equivU")
         (expand "g8")
         (expand "equivT")
         (expand "odd?")
         (expand "even?")
         (smash)
         (replace -3 1 lr)
         (inst 1 "0")
         (assert))
        ("3" (expand "equivT") (propax))
        ("4"
         (expand "equivU")
         (expand "equivT")
         (replace -2 3 lr)
         (expand "e8")
         (replace -2 1 lr)
         (expand "even?")
         (expand "odd?")
         (propax))
        ("5" (expand "equivT") (propax))
        ("6"
         (replace -2 1 lr)
         (hide 3)
         (expand "equivU")
         (expand "e8")
         (replace -2 2 lr)
         (expand "even?")
         (expand "equivT")
         (expand "g8")
         (expand "odd?")
         (expand "even?")
         (smash)
         (inst 3 "0")
         (assert))
        ("7" (expand "equivT") (propax))
        ("8"
         (expand "equivU")
         (replace -2 1 lr)
         (replace -2 3 lr)
         (expand "even?")
         (expand "g8")
         (expand "odd?")
         (propax))))
      ("2"
       (expand "rel_extension")
       (prop)
       (("1" (expand "equivT") (propax))
        ("2" (replace -1 1 lr) (replace -1 3 lr) (grind))
        ("3" (expand "equivT") (propax))
        ("4"
         (expand "equivU")
         (replace -1 1 lr)
         (replace -1 3 lr)
         (expand "equivT")
         (expand "odd?")
         (expand "g8")
         (expand "even?")
         (smash)
         (expand "e8")
         (expand "even?")
         (propax))
        ("5" (expand "equivT") (propax))
        ("6" (replace -1 1 lr) (hide 3) (grind)) ("7" (grind))
        ("8" (grind))))))
    ("2"
     (expand "ref8")
     (expand "RR")
     (expand "rel_extension")
     (prop)
     (("1"
       (expand "g8")
       (expand "equivT")
       (expand "odd?")
       (expand "equivU")
       (expand "odd?")
       (grind))
      ("2"
       (expand "equivT")
       (expand "equivU")
       (expand "odd?")
       (expand "e8")
       (grind))
      ("3" (grind)) ("4" (grind))
      ("5"
       (expand "equivT")
       (expand "even?")
       (skolem!)
       (replace -1 -2 lr)
       (expand "g8")
       (expand "equivU")
       (expand "even?")
       (skolem!)
       (case "j!2=0")
       (("1" (replace -1 -3 lr) (assert)) ("2" (grind))))
      ("6"
       (expand "equivT")
       (expand "equivU")
       (expand "even?")
       (expand "g8")
       (expand "odd?")
       (grind))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_finite_infinite_equival_finite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "RR2")
     (prop)
     (expand "ref8")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "equivU")
     (expand "odd?")
     (expand "even?")
     (expand "e8")
     (expand "g8")
     (smash)
     (("1" (inst 1 "0") (inst 2 "0") (expand "even?") (smash))
      ("2" (grind)) ("3" (grind)) ("4" (grind))))
    ("2"
     (expand "RR2")
     (prop)
     (("1"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (expand "ref8")
       (expand "equivT")
       (expand "equivU")
       (expand "e8")
       (expand "g8")
       (expand "even?")
       (expand "odd?")
       (smash)
       (("1"
         (inst 1 "0")
         (lift-if)
         (split)
         (("1" (flatten) (inst?) (assert))
          ("2" (prop) (inst?) (inst?) (assert))))
        ("2" (inst 1 "0") (smash) (inst 1 "0") (inst 3 "0") (assert))))
      ("2"
       (expand "ref8")
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (expand "equivT")
       (expand "equivU")
       (expand "e8")
       (expand "g8")
       (expand "odd?")
       (expand "even?")
       (smash)
       (("1" (grind))
        ("2"
         (inst 1 "0")
         (inst 2 "0")
         (lift-if)
         (split)
         (("1" (prop) (assert)) ("2" (prop))))
        ("3" (inst 1 "0") (inst 2 "0") (inst 3 "0") (smash))))
      ("3"
       (expand "rel_inv_extension2")
       (expand "ref8")
       (expand "rel_extension")
       (expand "equivT")
       (expand "e8")
       (expand "equivU")
       (expand "g8")
       (expand "odd?")
       (expand "even?")
       (prop)
       (("1" (grind)) ("2" (grind)) ("3" (grind)) ("4" (grind))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_finite_finite_equival_finite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (grind)
   (expand "ref7")
   (expand "RR")
   (grind)
   (apply-extensionality :hide? t)
   (lift-if)
   (smash)
   (inst 1 "0")
   (assert)
   (inst 2 "0")
   (assert))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_finite_finite_equival_finite_equival_classes
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "g7")
     (expand "equivU")
     (expand "e7")
     (expand "even?")
     (smash)
     (("1"
       (inst 1 "0")
       (assert)
       (expand "ref7")
       (expand "even?")
       (smash))
      ("2"
       (expand "ref7")
       (expand "even?")
       (smash)
       (inst 1 "0")
       (assert))
      ("3" (expand "ref7") (expand "even?") (smash))
      ("4" (expand "ref7") (expand "even?") (smash))))
    ("2"
     (expand "ref7")
     (expand "even?")
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "equivU")
     (expand "e7")
     (expand "g7")
     (expand "even?")
     (grind))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: finite_to_infinite
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "RR")
     (expand "rel_extension")
     (expand "ref6")
     (prop)
     (("1" (expand "equivT") (propax))
      ("2"
       (expand "equivU")
       (expand "g6")
       (smash)
       (expand "even?")
       (propax))
      ("3" (expand "equivT") (propax)) ("4" (expand "equivU") (propax))
      ("5" (expand "equivT") (propax))
      ("6"
       (expand "g6")
       (expand "e6")
       (replace -1 2 rl)
       (expand "equivT")
       (propax))
      ("7" (expand "equivT") (propax)) ("8" (expand "equivU") (propax))))
    ("2"
     (expand "ref6")
     (expand "RR")
     (expand "rel_extension")
     (prop)
     (("1"
       (expand "g6")
       (expand "equivU")
       (expand "equivT")
       (expand "e6")
       (propax))
      ("2"
       (expand "equivU")
       (expand "e6")
       (expand "equivT")
       (replace -1 1 lr)
       (propax))
      ("3"
       (expand "equivT")
       (expand "equivU")
       (replace -1 1 rl)
       (expand "g6")
       (smash)
       (expand "even?")
       (propax))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: finite_to_infinite
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref6")
     (replace -1 1 lr)
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "equivU")
     (expand "e6")
     (propax))
    ("2"
     (expand "RR2")
     (prop)
     (("1"
       (expand "rel_inv_extension2")
       (expand "ref6")
       (expand "rel_extension")
       (expand "equivT")
       (expand "e6")
       (expand "equivU")
       (prop)
       (replace -1 1 lr)
       (assert)
       (expand "g6")
       (smash)
       (expand "even?")
       (propax))
      ("2"
       (expand "rel_inv_extension2")
       (expand "ref6")
       (expand "rel_extension")
       (expand "equivT")
       (expand "e6")
       (expand "equivU")
       (expand "g6")
       (expand "even?")
       (assert)
       (smash)
       (("1" (inst 1 "0") (assert)) ("2" (inst 2 "0") (assert))))
      ("3"
       (expand "rel_inv_extension2")
       (expand "rel_extension")
       (expand "ref6")
       (expand "equivT")
       (expand "equivU")
       (expand "e6")
       (expand "g6")
       (expand "even?")
       (replace -1 1 lr)
       (smash)
       (inst 2 "0")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_infinite_trivial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref4")
     (expand "RR")
     (expand "rel_extension")
     (prop)
     (("1" (expand "equivT") (propax))
      ("2" (replace -1 1 rl) (expand "equivU") (expand "g4") (propax))
      ("3" (expand "e4") (expand "equivT") (propax))
      ("4" (expand "equivU") (propax)) ("5" (expand "equivT") (propax))
      ("6" (expand "equivU") (expand "g4") (propax))
      ("7" (expand "equivT") (propax)) ("8" (expand "equivU") (propax))))
    ("2"
     (expand "ref4")
     (expand "RR")
     (expand "rel_extension")
     (expand "equivT")
     (expand "e4")
     (expand "equivU")
     (expand "g4")
     (prop)
     (lemma "div_multiple")
     (inst -1 "10" "x!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: infinite_to_infinite_trivial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref4")
     (replace -1 1 rl)
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "equivU")
     (expand "g4")
     (propax))
    ("2"
     (expand "ref4")
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "equivT")
     (expand "equivU")
     (expand "e4")
     (expand "g4")
     (prop)
     (("1" (replace -2 1 rl) (assert)) ("2" (replace -1 1 lr) (assert))
      ("3" (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: finite_nats_trivial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref1")
     (expand "RR")
     (expand "rel_extension")
     (expand "e1")
     (expand "==")
     (prop)
     (("1" (expand "g1") (replace -1 1 lr) (assert))
      ("2" (replace -1 1 rl) (assert)) ("3" (expand "g1") (assert))))
    ("2"
     (expand "ref1")
     (expand "RR")
     (expand "rel_extension")
     (expand "e1")
     (expand "g1")
     (expand "==")
     (prop)
     (("1" (replace -1 1 rl) (assert)) ("2" (replace -1 1 rl) (propax))
      ("3" (replace -1 1 rl) (assert))
      ("4" (replace -1 1 rl) (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: finite_nats_trivial
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (apply-extensionality :hide? t)
   (iff)
   (prop)
   (("1"
     (expand "ref1")
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "e1")
     (prop)
     (("1" (expand "g1") (expand "==") (assert))
      ("2" (expand "g1") (expand "==") (assert))
      ("3" (expand "g1") (expand "==") (assert))))
    ("2"
     (expand "ref1")
     (expand "RR2")
     (expand "rel_inv_extension2")
     (expand "rel_extension")
     (expand "e1")
     (expand "g1")
     (prop)
     (("1"
       (assert)
       (replace -1 1 rl)
       (replace -1 3 rl)
       (expand "==")
       (propax))
      ("2" (expand "==") (propax))
      ("3" (expand "==") (replace -1 1 rl) (propax))
      ("4" (replace -1 1 rl) (expand "==") (propax))
      ("5" (expand "==") (propax)) ("6" (expand "==") (propax))
      ("7" (expand "==") (replace -1 1 rl) (propax))
      ("8" (replace -1 1 rl) (expand "==") (propax))
      ("9" (expand "==") (propax)) ("10" (expand "==") (propax))
      ("11" (expand "==") (replace -1 1 rl) (assert))
      ("12" (expand "==") (propax)) ("13" (expand "==") (propax))
      ("14" (expand "==") (propax))
      ("15" (expand "==") (replace -1 1 rl) (assert))
      ("16" (replace -1 1 rl) (expand "==") (propax))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_extension_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (expand "nonempty?")
   (expand "empty?")
   (expand "member")
   (expand "extended_equiv_class")
   (expand "rel_extension")
   (inst -3 "m!1")
   (prop)
   (("1" (expand "equivalence?") (prop) (expand "reflexive?") (inst?))
    ("2"
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst? -4))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_extension_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (expand "nonempty?")
   (expand "empty?")
   (expand "member")
   (expand "EquivClass")
   (expand "extended_equiv_class")
   (expand "rel_extension")
   (prop)
   (("1"
     (typepred "le_T!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst -1 "m!1`1")
     (typepred "le_U!1")
     (expand "equivalence?")
     (prop)
     (expand "reflexive?")
     (inst?)
     (inst?)
     (skolem!)
     (prop))
    ("2" (skolem!) (prop) (inst?))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_extension_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "proj_tuple_1")
   (replace -1 1 rl)
   (expand "repEC")
   (typepred "choose(EquivClass(le_T!1)(m!1`1))")
   (expand "EquivClass")
   (propax))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_extension_props
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (prop)
   (expand "proj_tuple_2")
   (replace -1 1 rl)
   (expand "repEC")
   (typepred "choose(EquivClass(le_U!1)(m!1`2))")
   (expand "EquivClass")
   (propax))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_implication
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (flatten)
   (expand "|=")
   (prop)
   (expand "|-")
   (skolem!)
   (inst?)
   (inst?)
   (prop))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_implication
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "partial_order?")
   (prop)
   (("1"
     (expand "preorder?")
     (prop)
     (("1"
       (expand "reflexive?")
       (skolem-typepred)
       (expand "|-")
       (skolem!)
       (flatten))
      ("2"
       (expand "transitive?")
       (skolem!)
       (flatten)
       (expand "|-")
       (skolem!)
       (inst?)
       (inst?)
       (prop))))
    ("2"
     (expand "antisymmetric?")
     (skolem!)
     (flatten)
     (expand "|-")
     (apply-extensionality :hide? t)
     (inst?)
     (inst?)
     (iff)
     (prop))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relation_implication
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "equivalence?")
   (prop)
   (("1"
     (expand "reflexive?")
     (skolem!)
     (expand "|=")
     (prop)
     (("1" (expand "|-") (skolem!) (prop))
      ("2" (expand "|-") (skolem!) (prop))))
    ("2" (expand "symmetric?") (skolem!) (prop) (expand "|=") (prop))
    ("3"
     (expand "transitive?")
     (skolem!)
     (flatten)
     (expand "|=")
     (expand "|-")
     (prop)
     (("1" (skolem!) (inst?) (inst?) (inst?) (inst?) (prop))
      ("2" (skolem!) (inst?) (inst?) (inst?) (inst?) (prop))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (expand "fun_choice")
   (expand "rel_unique_choice")
   (skolem! 1)
   (inst -1 "R!1")
   (flatten)
   (prop)
   (skolem-typepred)
   (inst 1 "LAMBDA(t:T,u:U):u=f!1(t)")
   (skolem-typepred)
   (inst 1 "f!1(t!1)")
   (split)
   (("1" (inst -1 "t!1"))
    ("2" (inst?) (skolem! 1) (prop) (replace -1 1 rl) (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (auto-rewrite-defs :always? t)
   (assert :let-reduce? t :cases-rewrite? nil :ignore-typepreds? nil)
   (skolem-typepred)
   (flatten)
   (assert :let-reduce? t :quant-simp? nil :implicit-typepreds? nil
           :ignore-typepreds? nil :cases-rewrite? nil)
   (inst? :if-match t :polarity? nil)
   (replace*)
   (assert :let-reduce? t :quant-simp? nil :implicit-typepreds? nil
           :ignore-typepreds? nil :cases-rewrite? nil)
   (inst? :if-match t :polarity? nil)
   (skolem-typepred)
   (replace*)
   (assert :let-reduce? t :quant-simp? nil :implicit-typepreds? nil
           :ignore-typepreds? nil :cases-rewrite? nil)
   (skolem-typepred)
   (flatten))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (expand "parametric_definite_description")
   (expand "rel_choice")
   (expand "fun_choice")
   (skosimp*)
   (grind))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (prop)
   (("1" (rewrite "fun_choice_impl_rel_choice"))
    ("2" (rewrite "fun_choice_impl_description"))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (prop)
   (("1" (rewrite "fun_choice_impl_rel_unique_choice"))
    ("2" (rewrite "fun_choice_impl_description"))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (prop)
   (expand "fun_choice")
   (skosimp*)
   (expand "rel_unique_choice")
   (inst -2 "R!1")
   (prop)
   (skolem!)
   (expand "parametric_definite_description")
   (inst -2 "R1!1")
   (prop)
   (("1"
     (skolem! -1)
     (inst 1 "f!1")
     (skolem! 1)
     (inst -1 "t!1")
     (inst -2 "t!1")
     (skolem!)
     (prop)
     (inst -4 "f!1(t!1)")
     (prop)
     (replace -1 1 rl)
     (propax))
    ("2" (skosimp*) (inst?) (skolem!) (prop) (inst 1 "u!1") (prop))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (expand "conditional_relational_choice")
   (expand "proof_irrelevance")
   (expand "rel_unique_choice")
   (skolem!)
   (skolem!)
   (prop)
   (inst -1 "R!1")
   (prop)
   (("1" (skolem!) (inst 1 "R1!1") (skolem!) (inst?) (flatten))
    ("2"
     (inst 2 "R!1")
     (skolem!)
     (skolem!)
     (bddsimp)
     (assert)
     (inst?)
     (replace 1 -1 rl)
     (assert)
     (inst -1 "P!1(t!2)"))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (flatten)
   (expand "conditional_relational_choice")
   (skolem! 1)
   (skolem! 1)
   (prop)
   (expand "rel_unique_choice")
   (inst -1 "LAMBDA(t:T,u:U):P!1(t) IMPLIES R!1(t,u)")
   (prop)
   (("1"
     (skolem!)
     (inst 1 "R1!1")
     (skolem! 1)
     (prop)
     (inst?)
     (skolem!)
     (prop)
     (inst 1 "u!1")
     (prop))
    ("2"
     (expand "independence_of_premises")
     (inst -1 "P!1")
     (skolem! 1)
     (inst -1 "P!1(t!1)")
     (prop)
     (("1"
       (assert)
       (inst?)
       (prop)
       (("1" (inst 2 "R!1") (skolem!) (skolem!) (inst?) (prop))
        ("2"
         (inst 3 "R!1")
         (skolem! 3)
         (flatten)
         (skolem!)
         (prop)
         (("1" (assert)) ("2" (assert))))))
      ("2" (inst 1 "t!1"))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: relational_choice_properties
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (prop)
   (("1" (rewrite "fun_choice_impl_rel_unique_choice"))
    ("2" (rewrite "fun_choice_impl_description"))
    ("3" (rewrite "description_rel_unique_choice_imp_funct_choice"))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "i")
   (("1" (skeep) (inst - "f" "g" "aa") (assert))
    ("2" (skeep) (expand "Afun") (propax))
    ("3"
     (skeep)
     (skeep)
     (inst - "f" "g" "aa")
     (expand "Afun" +)
     (propax))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "i")
   (("1" (skeep) (assert) (expand "Afun" + 2) (propax))
    ("2"
     (skolem 1 "ii")
     (flatten)
     (induct "j")
     (("1"
       (skeep)
       (expand "Afun" + 1)
       (assert)
       (lemma "Afundef")
       (inst - "f" "g" "ii+1" "a")
       (assert))
      ("2"
       (skolem 1 "jj")
       (flatten)
       (skeep)
       (assert)
       (expand "Afun" + 1)
       (inst - "f" "g" "a")
       (assert)
       (replace -1)
       (expand "Afun" + 3)
       (propax))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (induct "k")
   (("1"
     (assert)
     (ground)
     (("1"
       (lemma "Afundef")
       (inst-cp - "f" "g" "i" "a1")
       (inst - "f" "g" "j" "a2")
       (assert)
       (decompose-equality +))
      ("2"
       (lemma "Afundef")
       (inst-cp - "f" "g" "i" "a1")
       (inst - "f" "g" "j" "a2")
       (assert)
       (replace -1 :dir rl)
       (replace -2 :dir rl)
       (expand "injective?")
       (inst?)
       (assert)
       (decompose-equality +))))
    ("2"
     (skolem 1 "k")
     (flatten)
     (assert)
     (case "Afun(f, g)(a1)(-1 - k + i)`2 = Afun(f, g)(a2)(-1 - k + j)`2")
     (("1"
       (hide -7)
       (lemma "Afundef")
       (inst - "f" "g" "-1-k+i" "a1")
       (lemma "Afundef")
       (inst - "f" "g" "-1-k+j" "a2")
       (assert)
       (replace -1 :dir rl)
       (replace -2 :dir rl)
       (expand "injective?")
       (inst?)
       (assert)
       (decompose-equality +))
      ("2"
       (hide 2)
       (hide -6)
       (lemma "Afundef2")
       (inst-cp - "f" "g" "-1-k+i" "a1")
       (inst - "f" "g" "-1-k+j" "a2")
       (assert)
       (expand "injective?" -7)
       (inst?)
       (assert))))
    ("3" (skosimp*) (assert)) ("4" (skosimp*) (assert))
    ("5" (skosimp*) (assert)) ("6" (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "NOT Bfun(f, g)(b)(i) = Bfun(f, g)(b)(j)")
   (("1"
     (split -)
     (("1"
       (decompose-equality +)
       (lemma "Bfundef2")
       (inst-cp - "f" "g" "b" "i")
       (("1"
         (inst - "f" "g" "b" "j")
         (("1" (assert)) ("2" (skosimp*) (assert))))
        ("2" (skosimp*) (assert))))
      ("2"
       (lemma "Bfundef2")
       (decompose-equality +)
       (inst-cp - "f" "g" "b" "i")
       (("1"
         (inst - "f" "g" "b" "j")
         (("1" (expand "injective?") (inst?) (assert))
          ("2" (skosimp*) (assert))))
        ("2" (skosimp*) (assert))))))
    ("2"
     (hide -4)
     (induct "k")
     (("1" (assert))
      ("2"
       (skolem 1 "k")
       (flatten)
       (assert)
       (case "Bfun(f, g)(b)(-1 - k + i)`2 = Bfun(f, g)(b)(-1 - k + j)`2")
       (("1"
         (lemma "Bfundef2")
         (inst - "f" "g" "b" "-1-k+i")
         (lemma "Bfundef2")
         (inst - "f" "g" "b" "-1-k+j")
         (assert)
         (replace -1 :dir rl)
         (replace -2 :dir rl)
         (expand "injective?")
         (inst?)
         (assert)
         (decompose-equality +))
        ("2"
         (assert)
         (lemma "Bfundef")
         (inst-cp - "f" "g" "b" "-1-k+i")
         (inst - "f" "g" "b" "-1-k+j")
         (assert)
         (expand "injective?" -8)
         (inst?)
         (assert))))
      ("3" (skosimp*) (assert)) ("4" (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (f: [A -> B], g: [B -> A], a: A, i: nat):
                        Afun(f, g)(a)(i+1) = Bfun(f, g)(f(a))(i+1)")
   (("1" (skeep) (inst - "f" "g" "a" "i-1") (assert))
    ("2"
     (hide 2)
     (induct "i")
     (("1"
       (assert)
       (skeep)
       (expand "Afun")
       (expand "Bfun")
       (expand "Afun")
       (expand "Bfun")
       (ground))
      ("2"
       (skeep)
       (assert)
       (skeep)
       (expand "Afun" +)
       (expand "Bfun" +)
       (inst - "f" "g" "a")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "i")
   (("1"
     (skeep)
     (assert)
     (expand "Bfun")
     (expand "Afun")
     (expand "Bfun")
     (ground))
    ("2"
     (skeep)
     (skeep)
     (assert)
     (inst - "f" "g" "b")
     (expand "Bfun" +)
     (expand "Afun" +)
     (assert))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "NOT Bfun(f, g)(b)(i) = Afun(f, g)(a)(j)")
   (("1"
     (split -)
     (("1"
       (decompose-equality +)
       (lemma "Bfundef2")
       (inst - "f" "g" "b" "i")
       (("1"
         (lemma "Afundef")
         (assert)
         (inst - "f" "g" "j" "a")
         (assert))
        ("2" (skosimp*) (assert))))
      ("2"
       (decompose-equality +)
       (lemma "Bfundef2")
       (inst - "f" "g" "b" "i")
       (("1"
         (lemma "Afundef")
         (inst - "f" "g" "j" "a")
         (assert)
         (expand "injective?")
         (inst?)
         (assert))
        ("2" (skosimp*) (assert))))))
    ("2"
     (hide -4)
     (induct "k")
     (("1" (assert))
      ("2"
       (skolem 1 "k")
       (flatten)
       (assert)
       (case "Bfun(f, g)(b)(-1 - k + i)`2 = Afun(f, g)(a)(-1 - k + j)`2")
       (("1"
         (lemma "Bfundef2")
         (inst - "f" "g" "b" "-1-k+i")
         (lemma "Afundef")
         (inst - "f" "g" "-1-k+j" "a")
         (assert)
         (replace -1 :dir rl)
         (replace -2 :dir rl)
         (expand "injective?")
         (inst?)
         (assert)
         (decompose-equality +))
        ("2"
         (assert)
         (lemma "Bfundef")
         (inst - "f" "g" "b" "-1-k+i")
         (lemma "Afundef2")
         (inst - "f" "g" "-1-k+j" "a")
         (assert)
         (expand "injective?" -8)
         (inst?)
         (assert))))
      ("3" (skosimp*) (assert)) ("4" (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "ABrel")
   (flatten)
   (expand "Arel")
   (split -1)
   (("1"
     (hide -2)
     (skeep -1)
     (lemma "Afundef")
     (inst - "f" "g" "i" "a")
     (assert)
     (expand "preim_B?")
     (inst? 1)
     (assert))
    ("2"
     (skolem -1 "ia")
     (case "ia = 0")
     (("1"
       (replace -1)
       (expand "Bfun" -2)
       (expand "preim_B?")
       (replace 1)
       (split -)
       (("1"
         (skolem -1 "iaa")
         (replace -3 -1)
         (case "iaa = 0")
         (("1"
           (replace -1)
           (expand "Afun" -2)
           (inst 3 "0")
           (expand "Bfun" 3)
           (replace 1)
           (assert))
          ("2"
           (lemma "Afundef2")
           (inst - "f" "g" "iaa-1" "aa")
           (("1"
             (replace -2 -1 :dir rl)
             (expand "injective?" -6)
             (inst? -6)
             (("1"
               (assert)
               (lemma "Afundef")
               (inst - "f" "g" "iaa-1" "aa")
               (assert)
               (replace -7)
               (replace -1 2 :dir rl)
               (inst? 2))
              ("2" (assert))))
            ("2" (assert))))))
        ("2"
         (skolem -1 "ii")
         (replace -3 -1)
         (rewrite "BAfun" -1 :dir rl)
         (replace -1 3)
         (inst? 3))))
      ("2"
       (split -)
       (("1"
         (skolem -1 "iaa")
         (lemma "ABfuneq")
         (inst - "f" "g" "ia" "iaa" "b" "aa")
         (assert)
         (case "ia > iaa")
         (("1"
           (inst - "iaa")
           (assert)
           (case "NOT Bfun(f, g)(b)(ia - iaa)`1 = Afun(f, g)(aa)(0)`1")
           (("1" (assert))
            ("2" (expand "Afun" -1) (replace -1 4 :dir rl) (inst? 4))))
          ("2"
           (inst - "ia-1")
           (assert)
           (expand "Bfun" -1)
           (decompose-equality -1)
           (lemma "Afundef2")
           (inst - "f" "g" "-ia+iaa" "aa")
           (assert)
           (replace -1 :dir rl)
           (hide -1)
           (expand "injective?" -6)
           (inst - "Bfun(f, g)(b)(0)`2" "Afun(f, g)(aa)(-ia + iaa)`2")
           (assert)
           (expand "Bfun" -6)
           (expand "preim_B?")
           (replace 3)
           (lemma "Afundef")
           (inst - "f" "g" "-ia+iaa" "aa")
           (assert)
           (replace -1 :dir rl)
           (replace -7 3)
           (inst? 3))))
        ("2"
         (skolem -1 "iaa")
         (lemma "BAfun")
         (inst - "f" "g" "b" "ia-1")
         (("1"
           (assert)
           (replace -1 -3)
           (hide -1)
           (replace -2 -1)
           (rewrite "Afuncomp")
           (rewrite "BAfun" -1 :dir rl)
           (replace -1 4)
           (inst? 4))
          ("2" (assert))))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "BArel")
   (expand "Brel")
   (expand "ABrel")
   (flatten)
   (ground)
   (("1"
     (skolem -1 "ibb")
     (case "NOT ibb = 0")
     (("1"
       (lemma "Bfundef2")
       (inst - "f" "g" "bb" "ibb")
       (("1"
         (expand "preim_B?")
         (replace -2 :dir rl)
         (replace -1 + :dir rl)
         (inst? 2))
        ("2" (assert))))
      ("2"
       (replace -1)
       (expand "preim_B?")
       (expand "Bfun" -2)
       (case "NOT b = bb")
       (("1" (assert)) ("2" (hide -3) (assert))))))
    ("2"
     (skolem -1 "ibb")
     (skolem - "ia")
     (case "ibb = 0")
     (("1"
       (replace -1)
       (expand "Bfun" -2)
       (case "NOT bb = b")
       (("1" (assert))
        ("2" (hide -3) (replace -1) (replace -3 +) (inst? 2))))
      ("2"
       (lemma "BAfun")
       (inst - "f" "g" "b" "ibb-1")
       (("1"
         (assert)
         (replace -1)
         (hide -1)
         (replace -2 -1)
         (case "ia = 0")
         (("1"
           (replace -1)
           (expand "Afun" -3)
           (expand "preim_B?")
           (inst + "a")
           (assert))
          ("2"
           (rewrite "Afundef2")
           (rewrite "Afuncomp")
           (replace -1 +)
           (inst? 4))))
        ("2" (assert))))))
    ("3"
     (skolem -1 "ibb")
     (skolem - "ib")
     (case "ibb = 0")
     (("1"
       (replace -1)
       (expand "Bfun" -2)
       (case "NOT b = bb")
       (("1" (assert))
        ("2" (hide -3) (replace -1 :dir rl) (replace -3 +) (inst? 3))))
      ("2"
       (case "ib = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -3)
         (expand "preim_B?")
         (replace 2)
         (lemma "Bfundef")
         (inst - "f" "g" "bb" "ibb")
         (replace -3 :dir rl)
         (replace -1)
         (replace -4 4)
         (inst? 4))
        ("2"
         (lemma "BAfun")
         (inst - "f" "g" "bb" "ibb-1")
         (("1"
           (assert)
           (replace -1 -2)
           (hide -1)
           (lemma "Afundef")
           (inst - "f" "g" "ibb-1" "g(bb)")
           (assert)
           (replace -2 :dir rl)
           (replace -1 3 :dir rl)
           (expand "preim_B?")
           (inst? 3))
          ("2" (assert))))))))
    ("4"
     (skolem -1 "ibb")
     (skolem -2 "ia")
     (case "ibb = 0")
     (("1"
       (replace -1)
       (expand "Bfun" -2)
       (case "NOT bb = b")
       (("1" (assert))
        ("2" (hide -3) (replace -1) (replace -3) (inst? 3))))
      ("2"
       (case "ia = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -3)
         (expand "preim_B?")
         (replace 2)
         (lemma "BAfun")
         (inst - "f" "g" "b" "ibb-1")
         (("1"
           (assert)
           (replace -1)
           (replace -4 :dir rl)
           (replace -3)
           (inst? 3))
          ("2" (assert))))
        ("2"
         (case "ibb >= ia")
         (("1"
           (lemma "BAfun")
           (inst - "f" "g" "b" "ibb-1")
           (("1"
             (assert)
             (replaces -1)
             (lemma "BAfun")
             (inst - "f" "g" "b" "ia-1")
             (assert)
             (replaces -1)
             (lemma "Afuncomp")
             (inst - "f" "g" "ia-1" "ibb-ia" "g(b)")
             (assert)
             (replace -1 :dir rl)
             (replace -4 :dir rl)
             (replace -3)
             (inst? 4))
            ("2" (assert))))
          ("2"
           (lemma "BAfun")
           (inst - "f" "g" "b" "ibb-1")
           (("1"
             (assert)
             (replace -1)
             (hide -1)
             (lemma "Afundef")
             (inst - "f" "g" "ibb-1" "g(b)")
             (assert)
             (replace -2 :dir rl)
             (lemma "BAfun")
             (inst - "f" "g" "b" "ia-1")
             (assert)
             (replace -1)
             (hide -1)
             (lemma "Afuncomp")
             (inst - "f" "g" "ibb-1" "ia-ibb" "g(b)")
             (assert)
             (lemma "ABfun")
             (inst - "f" "g" "Afun(f, g)(g(b))(ibb - 1)`1" "ia-ibb")
             (replace -1)
             (hide -1)
             (replace -2)
             (decompose-equality -1)
             (replace -5 :dir rl)
             (replace -1 :dir rl)
             (inst? 6))
            ("2" (assert))))))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "Arel")
   (expand "Brel")
   (split)
   (("1"
     (flatten)
     (hide -2)
     (split)
     (("1"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -2)
         (case "b = bb")
         (("1"
           (hide -3)
           (replace -1 :dir rl)
           (inst + "0")
           (expand "Afun" 1)
           (propax))
          ("2" (assert))))
        ("2"
         (lemma "BAfun")
         (inst - "f" "g" "bb" "i!1-1")
         (("1"
           (assert)
           (replace -1)
           (inst + "i!1")
           (expand "Afun" 2)
           (assert))
          ("2" (assert))))))
      ("2"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -2)
         (case "bb = b")
         (("1" (replace -1) (inst 2 "0") (expand "Afun" 2) (propax))
          ("2" (assert))))
        ("2"
         (lemma "BAfun")
         (inst - "f" "g" "b" "i!1-1")
         (("1"
           (assert)
           (replace -1)
           (inst 3 "i!1")
           (expand "Afun" 3)
           (assert))
          ("2" (assert))))))))
    ("2"
     (flatten)
     (split)
     (("1"
       (skosimp*)
       (rewrite "BAfun" :dir rl)
       (lemma "Bfundef")
       (inst - "f" "g" "bb" "i!1")
       (replace -2 :dir rl)
       (expand "injective?")
       (inst? -3)
       (assert)
       (replace -3 1 :dir rl)
       (inst? 1))
      ("2"
       (skosimp*)
       (rewrite "BAfun" :dir rl)
       (lemma "Bfundef")
       (inst - "f" "g" "b" "i!1")
       (replace -2 :dir rl)
       (expand "injective?")
       (inst? -3)
       (assert)
       (replace -3 + :dir rl)
       (inst? 2))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (iff)
   (expand "Arel")
   (expand "Brel")
   (split)
   (("1"
     (flatten)
     (split)
     (("1"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Afun" -2)
         (replace -2 :dir rl)
         (inst + "0")
         (expand "Bfun" 1)
         (lift-if)
         (propax))
        ("2"
         (rewrite "ABfun" -1)
         (lemma "Bfundef2")
         (inst - "f" "g" "f(aa)" "i!1")
         (("1" (replace -2 :dir rl) (inst + "i!1")) ("2" (assert))))))
      ("2"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Afun" -2)
         (replace -2)
         (inst 2 "0")
         (expand "Bfun" 2)
         (assert))
        ("2"
         (rewrite "ABfun" -1)
         (lemma "Bfundef2")
         (inst - "f" "g" "f(a)" "i!1")
         (("1" (replace -2 :dir rl) (inst 3 "i!1")) ("2" (assert))))))))
    ("2"
     (flatten)
     (split)
     (("1"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -2)
         (assert)
         (expand "injective?")
         (inst - "a" "aa")
         (assert)
         (inst + "0")
         (expand "Afun" 1)
         (propax))
        ("2"
         (rewrite "ABfun" :dir rl)
         (lemma "Afundef")
         (inst - "f" "g" "i!1" "aa")
         (assert)
         (replace -2 :dir rl)
         (expand "injective?")
         (inst - "Afun(f,g)(aa)(i!1)`1" "a")
         (assert)
         (inst + "i!1")
         (assert))))
      ("2"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -2)
         (assert)
         (expand "injective?")
         (inst - "aa" "a")
         (assert)
         (inst + "0")
         (expand "Afun" 1)
         (assert))
        ("2"
         (rewrite "ABfun" :dir rl)
         (lemma "Afundef")
         (inst - "f" "g" "i!1" "a")
         (assert)
         (replace -2 :dir rl)
         (expand "injective?")
         (inst - "Afun(f,g)(a)(i!1)`1" "aa")
         (assert)
         (inst 3 "i!1")
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "ABrel")
   (expand "Brel")
   (split)
   (("1"
     (flatten)
     (split)
     (("1"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Afun" -2)
         (inst 2 "0")
         (expand "Bfun" 2)
         (assert))
        ("2" (rewrite "ABfun") (replace -1 +) (inst? 3))))
      ("2"
       (skosimp*)
       (case "a = g(b)")
       (("1" (inst + "1") (expand "Bfun" 1) (expand "Bfun" 1) (assert))
        ("2"
         (case "f(a) = b")
         (("1" (inst + "0") (expand "Bfun" 2) (assert))
          ("2"
           (case "i!1 = 0")
           (("1" (replace -1) (expand "Bfun" -2) (lift-if) (ground))
            ("2"
             (inst + "i!1")
             (lemma "Bfundef")
             (inst - "f" "g" "b" "i!1-1")
             (("1"
               (assert)
               (replace -2 :dir rl)
               (expand "Bfun" 4)
               (assert))
              ("2" (assert))))))))))))
    ("2"
     (flatten)
     (split -)
     (("1"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -2)
         (assert)
         (inst + "0")
         (expand "Afun" 1)
         (assert))
        ("2"
         (inst 3 "i!1")
         (expand "injective?" -2)
         (inst - "a" "Bfun(f,g)(b)(i!1)`1")
         (assert)
         (lemma "Bfundef2")
         (inst - "f" "g" "b" "i!1")
         (assert))))
      ("2"
       (skosimp*)
       (case "i!1 = 0")
       (("1"
         (replace -1)
         (expand "Bfun" -2)
         (assert)
         (inst + "0")
         (expand "Afun" 1)
         (propax))
        ("2" (rewrite "ABfun" :dir rl) (inst + "i!1"))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (f: [A -> B], g: [B -> A], a1, a2: A, i, j: nat):
                               injective?(f) AND
                         injective?(g) AND Afun(f, g)(a1)(i) = Afun(f, g)(a2)(j+i) IMPLIES Arel(f, g)(a1)(a2)")
   (("1"
     (skeep)
     (case "i >=j")
     (("1"
       (inst - "f" "g" "a2" "a1" "j" "i-j")
       (("1" (assert) (expand "Arel") (ground)) ("2" (assert))))
      ("2"
       (inst - "f" "g" "a1" "a2" "i" "j-i")
       (("1" (assert)) ("2" (assert))))))
    ("2"
     (hide 2)
     (induct "j")
     (("1"
       (assert)
       (case "FORALL (f: [A -> B], g: [B -> A], a1, a2: A, i: nat):
                                           injective?(f) AND
                                 injective?(g) AND Afun(f, g)(a1)(i) = Afun(f, g)(a2)(i) IMPLIES a1=a2")
       (("1"
         (skeep)
         (inst - "f" "g" "a1" "a2" "i")
         (assert)
         (replace -1 :dir rl)
         (expand "Arel")
         (flatten)
         (inst + "0")
         (expand "Afun")
         (propax))
        ("2"
         (hide 2)
         (induct "i")
         (("1" (skeep) (expand "Afun") (assert))
          ("2"
           (skeep)
           (skeep)
           (expand "Afun" -4)
           (flatten)
           (inst - "f" "g" "a1" "a2")
           (assert)
           (expand "injective?" -2)
           (inst - "Afun(f, g)(a1)(j)`2" "Afun(f, g)(a2)(j)`2")
           (assert)
           (decompose-equality +)
           (lemma "Afundef")
           (inst-cp - "f" "g" "j" "a1")
           (inst - "f" "g" "j" "a2")
           (assert)
           (expand "injective?")
           (inst - "Afun(f, g)(a1)(j)`1" "Afun(f, g)(a2)(j)`1")
           (assert))))))
      ("2"
       (assert)
       (skolem 1 "ii")
       (flatten)
       (induct "i")
       (("1"
         (assert)
         (skeep)
         (expand "Afun" -3 1)
         (expand "Arel" 1)
         (flatten)
         (inst + "1+ii")
         (assert))
        ("2"
         (assert)
         (skolem 1 "jj")
         (flatten)
         (assert)
         (skeep)
         (expand "Afun" -4)
         (flatten)
         (case "Afun(f, g)(a1)(jj) = Afun(f, g)(a2)(1 + ii + jj)")
         (("1" (inst - "f" "g" "a1" "a2") (assert))
          ("2"
           (case "Afun(f, g)(a1)(jj)`2 = Afun(f, g)(a2)(1 + ii + jj)`2")
           (("1"
             (lemma "Afundef")
             (inst - "f" "g" "jj" "a1")
             (lemma "Afundef")
             (inst - "f" "g" "1+ii+jj" "a2")
             (assert)
             (copy -5)
             (expand "injective?" -1)
             (replace -4 :dir rl)
             (replace -3 :dir rl)
             (inst?)
             (assert)
             (decompose-equality +))
            ("2"
             (copy -3)
             (expand "injective?" -1)
             (inst?)
             (assert))))))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "bijective?")
   (case "injective?(ag_fun(f, g)(a)) AND injective?(af_fun(f, g)(a))")
   (("1"
     (flatten)
     (assert)
     (expand "surjective?")
     (skolem 1 "aa")
     (skolem 2 "bb")
     (typepred "aa")
     (typepred "bb")
     (case "EXISTS (az:A): f(az) = bb")
     (("1"
       (expand "ABrel")
       (expand "Arel")
       (skeep -1)
       (ground)
       (("1"
         (expand "ag_fun" +)
         (expand "af_fun" +)
         (inst 2 "az")
         (lemma "Afununique")
         (skosimp*)
         (inst - "f" "g" "az" "a" "0" "i!2")
         (assert)
         (split -)
         (("1" (expand "Arel" (-1 1)) (ground))
          ("2"
           (expand "Afun" + 1)
           (copy -7)
           (expand "injective?" -1)
           (inst - "az" "Afun(f,g)(a)(i!2)`1")
           (assert)
           (split -)
           (("1" (decompose-equality +))
            ("2" (lemma "Afundef") (inst?) (assert))))))
        ("2"
         (skosimp*)
         (expand "ag_fun" +)
         (expand "af_fun" +)
         (lemma "Afundef")
         (inst - "f" "g" "i!2" "a")
         (assert)
         (replace -3 :dir rl)
         (inst 2 "Afun(f,g)(a)(i!2)`1")
         (assert)
         (expand "Arel" +)
         (flatten)
         (inst 2 "i!2"))
        ("3"
         (skosimp*)
         (lemma "ABfun")
         (inst - "f" "g" "az" "i!2")
         (("1"
           (replace -4 -3 :dir rl)
           (replace -1 :dir rl)
           (inst 2 "az")
           (("1" (expand "af_fun" +) (propax))
            ("2" (expand "Arel" +) (flatten) (inst? 1))))
          ("2"
           (case "i!2 = 0")
           (("1"
             (replace -1)
             (assert)
             (expand "Bfun" -3)
             (lift-if)
             (ground)
             (("1"
               (inst 3 "a")
               (("1" (expand "af_fun" +) (assert))
                ("2"
                 (expand "Arel" +)
                 (flatten)
                 (inst + "0")
                 (expand "Afun" 1)
                 (propax))))
              ("2" (inst + "az"))))
            ("2" (assert))))))
        ("4"
         (skosimp*)
         (replace -3 -2 :dir rl)
         (case "i!2 = 0")
         (("1"
           (replace -1)
           (expand "Bfun" -3)
           (lift-if)
           (ground)
           (("1"
             (inst 2 "a")
             (("1" (expand "af_fun" +) (assert))
              ("2"
               (expand "Arel" 1)
               (flatten)
               (inst + "0")
               (hide-all-but 1)
               (expand "Afun")
               (propax))))
            ("2" (inst + "az"))))
          ("2"
           (rewrite "ABfun" -2 :dir rl)
           (inst 3 "az")
           (("1" (expand "af_fun" 3) (propax))
            ("2" (expand "Arel" +) (flatten) (inst 1 "i!2"))))))))
      ("2"
       (hide 3)
       (lemma "ABrel_Arel_equiv")
       (inst - "f" "g" "bb" "a" "aa")
       (assert)
       (split -)
       (("1"
         (expand "ABrel" -1)
         (case "NOT EXISTS (i: nat): aa = Bfun(f, g)(bb)(i)`1")
         (("1"
           (assert)
           (replace 1)
           (skeep -1)
           (expand "ag_fun" +)
           (lemma "Afundef")
           (inst - "f" "g" "i" "aa")
           (assert)
           (inst 2 "Afun(f,g)(aa)(i)`1")
           (assert))
          ("2"
           (assert)
           (replace -1)
           (skeep -1)
           (case "i = 0")
           (("1"
             (replace -1)
             (expand "Bfun" -2)
             (assert)
             (replace 1)
             (inst 2 "bb")
             (expand "ag_fun" +)
             (assert))
            ("2"
             (lemma "Bfundef")
             (inst - "f" "g" "bb" "i-1")
             (("1"
               (assert)
               (replace -2 :dir rl)
               (replace -1 3 :dir rl)
               (expand "ag_fun" +)
               (inst? 3)
               (lemma "ABrel_Brel_equiv")
               (inst - "f" "g" "bb" "Bfun(f, g)(bb)(i - 1)`2" "a")
               (assert)
               (split -)
               (("1" (expand "BArel") (propax))
                ("2" (expand "preim_B?") (propax))
                ("3" (expand "Brel" 1) (flatten) (inst? 2))))
              ("2" (assert))))))))
        ("2" (expand "preim_B?") (propax))))))
    ("2"
     (hide (2 3))
     (expand "injective?")
     (ground)
     (("1" (skosimp*) (inst - "x1!1" "x2!1") (expand "ag_fun") (assert))
      ("2"
       (skosimp*)
       (hide -2)
       (inst - "x1!1" "x2!1")
       (expand "af_fun")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (inst + "a")
   (expand "Arel")
   (flatten)
   (inst + "0")
   (expand "Afun" 1)
   (propax))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (f: [A -> B], g: [B -> A], a1, a2, a, aa: A):
                                             Arel(f, g)(a1)(a) AND Arel(f, g)(a2)(a) AND Arel(f,g)(a1)(aa) AND injective?(g) AND injective?(f) IMPLIES
                                              Arel(f, g)(a2)(aa)")
   (("1"
     (skeep)
     (decompose-equality +)
     (inst-cp - "f" "g" "a1" "a2" "a" "x!1")
     (inst - "f" "g" "a2" "a1" "a" "x!1")
     (ground))
    ("2"
     (hide 2)
     (skeep)
     (expand "Arel")
     (flatten)
     (ground)
     (("1"
       (skosimp*)
       (case "i!3 >= i!2")
       (("1"
         (lemma "Afuncomp")
         (inst - "f" "g" "i!2" "i!3-i!2" "a")
         (("1"
           (replace -4 :dir rl)
           (assert)
           (replace -1 :dir rl)
           (lemma "Afuneq")
           (inst - "f" "g" "i!1" "i!3-i!2" "aa" "a2")
           (assert)
           (case "i!3-i!2 >= i!1")
           (("1"
             (inst - "i!1")
             (assert)
             (expand "Afun" -2 1)
             (decompose-equality -2)
             (replace -1 +)
             (inst? 2))
            ("2"
             (inst - "i!3-i!2")
             (assert)
             (expand "Afun" - 2)
             (decompose-equality -1)
             (replace -1 + :dir rl)
             (inst? 2))))
          ("2" (assert))))
        ("2"
         (lemma "Afuncomp")
         (inst - "f" "g" "i!3" "i!2-i!3" "a")
         (("1"
           (replace -4 :dir rl)
           (assert)
           (replace -1 :dir rl)
           (replace -2 -3)
           (rewrite "Afuncomp")
           (replace -3 +)
           (inst 2 "i!1+i!2-i!3")
           (assert))
          ("2" (assert))))))
      ("2"
       (skosimp*)
       (case "i!2>=i!3")
       (("1"
         (lemma "Afuncomp")
         (inst - "f" "g" "i!3" "i!2-i!3" "a")
         (("1"
           (assert)
           (replace -1 :dir rl)
           (replace -5 :dir rl)
           (case "i!2-i!3 >= i!1")
           (("1"
             (lemma "Afuncomp")
             (inst - "f" "g" "i!1" "i!2-i!3-i!1" "a1")
             (("1"
               (assert)
               (replace -5 :dir rl)
               (replace -1 :dir rl)
               (replace -6 +)
               (inst? 1))
              ("2" (assert))))
            ("2"
             (lemma "Afuncomp")
             (inst - "f" "g" "i!2-i!3" "i!1-i!2+i!3" "a1")
             (("1"
               (assert)
               (replace -5 :dir rl)
               (replace -1 :dir rl)
               (replace -4 +)
               (inst? 3))
              ("2" (assert))))))
          ("2" (assert))))
        ("2"
         (lemma "Afuncomp")
         (inst - "f" "g" "i!2" "i!3-i!2" "a")
         (("1"
           (assert)
           (replace -3 :dir rl)
           (replace -1 :dir rl)
           (replace -4 -2)
           (rewrite "Afuncomp")
           (replace -2 +)
           (hide-all-but (1 3))
           (inst?))
          ("2" (assert))))))
      ("3"
       (skosimp*)
       (replace -2 -3)
       (rewrite "Afuncomp")
       (replace -3 -1)
       (lemma "Afununique")
       (inst - "f" "g" "a2" "aa" "i!2+i!3" "i!1")
       (assert)
       (split -)
       (("1" (expand "Arel") (ground))
        ("2"
         (decompose-equality +)
         (lemma "Afundef")
         (inst - "f" "g" "i!2+i!3" "a2")
         (lemma "Afundef")
         (inst - "f" "g" "i!1" "aa")
         (assert))))
      ("4"
       (skosimp*)
       (replace -3 -1)
       (rewrite "Afuncomp")
       (replace -2 -1)
       (rewrite "Afuncomp")
       (replace -1 +)
       (inst? 2))
      ("5"
       (skosimp*)
       (replace -1 -3)
       (rewrite "Afuncomp")
       (replace -3 -2)
       (rewrite "Afuncomp")
       (replace -2 +)
       (hide-all-but 1)
       (inst?))
      ("6"
       (skosimp*)
       (replace -3 -2)
       (rewrite "Afuncomp")
       (case "i!1 >= i!2 + i!3")
       (("1"
         (lemma "Afuncomp")
         (inst - "f" "g" "i!2+i!3" "i!1-i!2-i!3" "a1")
         (("1"
           (assert)
           (replace -4 :dir rl)
           (replace -1 :dir rl)
           (replace -3 +)
           (inst? 2))
          ("2" (assert))))
        ("2"
         (lemma "Afuncomp")
         (inst - "f" "g" "i!1" "i!2+i!3-i!1" "a1")
         (("1"
           (assert)
           (replace -2 :dir rl)
           (replace -1 :dir rl)
           (replace -3 +)
           (inst? 2))
          ("2" (assert))))))
      ("7"
       (skosimp*)
       (replace -1 -3)
       (rewrite "Afuncomp")
       (replace -3 -2)
       (lemma "Afununique")
       (inst - "f" "g" "aa" "a2" "i!1+i!3" "i!2")
       (assert)
       (split -)
       (("1" (expand "Arel") (ground))
        ("2"
         (decompose-equality +)
         (lemma "Afundef")
         (inst-cp - "f" "g" "i!1+i!3" "aa")
         (inst - "f" "g" "i!2" "a2")
         (assert))))
      ("8"
       (skosimp*)
       (replace -3 -2)
       (lemma "Afununique")
       (inst - "f" "g" "a1" "a2" "i!3" "i!2")
       (assert)
       (split -)
       (("1"
         (expand "Arel")
         (split -)
         (("1"
           (skosimp*)
           (replace -1 -2)
           (rewrite "Afuncomp")
           (replace -2 +)
           (hide-all-but 2)
           (inst?))
          ("2"
           (skosimp*)
           (case "i!1 >= i!4")
           (("1"
             (lemma "Afuncomp")
             (inst - "f" "g" "i!4" "i!1-i!4" "a1")
             (("1"
               (assert)
               (replace -3 :dir rl)
               (replace -1 :dir rl)
               (replace -4 +)
               (inst? 2))
              ("2" (assert))))
            ("2"
             (lemma "Afuncomp")
             (inst - "f" "g" "i!1" "i!4-i!1" "a1")
             (("1"
               (assert)
               (replace -3 :dir rl)
               (replace -1 :dir rl)
               (replace -2 +)
               (inst? 2))
              ("2" (assert))))))))
        ("2"
         (lemma "Afundef")
         (inst-cp - "f" "g" "i!3" "a1")
         (inst - "f" "g" "i!2" "a2")
         (assert)
         (decompose-equality +))))))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (rewrite "Brel_Arel")
   (rewrite "Brel_Arel")
   (decompose-equality)
   (rewrite "Brel_Arel")
   (rewrite "Brel_Arel")
   (lemma "Arel_disjoint")
   (inst - "f" "g" "g(b1)" "g(b2)" "g(b)")
   (assert))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (inst + "g(b)")
   (expand "ABrel")
   (flatten)
   (inst 2 "1")
   (expand "Bfun" 2)
   (expand "Bfun" 2)
   (assert))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (f: [A -> B], g: [B -> A], a1, a2: A, b,bb: B):
                 ABrel(f, g)(a1)(b) AND
                  ABrel(f, g)(a2)(b) AND ABrel(f, g)(a1)(bb) AND injective?(g) AND injective?(f)
                  IMPLIES ABrel(f, g)(a2)(bb)")
   (("1"
     (skeep)
     (decompose-equality +)
     (inst-cp - "f" "g" "a1" "a2" "b" "x!1")
     (inst - "f" "g" "a2" "a1" "b" "x!1")
     (assert)
     (ground))
    ("2"
     (hide 2)
     (skeep)
     (lemma "ABrel_Brel")
     (assert)
     (inst - "f" "g" _ _)
     (inst-cp - "b" "a1")
     (inst-cp - "b" "a2")
     (inst-cp - "bb" "a1")
     (inst - "bb" "a2")
     (assert)
     (hide (-4 -5 -6 2))
     (rewrite "Brel_Arel")
     (rewrite "Brel_Arel")
     (rewrite "Brel_Arel")
     (rewrite "Brel_Arel")
     (lemma "Arel_disjoint")
     (inst - "f" "g" "g(f(a1))" "g(f(a2))" "g(b)")
     (assert))))


proof_type: f_proof
decl_type: formula
library: sets_aux
theory: cantor_bernstein_schroeder
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "EXISTS (SS:set[A], FF:[(SS)->[set[A],set[B]]]): (FORALL (a:A): EXISTS (ss:(SS)): FF(ss)`1(a)) AND (FORALL (b:B): EXISTS (ss:(SS)): FF(ss)`2(b)) AND (FORALL (ss1,ss2:(SS)): ss1/=ss2 IMPLIES disjoint?(FF(ss1)`1,FF(ss2)`1) AND disjoint?(FF(ss1)`2,FF(ss2)`2)) AND (FORALL (ss:(SS)): (EXISTS (hab:[(FF(ss)`1)->(FF(ss)`2)]): bijective?(hab)) OR (EXISTS (hab:[(FF(ss)`2)->(FF(ss)`1)]): bijective?(hab))) AND (FORALL (ss:(SS)): nonempty?(FF(ss)`1) AND nonempty?(FF(ss)`2))")
   (("1"
     (skeep -1)
     (case "FORALL (ss: (SS)):
                                                                (EXISTS (hab: [(FF(ss)`1) -> (FF(ss)`2)]): bijective?(hab))")
     (("1"
       (hide (-5 -6))
       (name "afun" "LAMBDA (a:A): choose({ss:(SS) | FF(ss)`1(a)})")
       (("1"
         (case "FORALL (a:A): FF(afun(a))`1(a)")
         (("1"
           (hide -2)
           (name "habfun"
                 "LAMBDA (ss:(SS)): choose({hab:[(FF(ss)`1)->(FF(ss)`2)]|bijective?(hab)})")
           (("1"
             (inst + "LAMBDA (a:A): habfun(afun(a))(a)")
             (expand "bijective?")
             (split +)
             (("1"
               (expand "injective?" +)
               (skeep)
               (case "afun(x1) = afun(x2)")
               (("1"
                 (replace -1 :dir rl)
                 (hide -1)
                 (typepred "habfun(afun(x1))")
                 (expand "bijective?" -1)
                 (flatten)
                 (expand "injective?" -1)
                 (inst - "x1" "x2")
                 (assert))
                ("2"
                 (inst - "afun(x1)" "afun(x2)")
                 (assert)
                 (flatten)
                 (copy -8)
                 (expand "disjoint?" -1)
                 (expand "empty?" -1)
                 (expand "intersection" -1)
                 (expand "member" -1)
                 (inst - "habfun(afun(x1))(x1)")
                 (assert))))
              ("2"
               (expand "surjective?" +)
               (skolem 1 "b")
               (case "EXISTS (aa:A): FF(afun(aa))`2(b)")
               (("1"
                 (skeep -1)
                 (typepred "habfun(afun(aa))")
                 (expand "bijective?" -1)
                 (flatten)
                 (hide -1)
                 (expand "surjective?" -1)
                 (inst - "b")
                 (skeep -1)
                 (case "afun(aa) = afun(x)")
                 (("1" (inst + "x") (assert))
                  ("2"
                   (hide 2)
                   (inst - "afun(aa)" "afun(x)")
                   (assert)
                   (flatten)
                   (copy -9)
                   (expand "disjoint?" -1)
                   (expand "empty?" -1)
                   (expand "member" -1)
                   (expand "intersection" -1)
                   (expand "member" -1)
                   (inst - "b")
                   (assert)
                   (typepred "x")
                   (inst - "x")
                   (copy -9)
                   (expand "disjoint?" -1)
                   (expand "empty?" -1)
                   (expand "intersection" -1)
                   (inst - "x")
                   (expand "member")
                   (propax))))
                ("2"
                 (hide 2)
                 (inst -5 "b")
                 (skosimp*)
                 (inst -3 "ss!1")
                 (skosimp*)
                 (expand "surjective?")
                 (inst -4 "b")
                 (skosimp*)
                 (inst + "x!1")
                 (case "FF(afun(x!1))`2 = FF(ss!1)`2")
                 (("1" (assert))
                  ("2"
                   (hide 2)
                   (inst - "ss!1" "afun(x!1)")
                   (assert)
                   (flatten)
                   (typepred "x!1")
                   (inst - "x!1")
                   (copy -8)
                   (expand "disjoint?" -1)
                   (expand "intersection" -1)
                   (expand "empty?" -1)
                   (expand "member")
                   (inst - "x!1")
                   (ground))))))))
            ("2"
             (skosimp*)
             (expand "nonempty?")
             (expand "empty?")
             (expand "member")
             (inst -3 "ss!1")
             (skosimp*)
             (inst - "hab!1"))))
          ("2" (skeep) (assert))))
        ("2"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (skosimp*)
         (inst -3 "a!1")
         (skosimp*)
         (inst - "ss!1"))))
      ("2"
       (hide 2)
       (skeep)
       (inst -4 "ss")
       (ground)
       (skeep -1)
       (inst + "inverse(hab)")
       (("1"
         (lemma "bij_inv_is_bij[(FF(ss)`2),(FF(ss)`1)]")
         (("1" (inst - "hab") (assert))
          ("2"
           (inst -5 "ss")
           (flatten)
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (skosimp*)
           (inst + "x!2"))))
        ("2"
         (inst -5 "ss")
         (flatten)
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (skosimp*)
         (inst + "x!2"))))))
    ("2"
     (hide 2)
     (case "EXISTS (SS: set[A],
                                                    FF: [(SS) -> [set[A], set[B]]]):
                                                   (FORALL (a: A): EXISTS (ss: (SS)): FF(ss)`1(a))
                                               AND (FORALL (b: B): EXISTS (ss: (SS)): FF(ss)`2(b))
                                               AND (FORALL (ss1, ss2: (SS)):
                                                      ss1 /= ss2 AND
                                                       ((NOT disjoint?(FF(ss1)`1, FF(ss2)`1)) OR
                                                        (NOT disjoint?(FF(ss1)`2, FF(ss2)`2))) IMPLIES FF(ss1) = FF(ss2))
                                               AND (FORALL (ss: (SS)):
                                                      (EXISTS (hab: [(FF(ss)`1) -> (FF(ss)`2)]): bijective?(hab))
                                                       OR
                                                       (EXISTS (hab: [(FF(ss)`2) -> (FF(ss)`1)]):
                                                          bijective?(hab)))
                                               AND (FORALL (ss: (SS)):
                                                      nonempty?(FF(ss)`1) AND nonempty?(FF(ss)`2))")
     (("1"
       (skeep -1)
       (name "ffim"
             "{abset:[set[A],set[B]]|EXISTS (ss:(SS)): FF(ss) = abset}")
       (case "FORALL (abset:(ffim)): EXISTS (ss:(SS)): FF(ss) = abset")
       (("1"
         (name "ssch"
               "LAMBDA (abset:(ffim)): choose({ss:(SS)|FF(ss) = abset})")
         (("1"
           (case "FORALL (abset:(ffim)): FF(ssch(abset)) = abset")
           (("1"
             (name "SSset"
                   "LAMBDA (fs:A): SS(fs) AND EXISTS (abset:(ffim)): fs = ssch(abset)")
             (name "FFex" "LAMBDA (ssn:(SSset)): FF(ssn)")
             (("1"
               (inst + "SSset" "FFex")
               (assert)
               (split +)
               (("1"
                 (skosimp*)
                 (inst -7 "a!1")
                 (skosimp*)
                 (inst -3 "FF(ss!1)")
                 (("1"
                   (inst + "ssch(FF(ss!1))")
                   (("1" (expand "FFex" +) (assert))
                    ("2" (expand "SSset" +) (inst + "FF(ss!1)"))))
                  ("2" (hide 2) (expand "ffim" +) (inst?))))
                ("2"
                 (skosimp*)
                 (inst -8 "b!1")
                 (skosimp*)
                 (inst -3 "FF(ss!1)")
                 (("1"
                   (inst + "ssch(FF(ss!1))")
                   (("1" (expand "FFex" +) (assert))
                    ("2" (expand "SSset" +) (inst + "FF(ss!1)"))))
                  ("2" (hide 2) (expand "ffim" +) (inst?))))
                ("3"
                 (skeep)
                 (expand "disjoint?" +)
                 (expand "FFex" +)
                 (typepred "ss1")
                 (typepred "ss2")
                 (expand "SSset" (-1 -2))
                 (flatten)
                 (inst -13 "ss1" "ss2")
                 (assert)
                 (expand "disjoint?")
                 (case "NOT (((NOT empty?(intersection(FF(ss1)`1, FF(ss2)`1))) OR
                                                                         (NOT empty?(intersection(FF(ss1)`2, FF(ss2)`2)))))")
                 (("1" (hide -) (ground))
                  ("2"
                   (replace -1)
                   (skolem -3 "abset2")
                   (skolem -5 "abset1")
                   (hide -1)
                   (copy -7)
                   (inst-cp - "abset1")
                   (inst - "abset2")
                   (replace -4 :dir rl)
                   (replace -6 :dir rl)
                   (assert)
                   (replace -15 :dir rl)
                   (replace -2 -1)
                   (replace -1 :dir rl)
                   (replace -6 :dir rl)
                   (assert))))
                ("4"
                 (hide-all-but (-10 1))
                 (skeep)
                 (typepred "ss")
                 (expand "SSset")
                 (flatten)
                 (hide -2)
                 (inst - "ss")
                 (split -)
                 (("1"
                   (skosimp*)
                   (inst + "hab!1")
                   (("1"
                     (assert)
                     (expand "bijective?")
                     (hide 2)
                     (expand "injective?")
                     (expand "surjective?")
                     (skosimp*)
                     (split)
                     (("1" (skosimp*) (inst - "x1!1" "x2!1") (assert))
                      ("2"
                       (skosimp*)
                       (hide -1)
                       (inst - "y!1")
                       (("1"
                         (skosimp*)
                         (inst + "x!1")
                         (expand "FFex")
                         (propax))
                        ("2"
                         (hide 2)
                         (typepred "y!1")
                         (expand "FFex")
                         (propax))))))
                    ("2" (hide 2) (expand "FFex") (propax))))
                  ("2"
                   (skosimp*)
                   (hide 1)
                   (inst + "hab!1")
                   (("1"
                     (expand "bijective?")
                     (expand "injective?")
                     (expand "surjective?")
                     (flatten)
                     (split +)
                     (("1"
                       (hide -2)
                       (skosimp*)
                       (inst - "x1!1" "x2!1")
                       (assert))
                      ("2"
                       (hide -1)
                       (skosimp*)
                       (inst - "y!1")
                       (("1"
                         (skosimp*)
                         (inst + "x!1")
                         (expand "FFex")
                         (propax))
                        ("2"
                         (hide 2)
                         (typepred "y!1")
                         (expand "FFex")
                         (propax))))))
                    ("2" (expand "FFex") (propax))))))
                ("5"
                 (hide-all-but (-11 1))
                 (skosimp*)
                 (typepred "ss!1")
                 (expand "SSset")
                 (flatten)
                 (hide -2)
                 (inst - "ss!1")
                 (expand "FFex")
                 (propax))))
              ("2"
               (hide-all-but 1)
               (skeep)
               (typepred "ssn")
               (expand "SSset")
               (assert))))
            ("2" (hide 2) (skeep) (assert))))
          ("2"
           (hide 2)
           (skeep)
           (expand "nonempty?" +)
           (expand "empty?")
           (expand "member")
           (inst -2 "abset")
           (skosimp*)
           (inst - "ss!1"))))
        ("2"
         (hide 2)
         (skosimp*)
         (assert)
         (typepred "abset!1")
         (expand "ffim" -1)
         (propax))))
      ("2"
       (hide 2)
       (inst + "fullset[A]"
        "LAMBDA (a:(fullset[A])): (Arel(f,g)(a),ABrel(f,g)(a))")
       (assert)
       (ground)
       (("1"
         (skosimp*)
         (lemma "Arel_union")
         (inst - "f" "g" "a!1")
         (skosimp*)
         (inst + "aa!1")
         (expand "fullset")
         (propax))
        ("2"
         (skosimp*)
         (lemma "ABrel_union")
         (inst - "f" "g" "b!1")
         (skosimp*)
         (inst + "a!1")
         (expand "fullset")
         (propax))
        ("3"
         (skolem 1 ("a1" "a2"))
         (flatten)
         (split -)
         (("1"
           (expand "disjoint?")
           (expand "empty?")
           (expand "intersection")
           (expand "member")
           (skolem 1 "aa")
           (flatten)
           (lemma "Arel_disjoint")
           (inst - "f" "g" "a1" "a2" "aa")
           (assert)
           (decompose-equality 2)
           (name "bb" "x!1")
           (replace -1)
           (hide -1)
           (rewrite "ABrel_Brel")
           (rewrite "ABrel_Brel")
           (rewrite "Arel_Brel" -)
           (rewrite "Arel_Brel" -)
           (lemma "Brel_disjoint")
           (inst - "f" "g" "f(a1)" "f(a2)" "f(aa)")
           (assert))
          ("2"
           (expand "disjoint?")
           (expand "intersection")
           (expand "empty?")
           (expand "member")
           (skolem 1 "b")
           (flatten)
           (lemma "ABrel_disjoint")
           (inst - "f" "g" "a1" "a2" "b")
           (assert)
           (rewrite "ABrel_Brel")
           (rewrite "ABrel_Brel")
           (decompose-equality 2)
           (rewrite "Arel_Brel")
           (rewrite "Arel_Brel")
           (lemma "Brel_disjoint")
           (inst - "f" "g" "f(a1)" "f(a2)" "b")
           (assert))))
        ("4"
         (skeep)
         (lemma "aginj")
         (inst - "f" "g" "ss")
         (assert)
         (inst + "af_fun(f,g)(ss)")
         (inst + "ag_fun(f,g)(ss)")
         (ground))
        ("5"
         (skeep)
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (split)
         (("1"
           (inst - "ss")
           (expand "Arel")
           (flatten)
           (inst + "0")
           (expand "Afun" 1)
           (propax))
          ("2"
           (inst - "f(ss)")
           (expand "ABrel")
           (flatten)
           (inst + "0")
           (expand "Afun" 1)
           (propax))))))))))


