# Proofs

proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "z <= FtoR(f)")
   (("1"
     (expand "abs" -4)
     (grind-reals)
     (expand "MinOrMax?")
     (skosimp*)
     (hide 1)
     (expand "isMax?")
     (skosimp*)
     (lemma "FsuccFpred" :subst ("f" "f" "b" "b"))
     (split)
     (("1"
       (replace -1 1 :dir rl)
       (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
       (("1"
         (rewrite "FsuccProp")
         (("1"
           (trans-ineq 1 "z" :strict 1)
           (trans-ineq 1 " FtoR[radix](f)-Fulp(b)(Fpred(b)(f))" :strict
            2)
           (("1" (rewrite "FpredDiff" :dir rl) (assert)) ("2" (assert))))
          ("2" (rewrite "FpredCanonic"))))
        ("2" (assert))))
      ("2" (propax))))
    ("2"
     (flip-ineq 1)
     (expand "abs" -4)
     (grind-reals)
     (expand "MinOrMax?")
     (skosimp*)
     (hide 2)
     (expand "isMin?")
     (skosimp*)
     (lemma "FpredFsucc" :subst ("f" "f" "b" "b"))
     (split)
     (("1"
       (replace -1 1 :dir rl)
       (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
       (("1"
         (rewrite "FpredProp")
         (("1"
           (trans-ineq 1 "z" :strict 2)
           (trans-ineq 1 "FtoR(f)+Fulp(b)(Fpred(b)(f))" :strict 1)
           (("1" (assert))
            ("2"
             (trans-ineq 1 "FtoR(f)+Fulp(b)(f)")
             (("1" (assert) (rewrite "FulpFpred1"))
              ("2" (rewrite "FsuccDiff" :dir rl) (assert))
              ("3" (skosimp*) (rewrite "FcanonicBounded"))
              ("4" (rewrite "FcanonicBounded"))))))
          ("2" (rewrite "FsuccCanonic"))))
        ("2" (assert))))
      ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand* "MinOrMax?" "isMin?")
   (skosimp*)
   (split)
   (("1" (propax))
    ("2"
     (skosimp*)
     (hide 2)
     (lemma "FpredFsucc" :subst ("f" "f" "b" "b"))
     (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
     (("1"
       (split)
       (("1"
         (replace -1 1 :dir rl)
         (rewrite "FpredProp")
         (("1"
           (hide 2 -1 -2)
           (trans-ineq 1 "z" :strict 2)
           (expand "abs" -4)
           (trans-ineq 1 "FtoR(f)+Fulp(b)(f)" :strict 1)
           (("1" (assert)) ("2" (rewrite "FsuccDiff" :dir rl) (assert))))
          ("2" (rewrite "FsuccCanonic"))))
        ("2" (propax))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "z <= FtoR(f)")
   (("1"
     (expand "abs" -4)
     (grind-reals)
     (expand* "MinOrMax?" "isMax?")
     (skosimp*)
     (hide 1)
     (lemma "FsuccFpred" :subst ("f" "f" "b" "b"))
     (split)
     (("1"
       (replace -1 1 :dir rl)
       (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
       (("1"
         (rewrite "FsuccProp")
         (("1"
           (hide 2 -1 -2)
           (trans-ineq 1 "z" :strict 1)
           (trans-ineq 1 "FtoR[radix](f) -Fulp(b)(f)" :strict 2)
           (("1"
             (rewrite "FulpCanonic")
             (case-replace "f=(# Fnum:=0, Fexp:=-dExp(b) #)")
             (("1"
               (hide-all-but 1)
               (expand* "Fpred" "FtoR")
               (grind-reals)
               (lemma "radix_less_vNum")
               (inst -1 "b")
               (hide 1)
               (grind-reals))
              ("2"
               (rewrite "FcanonicUnique" :subst
                ("b"
                 "b"
                 "p"
                 "f"
                 "q"
                 "(# Fnum := 0, Fexp := -dExp(b) #)"))
               (("1" (rewrite -3 :dir rl) (expand "FtoR" 1) (assert))
                ("2"
                 (hide-all-but 1)
                 (expand* "Fcanonic?" "Fsubnormal?" "Fbounded?")
                 (grind-reals)
                 (expand "abs")
                 (assert))))))
            ("2" (assert))))
          ("2" (rewrite "FpredCanonic"))))
        ("2" (assert))))
      ("2" (propax))))
    ("2"
     (flip-ineq 1)
     (expand* "MinOrMax?" "isMin?")
     (skosimp*)
     (split)
     (("1" (assert))
      ("2"
       (skosimp*)
       (expand "abs" -5)
       (grind-reals)
       (hide 2)
       (lemma "FpredFsucc" :subst ("f" "f" "b" "b"))
       (split)
       (("1"
         (replace -1 1 :dir rl)
         (case-replace "FtoR(f!1)=FtoR(Fnormalize(b)(f!1))")
         (("1"
           (rewrite "FpredProp")
           (("1"
             (hide -1 -2 2)
             (trans-ineq 1 "z" :strict 2)
             (trans-ineq 1 "FtoR(f)+Fulp(b)(f)" :strict 1)
             (("1" (assert))
              ("2"
               (rewrite "FulpCanonic")
               (case-replace "f=(# Fnum:=0, Fexp:=-dExp(b) #)")
               (("1"
                 (hide-all-but 1)
                 (expand* "Fsucc" "FtoR")
                 (grind-reals)
                 (hide 1)
                 (lemma "radix_less_vNum")
                 (inst?)
                 (assert))
                ("2"
                 (rewrite "FcanonicUnique" :subst
                  ("b"
                   "b"
                   "p"
                   "f"
                   "q"
                   "(# Fnum := 0, Fexp := -dExp(b) #)"))
                 (("1" (rewrite -4 :dir rl) (expand "FtoR" 1) (assert))
                  ("2"
                   (hide-all-but 1)
                   (expand* "Fcanonic?" "Fsubnormal?" "Fbounded?")
                   (expand "abs")
                   (grind-reals))))))))
            ("2" (rewrite "FsuccCanonic"))))
          ("2" (assert))))
        ("2" (propax))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (assert)
   (skeep)
   (assert)
   (case "0 < abs(Fnum(f))")
   (("1"
     (case "0 < 1 - 1 / (2 * abs(Fnum(f)))")
     (("1"
       (mult-by 2 "(1 - 1 / (2 * abs(Fnum(f))))")
       (case-replace
        " abs(FtoR[radix](f)) * (1 - 1 / (2 * abs(Fnum(f)))) = 
                  abs(FtoR(f))-Fulp(b)(f)/2")
       (("1"
         (move-terms 2 l 2)
         (move-terms 2 r 1)
         (trans-ineq 2 "abs(FtoR(f)-z)")
         (("1" (expand "abs" 1) (grind-reals))
          ("2" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))))
        ("2"
         (hide 2 3)
         (field 1)
         (rewrite "FulpCanonic")
         (expand "FtoR" 1)
         (rewrite "abs_mult")
         (expand "abs" 1 2)
         (assert))))
      ("2"
       (case "1 <= abs(Fnum(f))")
       (("1" (field 1)) ("2" (hide-all-but (-1 1)) (grind))))))
    ("2" (hide-all-but (1 2)) (expand* "abs" "FtoR") (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "0 < abs(Fnum(f))")
   (("1"
     (case "0 < 1 + 1 / (2 * abs(Fnum(f)))")
     (("1"
       (mult-by 2 "(1 + 1 / (2 * abs(Fnum(f))))")
       (assert)
       (case-replace
        " abs(FtoR[radix](f)) * (1 / (2 * abs(Fnum(f)))) = 
                  Fulp(b)(f)/2")
       (("1"
         (move-terms 2 r 1)
         (trans-ineq 2 "abs(FtoR(f)-z)")
         (("1" (hide-all-but 1) (expand "abs") (grind-reals))
          ("2" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))))
        ("2"
         (field 1)
         (rewrite "FulpCanonic")
         (hide-all-but 1)
         (expand* "abs" "FtoR")
         (grind-reals))))
      ("2" (field 1))))
    ("2" (hide-all-but (1 2)) (expand* "abs" "FtoR") (grind-reals))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "errorBoundedPlus")
   (inst -1 "b" "f" "p" "q")
   (split)
   (("1"
     (skosimp*)
     (case "FtoR(e!1)=0")
     (("1" (assert))
      ("2"
       (hide 2)
       (typepred "e!1")
       (expand "Fbounded?" -1)
       (flatten)
       (expand "FtoR" 1)
       (case "abs(Fnum(e!1)) < 1")
       (("1" (grind-reals))
        ("2"
         (hide 2)
         (mult-by 1 "radix ^ (-dExp(b))")
         (trans-ineq 1
          "abs(FtoR[radix](f) - (FtoR[radix](p) + FtoR[radix](q)))"
          :strict 2)
         (("1"
           (trans-ineq 1 "abs(FtoR(e!1))")
           (("1"
             (expand "FtoR" 1)
             (rewrite "abs_mult")
             (expand "abs" 1 3)
             (grind-reals)
             (rewrite "Exp_increq_1"))
            ("2" (rewrite -3) (expand "abs" 1) (grind-reals))))
          ("2" (assert))))))))
    ("2" (propax)) ("3" (propax)) ("4" (propax)) ("5" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (split)
   (("1"
     (skosimp*)
     (hide -2)
     (expand* "Fnormal?" "Fbounded?")
     (flatten)
     (case "radix /= 0")
     (("1"
       (trans-ineq 1
        ("radix ^ (Prec(b) - 1)*radix ^(-dExp(b))"
         "radix ^ (Prec(b) - 1)*radix ^(Fexp(f))"))
       (("1" (rewrite "expt_plus" :dir rl) (assert))
        ("2" (div-by 1 "radix ^ (Prec(b) - 1)") (rewrite "Exp_increq_1"))
        ("3"
         (expand "FtoR")
         (rewrite "abs_mult")
         (expand "abs" 1 2)
         (div-by 1 "radix ^ (Fexp(f))")
         (mult-by 1 "radix")
         (rewrite "abs_mult")
         (expand "abs" -4 1)
         (case-replace "vNum(b)=radix ^ (Prec(b) - 1) * radix ")
         (("1" (assert))
          ("2"
           (case-replace "vNum(b) =  radix ^ (Prec(b) - 1) * radix^1")
           (("1" (rewrite "expt_x1"))
            ("2"
             (rewrite "expt_plus" :dir rl)
             (assert)
             (expand "vNum")
             (propax))))))
        ("4" (assert)) ("5" (assert)) ("6" (assert)) ("7" (assert))
        ("8" (assert)) ("9" (assert)) ("10" (assert))))
      ("2" (assert))))
    ("2"
     (skosimp*)
     (expand "Fcanonic?")
     (split)
     (("1" (propax))
      ("2"
       (hide 1)
       (flip-ineq -2)
       (expand "Fsubnormal?")
       (flatten)
       (expand "FtoR")
       (rewrite "abs_mult")
       (rewrite "abs_mult")
       (expand "abs" -3 1)
       (expand "abs" 1 2)
       (case-replace "Prec(b) - 1 - dExp(b)=Prec(b) - 1 +(- dExp(b))")
       (("1"
         (rewrite "expt_plus")
         (copy -4)
         (rewrite -4)
         (div-by 1 "radix ^ (-dExp(b))")
         (mult-by 1 "radix")
         (case-replace "vNum(b) =  radix ^ (Prec(b) - 1) * radix")
         (("1" (assert))
          ("2"
           (case-replace "vNum(b) =  radix ^ (Prec(b) - 1) * radix^1")
           (("1" (rewrite "expt_x1"))
            ("2"
             (rewrite "expt_plus" :dir rl)
             (assert)
             (expand "vNum")
             (propax))))))
        ("2" (assert))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "abs(FtoR(u)-(y1+a1*x1)) < Fulp(b)(Fpred(b)(u)) / 2 + abs(FtoR(u)-(FtoR(t)+FtoR(y)))")
   (("1"
     (case "FtoR(t)+FtoR(y) <= FtoR(u)")
     (("1"
       (rewrite "MinOrMax1")
       (hide 2)
       (trans-ineq 1
        "abs(FtoR[radix](u) - FtoR[radix](t) - FtoR[radix](y)) +
                            Fulp(b)(Fpred(b)(u)) / 2"
        :strict 1)
       (case "abs(FtoR[radix](u) - FtoR[radix](t) - FtoR[radix](y)) <= Fulp(b)(Fpred(b)(u)) / 2")
       (("1" (grind-reals))
        ("2"
         (hide 2)
         (lemma "ClosestUlp2")
         (inst -1 "b" "u" "FtoR(t)+FtoR(y)")
         (split)
         (("1"
           (case-replace "Fabs(u)=u")
           (("1" (assert))
            ("2"
             (hide-all-but (1 -6))
             (expand* "Fabs" "abs" "FtoR")
             (grind-reals)
             (decompose-equality 1))))
          ("2"
           (trans-ineq 1 "FtoR[radix](u)")
           (("1"
             (hide 2)
             (case "0 <= FtoR(t)+FtoR(y)")
             (("1" (expand "abs" 1) (grind-reals))
              ("2"
               (hide-all-but (-4 -5 1))
               (flip-ineq -2)
               (flip-ineq 2)
               (lemma "RleRoundedLessR0")
               (assert)
               (inst -1 "Closest?" "b" "u" "FtoR(t)+FtoR(y)")
               (split)
               (("1" (assert)) ("2" (assert)) ("3" (propax))
                ("4" (rewrite "Closest_RoundedMode"))
                ("5" (typepred "u") (rewrite "FcanonicBounded"))))))
            ("2"
             (hide-all-but (1 -5))
             (expand "abs")
             (expand "Fulp")
             (grind-reals))))
          ("3" (propax)) ("4" (assert))))))
      ("2"
       (flip-ineq 1)
       (case "FtoR(t)+FtoR(y) <= FtoR(u)+ Fulp(b)(Fpred(b)(u)) / 2")
       (("1"
         (rewrite "MinOrMax1")
         (trans-ineq 1
          "abs(-1 * FtoR(y) - FtoR(a) * FtoR(x) + a1 * x1 + y1)+abs(FtoR(t) - FtoR(a) * FtoR(x))+abs(FtoR(t)+FtoR(y)-FtoR(u))"
          :strict 2)
         (("1" (hide-all-but 1) (expand "abs") (grind-reals))
          ("2" (expand "abs" 1 3) (grind-reals))))
        ("2"
         (flip-ineq 1)
         (rewrite "MinOrMax2")
         (hide 2)
         (trans-ineq 1
          "abs(-1 * FtoR(y) - FtoR(a) * FtoR(x) + a1 * x1 + y1)+abs(FtoR(t) - FtoR(a) * FtoR(x))+abs(FtoR(t)+FtoR(y)-FtoR(u))"
          :strict 2)
         (("1" (hide-all-but 1) (expand "abs") (grind-reals))
          ("2"
           (trans-ineq 1
            "Fulp(b)(Fpred(b)(u)) / 4 + Fulp(b)(Fpred(b)(u)) / 4 +
                                     abs(FtoR[radix](t) + FtoR[radix](y) - FtoR[radix](u))"
            :strict 1)
           (("1" (assert))
            ("2"
             (case " Fulp(b)(Fpred(b)(u)) <= Fulp(b)(u)")
             (("1"
               (case "abs(FtoR[radix](t) + FtoR[radix](y) - FtoR[radix](u))<= Fulp(b)(u)/2")
               (("1" (assert))
                ("2"
                 (hide 2)
                 (lemma "ClosestUlp")
                 (inst -1 "b" "u" "FtoR(t)+FtoR(y)")
                 (split)
                 (("1"
                   (hide-all-but (-1 1))
                   (expand "abs")
                   (grind-reals))
                  ("2" (propax)) ("3" (rewrite "FcanonicBounded"))))))
              ("2" (rewrite "FulpFpred1"))))))))))))
    ("2"
     (hide 2)
     (trans-ineq 1
      "abs(y1-FtoR(y)+a1*x1-FtoR(a)*FtoR(x))+abs(FtoR(t)-FtoR(a)*FtoR(x))+abs(FtoR(u)-(FtoR(t)+FtoR(y)))")
     (("1" (hide-all-but 1) (expand "abs") (grind-reals))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (trans-ineq 1 "Fulp(b)(t)/2")
   (("1" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))
    ("2"
     (mult-by 1 "4")
     (field 1)
     (trans-ineq 1 " radix* Fulp(b)(t)")
     (("1" (expand "Fulp") (grind-reals))
      ("2"
       (case "Fcanonic?(b)((# Fnum:= Fnum(t), Fexp:=Fexp(t)+1 #))")
       (("1"
         (case-replace
          "radix * Fulp(b)(t) =Fulp(b)( (# Fnum:= Fnum(t), Fexp:=Fexp(t)+1 #))")
         (("1"
           (rewrite "FulpMonotoneAbs")
           (("1"
             (case-replace
              "abs(FtoR((# Fnum := Fnum(t), Fexp := 1 + Fexp(t) #)))=radix  * abs(FtoR[radix](t))")
             (("1"
               (case "0 <= FtoR(Fpred(b)(u))")
               (("1" (expand "abs" 1 2) (propax))
                ("2" (rewrite "FpredPos"))))
              ("2"
               (hide-all-but 1)
               (expand* "abs" "FtoR")
               (grind-reals)
               (("1" (rewrite "expt_plus") (assert))
                ("2" (rewrite "expt_plus") (assert))))))
            ("2" (rewrite "FcanonicBounded") (rewrite "FpredCanonic"))
            ("3" (rewrite "FcanonicBounded"))))
          ("2"
           (rewrite "FulpCanonic")
           (rewrite "FulpCanonic")
           (rewrite "expt_plus"))
          ("3" (rewrite "FcanonicBounded"))))
        ("2"
         (hide-all-but (-4 1))
         (expand* "Fcanonic?" "Fnormal?" "Fbounded?")
         (flatten)
         (split)
         (("1" (propax)) ("2" (assert)) ("3" (propax))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (trans-ineq 1 "Fulp(b)(t)/2")
   (("1" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))
    ("2"
     (rewrite "FulpCanonic")
     (rewrite "FulpCanonic")
     (("1"
       (expand "Fsubnormal?")
       (flatten)
       (rewrite -5)
       (mult-by 1 "4")
       (field 1)
       (trans-ineq 1 "radix*(radix ^ -dExp(b))")
       (("1" (grind-reals))
        ("2"
         (case-replace
          " radix * (radix ^ -dExp(b))=radix ^(1 - dExp(b))")
         (("1" (rewrite "Exp_increq_1"))
          ("2"
           (lemma "expt_plus")
           (inst -1 "1" "-dExp(b)" "radix")
           (rewrite "expt_x1")
           (assert))))))
      ("2" (rewrite "FpredCanonic"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (rewrite "MinOrMax1")
   (hide 2)
   (copy -6)
   (rewrite -6)
   (trans-ineq 1
    "abs(FtoR(t)-FtoR(a)*FtoR(x))+abs(-1 * FtoR(y) - FtoR(a) * FtoR(x) + a1 * x1 + y1)"
    :strict 2)
   (("1" (hide-all-but 1) (expand "abs") (grind-reals))
    ("2"
     (trans-ineq 1 "Fulp(b)(Fpred(b)(u)) / 2+ Fulp(b)(Fpred(b)(u)) / 4"
      :strict 1)
     (("1"
       (case "abs(FtoR[radix](t) - FtoR[radix](a) * FtoR[radix](x)) <= Fulp(b)(Fpred(b)(u)) / 2")
       (("1" (assert))
        ("2"
         (hide 2)
         (trans-ineq 1 "Fulp(b)(t)/2")
         (("1" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))
          ("2"
           (field 1)
           (case "Fcanonic?(b)(Fpred(b)(u))")
           (("1"
             (rewrite "FulpCanonic")
             (rewrite "FulpCanonic")
             (rewrite "Exp_increq_1")
             (hide-all-but (-1 -7 1))
             (expand* "Fcanonic?" "Fnormal?" "Fsubnormal?" "Fbounded?")
             (split)
             (("1" (flatten) (assert)) ("2" (flatten) (assert))))
            ("2" (rewrite "FpredCanonic"))))))))
      ("2" (expand "Fulp" 1) (grind-reals))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: (trans-ineq 1 " Fulp(b)(t) / 2") -> infinite loop
script:
  (""
   (skeep)
   (case "FtoR(u) <= a1*x1+y1")
   (("1"
     (rewrite "MinOrMax2")
     (hide 2)
     (trans-ineq 1
      "abs(FtoR(u)-(FtoR(t)+FtoR(y)))+abs(FtoR(t)-FtoR(a)*FtoR(x))+abs(-1 * FtoR(y) - FtoR(a) * FtoR(x) + a1 * x1 + y1)"
      :strict 2)
     (("1" (hide-all-but 1) (expand "abs") (grind-reals))
      ("2"
       (case "abs(FtoR[radix](u) - (FtoR[radix](t) + FtoR[radix](y))) <= Fulp(b)(u)/2")
       (("1"
         (case "abs(FtoR[radix](t) - FtoR[radix](a) * FtoR[radix](x)) <= Fulp(b)(u)/4")
         (("1"
           (trans-ineq 1
            "Fulp(b)(u) / 4+ Fulp(b)(u) / 2+Fulp(b)(Fpred(b)(u)) / 4"
            :strict 1)
           (("1" (assert))
            ("2"
             (case "Fulp(b)(Fpred(b)(u)) <= Fulp(b)(u)")
             (("1" (grind-reals)) ("2" (rewrite "FulpFpred1"))))))
          ("2"
           (hide 2 -1)
           (trans-ineq 1 "Fulp(b)(t)/2")
           (("1" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))
            ("2"
             (field 1)
             (rewrite "FulpCanonic")
             (rewrite "FulpCanonic")
             (trans-ineq 1 "radix^(1+Fexp(t))")
             (("1" (rewrite "expt_plus") (grind-reals))
              ("2"
               (rewrite "Exp_increq_1")
               (expand "Fsubnormal?")
               (propax))))))))
        ("2" (rewrite "ClosestUlp") (rewrite "FcanonicBounded"))))))
    ("2"
     (flip-ineq 1)
     (case "Fabs(u)=u")
     (("1"
       (lemma "Axpy_aux2")
       (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
       (split)
       (("1" (propax)) ("2" (propax))
        ("3"
         (rewrite "ExactSum_Near")
         (("1"
           (lemma "ClosestUlp2" :subst
            ("b" "b" "p" "u" "r" "FtoR(t)+FtoR(y)"))
           (split)
           (("1"
             (trans-ineq 1 "Fulp(b)(Fpred(b)(Fabs(u))) / 2" :strict 2)
             (("1" (assert))
              ("2"
               (rewrite "FulpCanonic")
               (("1" (grind-reals)) ("2" (rewrite "FpredCanonic"))))))
            ("2"
             (assert)
             (flip-ineq 1)
             (rewrite "MinOrMax1")
             (expand "abs" 1)
             (trans-ineq 1
              "abs(FtoR(t) + FtoR(y))- Fulp(b)(Fpred(b)(u)) / 2 - a1 * x1 - y1"
              :strict 1)
             (("1" (assert))
              ("2"
               (expand "abs" 1)
               (grind-reals)
               (("1"
                 (hide 1 2)
                 (flip-ineq -7)
                 (lemma "RleRoundedLessR0")
                 (inst -1 "Closest?" "b" "u" "FtoR(t)+FtoR(y)")
                 (split)
                 (("1" (assert)) ("2" (assert)) ("3" (propax))
                  ("4" (rewrite "Closest_RoundedMode"))
                  ("5" (rewrite "FcanonicBounded"))))
                ("2"
                 (hide 1)
                 (trans-ineq 1
                  "abs(FtoR(t)-FtoR(a)*FtoR(x)) + abs(-FtoR(y) - FtoR(a) * FtoR(x) + a1 * x1 + y1) - Fulp(b)(Fpred(b)(u)) / 2")
                 (("1" (hide-all-but 1) (expand "abs") (grind-reals))
                  ("2"
                   (case "abs(FtoR[radix](t) - FtoR[radix](a) * FtoR[radix](x)) <= Fulp(b)(Fpred(b)(u)) / 2")
                   (("1" (grind-reals))
                    ("2"
                     (hide 2 3)
                     (name "f2" "Fulp(b)(t) / 2")
                     (trans-ineq 1 "f2")
                     (("1"
                       (replaces -1 :dir rl)
                       (rewrite "ClosestUlp")
                       (rewrite "FcanonicBounded"))
                      ("2"
                       (replaces -1 :dir rl)
                       (mult-by 1 "2")
                       (rewrite "FulpCanonic")
                       (rewrite "FulpCanonic")
                       (("1" (expand "Fsubnormal?") (flatten) (assert))
                        ("2" (rewrite "FpredCanonic"))))))))))))))
            ("3" (propax))
            ("4"
             (hide-all-but (-4 1))
             (expand* "FtoR" "Fabs" "abs")
             (grind-reals))))
          ("2" (decompose-equality) (rewrite "FcanonicBounded"))
          ("3" (rewrite "FcanonicBounded"))
          ("4" (rewrite "FcanonicBounded"))))
        ("4" (propax)) ("5" (propax)) ("6" (propax)) ("7" (propax))))
      ("2"
       (hide-all-but (-4 1))
       (expand* "FtoR" "Fabs" "abs")
       (grind-reals)
       (decompose-equality))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (typepred "t")
   (expand "Fcanonic?")
   (split)
   (("1"
     (lemma "Axpy_aux1")
     (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
     (split)
     (("1" (propax)) ("2" (propax))
      ("3"
       (lemma "Axpy_aux1_aux1")
       (inst -1 "a" "t" "u" "x" "y")
       (split)
       (("1" (propax)) ("2" (split) (("1" (propax)) ("2" (propax))))
        ("3" (propax)) ("4" (propax)) ("5" (propax)) ("6" (propax))))
      ("4" (propax)) ("5" (propax)) ("6" (propax))))
    ("2"
     (case "1-dExp(b) <= Fexp(Fpred(b)(u))")
     (("1"
       (lemma "Axpy_aux1")
       (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
       (split)
       (("1" (propax)) ("2" (propax))
        ("3"
         (lemma "Axpy_aux1_aux2")
         (inst -1 "a" "t" "u" "x" "y")
         (split)
         (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))
          ("5" (propax)) ("6" (propax))))
        ("4" (propax)) ("5" (propax)) ("6" (propax))))
      ("2"
       (flip-ineq 1)
       (case "1-dExp(b) <= Fexp(u)")
       (("1"
         (lemma "Axpy_aux3")
         (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
         (split)
         (("1" (propax)) ("2" (propax)) ("3" (propax))
          ("4"
           (case "Fbounded?(b)(Fpred(b)(u))")
           (("1" (expand "Fbounded?") (flatten) (assert))
            ("2" (rewrite "FcanonicBounded") (rewrite "FpredCanonic"))))
          ("5" (propax)) ("6" (propax)) ("7" (propax)) ("8" (propax))))
        ("2"
         (flip-ineq 1)
         (lemma "Axpy_aux2")
         (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
         (split)
         (("1" (propax)) ("2" (propax))
          ("3"
           (rewrite "ExactSum_Near")
           (("1"
             (trans-ineq 1 "radix ^ (-dExp(b))/2" :strict 2)
             (("1"
               (lemma "ClosestUlp" :subst
                ("b" "b" "p" "u" "r" "FtoR(t)+FtoR(y)"))
               (split)
               (("1"
                 (trans-ineq 1 "Fulp(b)(u) / 2")
                 (("1" (assert))
                  ("2"
                   (mult-by 1 "2")
                   (rewrite "FulpCanonic")
                   (rewrite "Exp_increq_1"))))
                ("2" (propax)) ("3" (rewrite "FcanonicBounded"))))
              ("2" (grind-reals))))
            ("2" (rewrite "FcanonicBounded"))
            ("3" (rewrite "FcanonicBounded"))
            ("4" (rewrite "FcanonicBounded"))))
          ("4" (propax)) ("5" (propax)) ("6" (propax))
          ("7" (propax))))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (x:float): Fnormal?(b)(x) => radix^(Prec(b)-1) <= abs(Fnum(x))")
   (("1"
     (skeep)
     (inst-cp -1 "t")
     (inst -1 "u")
     (split)
     (("1"
       (split)
       (("1"
         (case "2 <= radix ^ (Prec(b) - 1)")
         (("1"
           (mult-by 1 "(1 - 1 / (2 * abs(Fnum(t))))")
           (("1"
             (trans-ineq 1
              "(1 + radix + radix ^ (4 - Prec(b))) * (1 - radix^(1-Prec(b))/2)")
             (("1"
               (move-terms 1 l 1)
               (move-terms 1 l 4)
               (trans-ineq 1
                "radix/(radix^(Prec(b)-1)-1)+radix/(2*radix^(Prec(b)-1))+
                                                                                                       radix*1/(2*radix^(Prec(b)-1))*1/(radix^(Prec(b)-1)-1)")
               (("1"
                 (case "(abs(Fnum(Fpred(b)(u)))=radix ^ (Prec(b))-1 AND abs(Fnum(u))= radix ^ (Prec(b) - 1)) OR abs(Fnum(Fpred(b)(u)))=abs(Fnum(u))-1")
                 (("1"
                   (split)
                   (("1"
                     (flatten)
                     (copy -3)
                     (replace -3)
                     (hide -4)
                     (replace -2)
                     (hide-all-but (-1 1))
                     (case "radix ^ (Prec(b))=radix*radix ^ (Prec(b) - 1)")
                     (("1"
                       (name-replace "AA" "radix ^ (Prec(b) - 1)")
                       (copy -2)
                       (replace -2)
                       (hide -3)
                       (case "1 / (radix * AA - 1) <= 1 / (AA - 1)")
                       (("1"
                         (case "(1 / (radix * AA - 1)) * (1 / (2 * AA)) * radix <=  radix * 1 / (2 * AA) * 1 / (AA - 1)")
                         (("1"
                           (case " (1 / (radix * AA - 1)) * radix <=  radix / (AA - 1)")
                           (("1" (assert))
                            ("2"
                             (hide 2)
                             (div-by 1 "radix")
                             (case-replace
                              "radix / (AA - 1) / radix=1 / (AA - 1)")
                             (field 1))))
                          ("2"
                           (hide 2)
                           (div-by 1 "radix")
                           (case-replace
                            " radix * 1 / (2 * AA) * 1 / (AA - 1) / radix =
                                                                                                               (1 / (AA - 1))* (1 / (2 * AA))")
                           (("1"
                             (mult-by 1 "2*AA")
                             (case-replace
                              "(1 / (radix * AA - 1)) * (1 / (2 * AA)) * (2 * AA)=1 / (radix * AA - 1)")
                             (("1"
                               (case-replace
                                "(1 / (AA - 1)) * (1 / (2 * AA)) * (2 * AA)=1 / (AA - 1)")
                               (field 1))
                              ("2" (field 1))))
                            ("2" (field 1))))))
                        ("2"
                         (hide 2)
                         (case "0 < radix * AA - 1")
                         (("1"
                           (case "0 < AA - 1")
                           (("1" (grind-reals) (div-by 1 "AA") (assert))
                            ("2" (grind-reals))))
                          ("2"
                           (hide 2)
                           (case "2*2 <= radix*AA")
                           (("1" (grind-reals))
                            ("2"
                             (trans-ineq 1 "2*AA")
                             (("1" (grind-reals))
                              ("2" (grind-reals))))))))))
                      ("2"
                       (hide 2)
                       (rewrite "expt_div" :dir rl)
                       (field 1))))
                    ("2"
                     (replace -1)
                     (hide -2)
                     (case "1 / (abs(Fnum(u)) - 1) <= 1 / (radix ^ (Prec(b) - 1) - 1)")
                     (("1"
                       (trans-ineq 1
                        "radix / (radix ^ (Prec(b) - 1) - 1) +  1 / (2 * abs(Fnum(u))) * radix +
                                                                                                 (1 / (abs(Fnum(u)) - 1)) * (1 / (2 * abs(Fnum(u)))) * radix")
                       (("1" (assert))
                        ("2"
                         (case-replace
                          " radix / (radix ^ (Prec(b) - 1) - 1) = (1/ (radix ^ (Prec(b) - 1) - 1)) * radix")
                         (("1"
                           (case "(1 / (abs(Fnum(u)) - 1)) * radix <=  (1 / (radix ^ (Prec(b) - 1) - 1)) * radix")
                           (("1" (assert))
                            ("2" (hide 2) (div-by 1 "radix"))))
                          ("2" (assert))))
                        ("3"
                         (case "  1 / (2 * abs(Fnum(u))) * radix <= radix / (2 * radix ^ (Prec(b) - 1))")
                         (("1"
                           (trans-ineq 1
                            " radix / (radix ^ (Prec(b) - 1) - 1) +
                                                                                                                  radix / (2 * radix ^ (Prec(b) - 1))+(1 / (abs(Fnum(u)) - 1)) * (1 / (2 * abs(Fnum(u)))) * radix")
                           (("1" (assert))
                            ("2"
                             (case "(1 / (abs(Fnum(u)) - 1)) * (1 / (2 * abs(Fnum(u)))) * radix <=  radix * 1 / (2 * radix ^ (Prec(b) - 1)) * 1 /
                                                                                                                                               (radix ^ (Prec(b) - 1) - 1)")
                             (("1" (assert))
                              ("2"
                               (hide 2)
                               (div-by 1 "radix")
                               (case-replace
                                " radix * 1 / (2 * radix ^ (Prec(b) - 1)) * 1 /
                                                                                                                                  (radix ^ (Prec(b) - 1) - 1)
                                                                                                                                  / radix = 1 / (radix ^ (Prec(b) - 1) - 1) * 1 / (2 * radix ^ (Prec(b) - 1))")
                               (("1"
                                 (case
                                  "(1 / (2 * abs(Fnum(u)))) <= 1 / (2 * radix ^ (Prec(b) - 1))")
                                 (("1"
                                   (trans-ineq
                                    1
                                    " (1 / (abs(Fnum(u)) - 1)) *  1 / (2 * radix ^ (Prec(b) - 1))")
                                   (("1"
                                     (mult-by 1 "abs(Fnum(u)) - 1")
                                     (("1"
                                       (case-replace
                                        "(1 / (abs(Fnum(u)) - 1)) * (1 / (2 * abs(Fnum(u)))) *
                                                                                                                                                                 (abs(Fnum(u)) - 1)=(1 / (2 * abs(Fnum(u))))")
                                       (("1"
                                         (case-replace
                                          "(1 / (abs(Fnum(u)) - 1)) * 1 / (2 * radix ^ (Prec(b) - 1)) *
                                                                                                                                                                          (abs(Fnum(u)) - 1)=1 / (2 * radix ^ (Prec(b) - 1))")
                                         (field 1))
                                        ("2" (field 1))))
                                      ("2" (grind-reals))))
                                    ("2"
                                     (mult-by
                                      1
                                      "2 * radix ^ (Prec(b) - 1)"))))
                                  ("2" (hide 2) (grind-reals))))
                                ("2" (field 1))))))))
                          ("2"
                           (hide 2)
                           (div-by 1 "radix")
                           (case-replace
                            "radix / (2 * radix ^ (Prec(b) - 1)) / radix= 1 / (2*radix ^ (Prec(b) - 1))")
                           (("1"
                             (mult-by 1 "2")
                             (case-replace
                              "1 / (2 * abs(Fnum(u))) * 2=1 /abs(Fnum(u))")
                             (("1"
                               (case-replace
                                "1 / (2 * radix ^ (Prec(b) - 1)) * 2=1/radix ^ (Prec(b) - 1)")
                               (("1" (grind-reals)) ("2" (field 1))))
                              ("2" (field 1)) ("3" (grind-reals))))
                            ("2" (field 1))))))))
                      ("2"
                       (hide 2)
                       (case "0 < radix ^ (Prec(b) - 1) - 1")
                       (("1" (grind-reals))
                        ("2"
                         (case "radix^1 <=  radix ^ (Prec(b) - 1)")
                         (("1" (rewrite "expt_x1") (grind-reals))
                          ("2" (rewrite "Exp_increq_1"))))))))))
                  ("2"
                   (hide 2)
                   (case "0 <  Fnum(u)")
                   (("1"
                     (case "0 <= Fnum(Fpred(b)(u))")
                     (("1"
                       (case-replace
                        "abs(Fnum(Fpred(b)(u)))=Fnum(Fpred(b)(u))")
                       (("1"
                         (case-replace "abs(Fnum(u))=Fnum(u)")
                         (("1"
                           (case-replace "radix ^ (Prec(b))=vNum(b)")
                           (("1"
                             (case-replace
                              "radix ^ (Prec(b)-1)=vNum(b)/radix")
                             (("1" (expand "Fpred" 1) (grind-reals))
                              ("2"
                               (rewrite -1 :dir rl)
                               (rewrite "expt_div" :dir rl))))
                            ("2" (expand "vNum") (propax))))
                          ("2" (expand "abs" 1) (grind-reals))))
                        ("2" (expand "abs" 1) (grind-reals))))
                      ("2"
                       (case "0 <=  FtoR(Fpred(b)(u))")
                       (("1" (expand "FtoR" -1) (grind-reals))
                        ("2" (rewrite "FpredPos"))))))
                    ("2" (expand "FtoR" -6) (grind-reals))))))
                ("2"
                 (hide -2 -3 -4 -5 -6)
                 (case-replace
                  "radix ^ (1 - Prec(b))=1/radix ^ (Prec(b) - 1)")
                 (("1"
                   (case-replace
                    " radix ^ (4 - Prec(b))=radix^3/radix ^ (Prec(b) - 1)")
                   (("1"
                     (hide -1 -2)
                     (name-replace "AA" "radix ^ (Prec(b) - 1)")
                     (case "0 < AA-1")
                     (("1"
                       (case "0 < 2*AA")
                       (("1"
                         (mult-by 1 "AA-1")
                         (mult-by 1 "2*AA")
                         (trans-ineq 1 "3*AA*radix")
                         (("1" (field 1))
                          ("2"
                           (grind-reals)
                           (mult-by 1 "AA")
                           (grind-reals)
                           (case-replace
                            "2 * (AA * AA * radix ^ 3) / (2 * (AA * AA))=radix ^ 3")
                           (("1"
                             (case-replace
                              "2 * (AA * AA * radix) / (2 * AA)=AA * radix")
                             (("1"
                               (case-replace
                                "2 * (AA * AA * AA) / (2 * AA)=AA * AA")
                               (("1"
                                 (case-replace
                                  "2 * (AA * AA * AA * radix ^ 3) / (2 * (AA * AA))=AA * radix ^ 3")
                                 (("1"
                                   (case-replace
                                    " 2 * (AA * AA * AA * radix) / (2 * AA)=AA * AA * radix")
                                   (("1"
                                     (hide -1 -2 -3 -4 -5)
                                     (assert)
                                     (move-terms 1 r 4)
                                     (move-terms 1 r 4)
                                     (move-terms 1 r 4)
                                     (case "radix*radix <= AA")
                                     (("1"
                                       (hide -5)
                                       (rewrite "expt_x3")
                                       (grind-reals)
                                       (trans-ineq
                                        1
                                        " 2 * (AA * AA * radix * radix * radix)")
                                       (("1"
                                         (trans-ineq
                                          1
                                          "AA * AA + 3 * (AA * (AA * radix)) + 4 * (AA * AA * radix)")
                                         (("1" (grind-reals))
                                          ("2"
                                           (div-by 1 "AA")
                                           (div-by 1 "AA")
                                           (trans-ineq 1 "1+7*radix")
                                           (("1" (field 1))
                                            ("2"
                                             (case-replace
                                              "2 * (AA * AA * radix * radix * radix) / AA / AA=2*radix*radix*radix")
                                             (("1"
                                               (hide -1)
                                               (trans-ineq 1 "8*radix")
                                               (("1" (grind-reals))
                                                ("2"
                                                 (div-by 1 "radix")
                                                 (div-by 1 "2")
                                                 (case-replace "8/2=4")
                                                 (("1"
                                                   (trans-ineq
                                                    1
                                                    "2*radix")
                                                   (("1" (grind-reals))
                                                    ("2" (grind-reals))))
                                                  ("2" (field 1))))))
                                              ("2" (field 1))))))))
                                        ("2" (grind-reals))))
                                      ("2"
                                       (hide 2)
                                       (reveal -12)
                                       (rewrite -1 :dir rl)
                                       (rewrite "expt_x2" :dir rl)
                                       (rewrite "Exp_increq_1"))))
                                    ("2" (field 1))))
                                  ("2" (field 1))))
                                ("2" (field 1))))
                              ("2" (field 1))))
                            ("2" (field 1))))))
                        ("2" (hide 2) (grind-reals))))
                      ("2" (hide 2) (grind-reals))))
                    ("2" (hide 2) (rewrite "expt_div"))))
                  ("2"
                   (hide 2)
                   (rewrite "expt_inverse" :dir rl)
                   (assert))))
                ("3" (hide 2) (skosimp*) (hide -1) (grind-reals))
                ("4" (hide 2) (grind-reals))))
              ("2"
               (div-by 1 "1 + radix + radix ^ (4 - Prec(b))")
               (case-replace
                "radix ^ (1 - Prec(b))=1/radix ^ (Prec(b) - 1)")
               (("1" (grind-reals))
                ("2" (rewrite "expt_inverse" :dir rl) (assert))))))
            ("2" (hide 2) (split) (("1" (field 1)) ("2" (field 1))))))
          ("2"
           (trans-ineq 1 "radix ^1")
           (("1" (rewrite "expt_x1") (assert))
            ("2" (rewrite "Exp_increq_1"))))))
        ("2" (propax))))
      ("2" (propax))))
    ("2"
     (hide 2)
     (skeep)
     (expand "Fnormal?")
     (flatten)
     (rewrite "abs_mult")
     (expand "abs" -2 1)
     (case-replace "vNum(b)= radix *radix ^ (Prec(b) - 1)")
     (("1" (grind-reals))
      ("2"
       (case-replace " vNum(b) =radix ^ (Prec(b))")
       (("1" (rewrite "expt_div" :dir rl) (field 1))
        ("2" (assert) (expand "vNum") (propax))))))
    ("3" (hide 2) (skeep) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "Fnormal?(b)(u)")
   (("1"
     (case "0 < Fnum(Fpred(b)(u))")
     (("1"
       (case "0 < 1+1/Fnum(Fpred(b)(u))")
       (("1"
         (trans-ineq 1 "FtoR(u)/(1+1/Fnum(Fpred(b)(u)))")
         (("1"
           (mult-by 1 "1 + 1 / Fnum(Fpred(b)(u))")
           (case "0 < abs(Fnum(u))")
           (("1"
             (case "0 < 1+1/(2*abs(Fnum(u)))")
             (("1"
               (trans-ineq 1
                "abs(FtoR(t)+FtoR(y))/(1+1/(2*abs(Fnum(u))))")
               (("1"
                 (mult-by 1 "1 + 1 / (2 * abs(Fnum(u)))")
                 (trans-ineq 1 "abs(FtoR(y)) - abs(FtoR(t))")
                 (("1"
                   (move-terms 1 r 2)
                   (trans-ineq 1
                    "abs(FtoR[radix](t))*(1+radix*((1 + 1 / Fnum(Fpred(b)(u)))*(1 + 1 / (2 * abs(Fnum(u))))))")
                   (("1" (assert))
                    ("2"
                     (case "0 < abs(Fnum(t))")
                     (("1"
                       (case " 0 <  (1 - 1 / (2 * abs(Fnum(t))))")
                       (("1"
                         (case " abs(FtoR[radix](t)) <=
                                                                                                                           abs(FtoR[radix](a) * FtoR[radix](x)) / (1 - 1 / (2 * abs(Fnum(t))))")
                         (("1"
                           (trans-ineq 1
                            "(radix + 1 + radix ^ (4 - Prec(b))) *
                                                                                                               abs(FtoR[radix](a) * FtoR[radix](x))")
                           (lemma "Axpy_opt_aux1_aux1")
                           (inst -1 "t" "u")
                           (split)
                           (("1"
                             (mult-by -1 "abs(FtoR(a)*FtoR(x))")
                             (trans-ineq 1
                              "(1 +
                                                                                                                        radix * (1 + 1 / (2 * abs(Fnum(u)))) *
                                                                                                                         (1 + 1 / abs(Fnum(Fpred(b)(u)))))
                                                                                                                       / (1 - 1 / (2 * abs(Fnum(t))))
                                                                                                                       * abs(FtoR[radix](a) * FtoR[radix](x))")
                             (("1"
                               (hide -1)
                               (case-replace
                                "abs(Fnum(Fpred(b)(u)))=Fnum(Fpred(b)(u))")
                               (("1"
                                 (hide -1)
                                 (name-replace
                                  "G1"
                                  "(1 - 1 / (2 * abs(Fnum(t))))")
                                 (name-replace
                                  "G2"
                                  "1 + 1 / (2 * abs(Fnum(u)))")
                                 (name-replace
                                  "G3"
                                  "1 + 1 / Fnum(Fpred(b)(u))")
                                 (div-by 1 "1 + radix * (G3 * G2)")
                                 (("1"
                                   (case-replace
                                    "(1 + radix * G2 * G3) / G1 * abs(FtoR[radix](a) * FtoR[radix](x)) /
                                                                                                                                                (1 + radix * (G3 * G2))= abs(FtoR[radix](a) * FtoR[radix](x)) / G1")
                                   (field 1))
                                  ("2"
                                   (hide 2)
                                   (case "radix * (G3 * G2) >= 0")
                                   (("1"
                                     (split)
                                     (("1" (grind-reals))
                                      ("2" (grind-reals))))
                                    ("2" (grind-reals))))))
                                ("2"
                                 (hide 2)
                                 (expand "abs" 1)
                                 (grind-reals))))
                              ("2" (assert))))
                            ("2" (propax)) ("3" (propax)) ("4" (propax))
                            ("5" (propax))))
                          ("2"
                           (hide 2)
                           (rewrite "RoundLe")
                           (hide-all-but (-1 -3))
                           (expand* "abs" "FtoR")
                           (grind-reals))
                          ("3" (assert))))
                        ("2"
                         (hide 2)
                         (hide-all-but (-1 1))
                         (move-terms 1 r 2)
                         (assert)
                         (case "1 <= abs(Fnum(t))")
                         (("1" (grind-reals)) ("2" (hide 2) (grind))))
                        ("3" (assert))))
                      ("2"
                       (expand "Fnormal?")
                       (flatten)
                       (hide-all-but (1 -12))
                       (rewrite "abs_mult")
                       (expand "abs" -1 1)
                       (grind-reals))))))
                  ("2" (expand "abs" 1) (grind-reals))))
                ("2"
                 (trans-ineq 1 "abs(FtoR(u))")
                 (("1" (rewrite "RoundGe"))
                  ("2" (expand "abs") (grind-reals))))
                ("3" (skosimp*) (grind-reals)) ("4" (grind-reals))))
              ("2"
               (case "0 <= 1 / (2 * abs(Fnum(u)))")
               (("1" (grind-reals)) ("2" (grind-reals))))
              ("3" (grind-reals))))
            ("2" (expand "FtoR" -6) (expand "abs" 1) (grind-reals))))
          ("2"
           (mult-by 1 "1 + 1/Fnum(Fpred(b)(u))")
           (assert)
           (case-replace
            " FtoR[radix](Fpred(b)(u)) * (1 / Fnum(Fpred(b)(u))) = Fulp(b)(Fpred(b)(u))")
           (("1" (rewrite "FpredDiff" :dir rl) (assert))
            ("2"
             (hide 2)
             (expand "FtoR" 1)
             (rewrite "FulpCanonic")
             (("1" (field 1)) ("2" (rewrite "FpredCanonic"))))
            ("3" (rewrite "FcanonicBounded") (rewrite "FpredCanonic"))))
          ("3" (hide 2) (skosimp*) (grind-reals))
          ("4" (hide 2) (skosimp*) (grind-reals))))
        ("2"
         (hide-all-but (-1 1))
         (trans-ineq 1 "1" :strict 1)
         (("1" (assert))
          ("2"
           (grind-reals)
           (case "0 <= 1 / Fnum(Fpred(b)(u))")
           (("1" (grind-reals)) ("2" (grind-reals))))))
        ("3" (assert))))
      ("2"
       (hide-all-but (-1 1 -4))
       (expand* "FtoR" "Fnormal?")
       (flatten)
       (expand "abs" -2)
       (grind-reals)
       (expand "Fpred")
       (grind-reals)
       (("1" (lemma "radix_less_vNum") (inst -1 "b") (grind-reals))
        ("2"
         (mult-by 2 "radix")
         (assert)
         (case "radix < vNum(b)")
         (("1" (grind-reals))
          ("2"
           (case-replace "vNum(b)=radix^(Prec(b))")
           (("1"
             (case "radix=radix^1")
             (("1"
               (trans-ineq 1 "radix^1" :strict 2)
               (("1" (assert)) ("2" (rewrite "Exp_incr_1"))))
              ("2" (rewrite "expt_x1"))))
            ("2" (assert) (expand "vNum") (propax))))))
        ("3"
         (mult-by 2 "radix")
         (assert)
         (case "radix < vNum(b)")
         (("1" (grind-reals))
          ("2"
           (trans-ineq 1 "radix^1" :strict 2)
           (("1" (rewrite "expt_x1") (assert))
            ("2"
             (case-replace "vNum(b)=radix^(Prec(b))")
             (("1" (rewrite "Exp_incr_1"))
              ("2" (assert) (expand "vNum") (propax))))))))))))
    ("2"
     (hide 2)
     (lemma "Normal_iff" :subst ("f" "u"))
     (split)
     (("1"
       (flatten)
       (case " radix ^ (Prec(b) - 1 - dExp(b)) <= abs(FtoR[radix](u))")
       (("1" (assert))
        ("2"
         (trans-ineq 1 "abs(FtoR(t))")
         (("1"
           (lemma "Normal_iff" :subst ("f" "t"))
           (split)
           (("1" (flatten) (assert)) ("2" (assert))))
          ("2"
           (hide 2 -1 -2)
           (lemma "Closest_Monotone")
           (expand "Monotone?")
           (inst -1 "b" "abs(FtoR(t))" "abs(FtoR(t)+FtoR(y))" "Fabs(t)"
            "Fabs(u)")
           (("1"
             (split)
             (("1" (rewrite "FabsCorrect") (rewrite "FabsCorrect"))
              ("2" (rewrite "ClosestFabs") (rewrite "FcanonicBounded"))
              ("3"
               (rewrite "ClosestFabs")
               (("1"
                 (rewrite "RoundedProjector")
                 (("1" (rewrite "Closest_RoundedMode"))
                  ("2" (rewrite "FcanonicBounded"))))
                ("2" (rewrite "FcanonicBounded"))))
              ("4"
               (hide 2)
               (case "0 <  2*radix^(Prec(b)-1)")
               (("1"
                 (trans-ineq 1
                  "abs(FtoR[radix](t))*((radix+1)*(1-1/(2*radix ^ (Prec(b) - 1)))-1) "
                  :strict 1)
                 (("1"
                   (div-by 1 "abs(FtoR[radix](t))")
                   (("1"
                     (case "radix*radix <=radix ^ (Prec(b) - 1)")
                     (("1"
                       (name-replace "AA" "radix ^ (Prec(b) - 1)")
                       (hide-all-but (-1 -2 1))
                       (field 1)
                       (move-terms 1 r 2)
                       (move-terms 1 r 2)
                       (trans-ineq 1 "2*AA+AA" :strict 2)
                       (("1"
                         (move-terms 1 r 1)
                         (assert)
                         (trans-ineq 1 "radix*radix")
                         (trans-ineq 1 "radix+radix")
                         (("1" (grind-reals)) ("2" (grind-reals))))
                        ("2" (div-by 1 "AA") (field 1))))
                      ("2"
                       (rewrite "expt_x2" :dir rl)
                       (rewrite "Exp_increq_1"))))
                    ("2"
                     (hide-all-but (1 -6))
                     (expand* "Fnormal?" "FtoR")
                     (flatten)
                     (rewrite "abs_mult")
                     (rewrite "abs_mult")
                     (expand "abs" -2 1)
                     (expand "abs" 1 2)
                     (grind-reals))))
                  ("2"
                   (trans-ineq 1 "abs(FtoR(y))-abs(FtoR(t))")
                   (("1"
                     (move-terms 1 r 2)
                     (trans-ineq 1
                      "(abs(FtoR[radix](t)) *  ((radix + 1) * (1 - 1 / (2 * radix ^ (Prec(b) - 1)))))")
                     (("1" (assert))
                      ("2"
                       (trans-ineq 1
                        "abs(FtoR[radix](a) * FtoR[radix](x))*(radix + 1)")
                       (("1"
                         (name-replace "rr" "radix+1")
                         (cancel-by 1 "rr")
                         (hide -1 1)
                         (trans-ineq 1
                          "(abs(FtoR[radix](t)) *(1 - 1 / (2 * radix ^ (Prec(b) - 1))))")
                         (("1"
                           (name-replace "G1"
                            "1 / (2 * radix ^ (Prec(b) - 1))")
                           (grind-reals))
                          ("2"
                           (lemma "RoundLe")
                           (inst -1 "t" "FtoR(a)*FtoR(x)")
                           (case " 0 < 2 * abs(Fnum(t))")
                           (("1"
                             (case " 0 < 1 - 1 / (2 * abs(Fnum(t)))")
                             (("1"
                               (split)
                               (("1"
                                 (mult-by
                                  -1
                                  " 1 - 1 / (2 * abs(Fnum(t)))")
                                 (trans-ineq
                                  1
                                  "abs(FtoR[radix](t)) * (1 - 1 / (2 * abs(Fnum(t))))")
                                 (("1"
                                   (div-by 1 "abs(FtoR[radix](t))")
                                   (case
                                    " radix ^ (Prec(b) - 1) <= abs(Fnum(t))")
                                   (("1" (grind-reals))
                                    ("2"
                                     (hide-all-but (-9 1))
                                     (expand "Fnormal?")
                                     (flatten)
                                     (case-replace
                                      "radix ^ (Prec(b) - 1)=vNum(b)/radix")
                                     (("1"
                                       (grind-reals)
                                       (expand "abs" -3 1)
                                       (assert))
                                      ("2"
                                       (case-replace
                                        "vNum(b)=radix ^ (Prec(b))")
                                       (("1"
                                         (rewrite "expt_div" :dir rl))
                                        ("2"
                                         (assert)
                                         (expand "vNum")
                                         (propax))))))))
                                  ("2" (grind-reals))))
                                ("2" (propax))
                                ("3"
                                 (hide-all-but (-1 -9))
                                 (expand* "Fnormal?" "FtoR")
                                 (flatten)
                                 (expand "abs")
                                 (grind-reals))
                                ("4" (assert))))
                              ("2"
                               (hide-all-but (-1 -8 1))
                               (case "1 <= abs(Fnum(t))")
                               (("1" (field 1))
                                ("2" (hide -2 2) (grind))))
                              ("3" (assert))))
                            ("2"
                             (hide-all-but (1 -7))
                             (expand "Fnormal?")
                             (flatten)
                             (expand "abs")
                             (grind))))))
                        ("2"
                         (trans-ineq 1
                          "(radix + 1 + radix ^ (4 - Prec(b))) *
                                                                                 abs(FtoR[radix](a) * FtoR[radix](x))")
                         (div-by 1 "abs(FtoR(a)*FtoR(x))")
                         (grind-reals))))))
                    ("2"
                     (hide-all-but 1)
                     (expand "abs")
                     (grind-reals))))))
                ("2" (grind-reals)) ("3" (assert))))))
            ("2" (rewrite "FabsBounded") (rewrite "FcanonicBounded"))
            ("3" (rewrite "FabsBounded") (rewrite "FcanonicBounded"))))))
        ("3" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (case "FORALL (x:float): Fnormal?(b)(x) => radix^(Prec(b)-1) <= abs(Fnum(x))")
   (("1"
     (skeep)
     (case "Fnormal?(b)(Fpred(b)(u))")
     (("1"
       (case "Fnormal?(b)(u)")
       (("1"
         (trans-ineq 1 "abs(FtoR(u))*radix^(-Prec(b))" :strict 1)
         (("1"
           (mult-by 1 "radix ^ (Prec(b))")
           (trans-ineq 1 "abs(FtoR[radix](y)) * radix/(radix+1)" :strict
            2)
           (("1" (rewrite "expt_div" :dir rl) (field 1))
            ("2"
             (trans-ineq 1 "abs(FtoR(u))" :strict 1)
             (("1"
               (case "0< 2*abs(Fnum(u))")
               (("1"
                 (case "0< 1+1/(2*abs(Fnum(u)))")
                 (("1"
                   (trans-ineq 1
                    "abs(FtoR(t)+FtoR(y))/(1+1/(2*abs(Fnum(u))))" :strict
                    1)
                   (("1"
                     (case "0 < 1+radix^(1-Prec(b))/2")
                     (("1"
                       (trans-ineq 1
                        " abs(FtoR[radix](t) + FtoR[radix](y)) / ( 1 + radix ^ (1 - Prec(b)) / 2)"
                        :strict 1)
                       (("1"
                         (mult-by 1 "1 + radix ^ (1 - Prec(b)) / 2")
                         (trans-ineq 1 "abs(FtoR(y))-abs(FtoR(t))"
                          :strict 1)
                         (("1"
                           (move-terms 1 l 1)
                           (move-terms 1 r 2)
                           (assert)
                           (case "0 < 1+radix+radix^(4 - Prec(b))")
                           (("1"
                             (case " 0 < 1 - radix ^ (1 - Prec(b)) / 2")
                             (("1"
                               (trans-ineq 1
                                "abs(FtoR(y))/(1 - radix ^ (1 - Prec(b)) / 2)*1/(1 + radix + radix ^ (4 - Prec(b)))"
                                :strict 2)
                               (("1"
                                 (case "0 < 2 * abs(Fnum(t))")
                                 (("1"
                                   (case
                                    "0 < 1 - 1 / (2 * abs(Fnum(t)))")
                                   (("1"
                                     (trans-ineq
                                      1
                                      "abs(FtoR(a)*FtoR(x))/(1-1/(2*abs(Fnum(t))))")
                                     (("1"
                                       (rewrite "RoundLe")
                                       (hide-all-but (-1 -3))
                                       (expand* "FtoR" "abs")
                                       (grind-reals))
                                      ("2"
                                       (trans-ineq
                                        1
                                        "abs(FtoR[radix](a) * FtoR[radix](x)) / (1 - radix ^ (1 - Prec(b)) / 2)")
                                       (("1"
                                         (inst -10 "t")
                                         (split)
                                         (("1"
                                           (field 1)
                                           (div-by 1 "abs(FtoR(a))")
                                           (div-by 1 "abs(FtoR(x))")
                                           (field 1)
                                           (mult-by
                                            1
                                            "radix ^ (Prec(b) - 1)")
                                           (trans-ineq 1 "abs(Fnum(t))")
                                           (("1" (assert))
                                            ("2"
                                             (div-by 1 "abs(Fnum(t))")
                                             (field 1)
                                             (rewrite
                                              "expt_plus"
                                              :dir
                                              rl)
                                             (assert))))
                                          ("2" (propax))))
                                        ("2"
                                         (mult-by
                                          1
                                          "(1 - radix ^ (1 - Prec(b)) / 2)")
                                         (field 1))))
                                      ("3" (assert))
                                      ("4" (assert))))
                                    ("2"
                                     (move-terms 1 r 2)
                                     (assert)
                                     (hide 2 -15)
                                     (case "1 <=  abs(Fnum(t))")
                                     (("1" (grind-reals))
                                      ("2"
                                       (hide-all-but (-1 1))
                                       (name-replace "gg" "abs(Fnum(t))")
                                       (grind-reals))))
                                    ("3" (assert))))
                                  ("2"
                                   (expand "Fnormal?" -13)
                                   (flatten)
                                   (hide 2 -15)
                                   (grind-reals))))
                                ("2"
                                 (case-replace
                                  " radix ^ (4 - Prec(b))=radix^3*radix ^ (1 - Prec(b))")
                                 (("1"
                                   (case "0 < radix ^ (1 - Prec(b))")
                                   (("1"
                                     (case
                                      " radix ^ (1 - Prec(b)) <= radix^(-5)")
                                     (("1"
                                       (hide
                                        -7
                                        -8
                                        -9
                                        -10
                                        -11
                                        -12
                                        -13
                                        -14
                                        -16
                                        -17)
                                       (name-replace
                                        "AA"
                                        "radix ^ (1 - Prec(b))")
                                       (hide -3 -7)
                                       (mult-by 1 "1+radix")
                                       (trans-ineq
                                        1
                                        "abs(FtoR[radix](y))*(1+radix) - abs(FtoR[radix](y)) * radix -
                                                                                                                             AA / 2 * (abs(FtoR[radix](y)) * radix)"
                                        :strict
                                        1)
                                       (("1"
                                         (div-by 1 "abs(FtoR(y))")
                                         (("1"
                                           (trans-ineq
                                            1
                                            "1/ (1 - AA / 2) * 1 / (1 + radix + radix ^ 3 * AA)
                                                                                                                                       * (1 + radix)"
                                            :strict
                                            2)
                                           (("1"
                                             (field 1)
                                             (mult-by -5 " 1 - AA / 2")
                                             (grind-reals))
                                            ("2"
                                             (trans-ineq
                                              1
                                              "( (1 + radix) -  radix -
                                                                                                                                               AA / 2 *  radix)"
                                              :strict
                                              1)
                                             (("1"
                                               (mult-by 1 "1-AA/2")
                                               (trans-ineq
                                                1
                                                "1 / (1 + radix + radix ^ 3 * AA) * (1 + radix)"
                                                :strict
                                                2)
                                               (("1" (field 1))
                                                ("2"
                                                 (mult-by
                                                  1
                                                  "1 + radix + radix ^ 3 * AA")
                                                 (trans-ineq
                                                  1
                                                  "1+radix"
                                                  :strict
                                                  2)
                                                 (("1" (field 1))
                                                  ("2"
                                                   (assert)
                                                   (assert)
                                                   (move-terms 1 l 1)
                                                   (move-terms 1 l 1)
                                                   (assert)
                                                   (move-terms
                                                    1
                                                    r
                                                    (2 3 4 5 6))
                                                   (div-by 1 "AA")
                                                   (trans-ineq
                                                    1
                                                    "( 1 / 2 + radix ^ 3 * (AA / 2) + 1/ 2 * radix * radix +
                                                                                                                                                                  radix ^ 3 * (AA / 2) * radix
                                                                                                                                                                +  radix)"
                                                    :strict
                                                    2)
                                                   (("1" (field 1))
                                                    ("2"
                                                     (trans-ineq
                                                      1
                                                      " (radix ^ 3 + AA / 4 * radix +
                                                                                                                                                                        (AA / 4) * radix * radix
                                                                                                                                                                       +  radix ^ 3 * (AA / 2) * (AA / 2) * radix)"
                                                      :strict
                                                      1)
                                                     (("1"
                                                       (trans-ineq
                                                        1
                                                        "radix ^ 3"
                                                        :strict
                                                        2)
                                                       (("1"
                                                         (mult-by 1 "2")
                                                         (trans-ineq
                                                          1
                                                          "1+radix^3*AA+radix*radix+radix^3*radix*AA+2*radix")
                                                         (("1" (field 1))
                                                          ("2"
                                                           (trans-ineq
                                                            1
                                                            "1 + radix ^ 3 * radix^(-5) + radix * radix + radix ^ 3 * radix * radix^(-5) + 2 * radix")
                                                           (("1"
                                                             (move-terms
                                                              1
                                                              r
                                                              (1 3 5))
                                                             (assert)
                                                             (case
                                                              "radix ^ 3 * AA <=  radix ^ 3 * radix ^ (-5)")
                                                             (("1"
                                                               (case
                                                                "AA * radix ^ 3 * radix <=  radix ^ 3 * radix ^ (-5) * radix")
                                                               (("1"
                                                                 (assert))
                                                                ("2"
                                                                 (grind-reals))))
                                                              ("2"
                                                               (grind-reals))))
                                                            ("2"
                                                             (rewrite
                                                              "expt_plus"
                                                              :dir
                                                              rl)
                                                             (case-replace
                                                              "radix ^ 3 * radix * radix ^ (-5)=radix^(-1)")
                                                             (("1"
                                                               (case
                                                                "radix * radix <= radix ^ 3")
                                                               (("1"
                                                                 (case
                                                                  "1 + radix ^ -2 + radix ^ (-1) + 2 * radix <=
                                                                                                                                                                                                         radix ^ 3")
                                                                 (("1"
                                                                   (assert))
                                                                  ("2"
                                                                   (hide
                                                                    2)
                                                                   (trans-ineq
                                                                    1
                                                                    "radix^2+radix^2")
                                                                   (("1"
                                                                     (case
                                                                      "1 + radix ^ -2 + radix ^ (-1) <= radix ^ 2")
                                                                     (("1"
                                                                       (case
                                                                        " 2 * radix <= radix ^ 2")
                                                                       (("1"
                                                                         (assert))
                                                                        ("2"
                                                                         (rewrite
                                                                          "expt_x2")
                                                                         (grind-reals))))
                                                                      ("2"
                                                                       (hide
                                                                        2)
                                                                       (trans-ineq
                                                                        1
                                                                        "radix+1+1")
                                                                       (("1"
                                                                         (case
                                                                          "1 <= radix")
                                                                         (("1"
                                                                           (case
                                                                            "radix ^ -2 <= 1")
                                                                           (("1"
                                                                             (case
                                                                              "radix ^ -1 <= 1")
                                                                             (("1"
                                                                               (assert))
                                                                              ("2"
                                                                               (trans-ineq
                                                                                1
                                                                                "radix^0")
                                                                               (("1"
                                                                                 (rewrite
                                                                                  "Exp_increq_1"))
                                                                                ("2"
                                                                                 (rewrite
                                                                                  "expt_x0")
                                                                                 (assert))))))
                                                                            ("2"
                                                                             (trans-ineq
                                                                              1
                                                                              "radix^0")
                                                                             (("1"
                                                                               (rewrite
                                                                                "Exp_increq_1"))
                                                                              ("2"
                                                                               (rewrite
                                                                                "expt_x0")
                                                                               (assert))))))
                                                                          ("2"
                                                                           (assert))))
                                                                        ("2"
                                                                         (rewrite
                                                                          "expt_x2")
                                                                         (grind-reals)
                                                                         (trans-ineq
                                                                          1
                                                                          "radix+radix")
                                                                         (("1"
                                                                           (grind-reals))
                                                                          ("2"
                                                                           (grind-reals))))))))
                                                                    ("2"
                                                                     (trans-ineq
                                                                      1
                                                                      "radix*radix^2")
                                                                     (("1"
                                                                       (grind-reals))
                                                                      ("2"
                                                                       (lemma
                                                                        "expt_plus")
                                                                       (inst
                                                                        -1
                                                                        "2"
                                                                        "1"
                                                                        "radix")
                                                                       (rewrite
                                                                        "expt_x1")
                                                                       (assert))))))))
                                                                ("2"
                                                                 (rewrite
                                                                  "expt_x2"
                                                                  :dir
                                                                  rl)
                                                                 (rewrite
                                                                  "Exp_increq_1"))))
                                                              ("2"
                                                               (lemma
                                                                "expt_plus")
                                                               (inst
                                                                -1
                                                                "3"
                                                                "1"
                                                                "radix")
                                                               (rewrite
                                                                "expt_x1")
                                                               (rewrite
                                                                -1
                                                                :dir
                                                                rl)
                                                               (rewrite
                                                                "expt_plus"
                                                                :dir
                                                                rl)
                                                               (assert))))))))
                                                        ("2"
                                                         (grind-reals))))
                                                      ("2"
                                                       (field 1))))))))))
                                              ("2" (field 1))))))
                                          ("2"
                                           (hide-all-but 1)
                                           (reveal -19 -16 -20)
                                           (case
                                            "0 < abs(FtoR(a)*FtoR(x))*(radix+1+radix^(4-Prec(b)))")
                                           (("1" (grind-reals))
                                            ("2"
                                             (div-by
                                              1
                                              " (radix + 1 + radix ^ (4 - Prec(b)))")
                                             (trans-ineq 1 "0" :strict 2)
                                             (("1" (field 1))
                                              ("2"
                                               (case
                                                "0 <= abs(FtoR(a)*FtoR(x))")
                                               (("1"
                                                 (split-ineq -1)
                                                 (case
                                                  "FtoR[radix](t)=FtoR[radix]((#Fnum:=0, Fexp:=-dExp(b)#))")
                                                 (("1"
                                                   (hide-all-but (-1 -5))
                                                   (expand*
                                                    "Fnormal?"
                                                    "FtoR")
                                                   (flatten)
                                                   (grind-reals))
                                                  ("2"
                                                   (lemma
                                                    "RoundedProjectorEq")
                                                   (inst
                                                    -1
                                                    "Closest?"
                                                    "b"
                                                    "(# Fnum := 0, Fexp := -dExp(b) #)"
                                                    "t")
                                                   (split)
                                                   (("1" (propax))
                                                    ("2"
                                                     (case-replace
                                                      "FtoR((# Fnum := 0, Fexp := -dExp(b) #))=FtoR(a)*FtoR(x)")
                                                     (hide-all-but
                                                      (-1 1))
                                                     (expand "FtoR" 1 1)
                                                     (expand "abs" -1)
                                                     (grind-reals))
                                                    ("3"
                                                     (rewrite
                                                      "Closest_RoundedMode"))
                                                    ("4"
                                                     (rewrite
                                                      "FcanonicBounded"))
                                                    ("5"
                                                     (hide-all-but 1)
                                                     (expand "Fbounded?")
                                                     (expand "abs")
                                                     (assert))))))
                                                ("2"
                                                 (grind-reals))))))))))
                                        ("2" (field 1))))
                                      ("2" (rewrite "Exp_increq_1"))))
                                    ("2" (assert))))
                                  ("2" (rewrite "expt_plus" :dir rl))))
                                ("3" (assert)) ("4" (assert))))
                              ("2"
                               (move-terms 1 r 2)
                               (assert)
                               (hide-all-but (-11 1))
                               (trans-ineq 1 "1/2" :strict 2)
                               (("1"
                                 (field 1)
                                 (trans-ineq 1 "radix^0")
                                 (("1" (rewrite "Exp_increq_1"))
                                  ("2" (rewrite "expt_x0") (assert))))
                                ("2" (grind-reals))))))
                            ("2" (hide-all-but 1) (grind-reals))))
                          ("2"
                           (hide-all-but 1)
                           (expand "abs")
                           (grind-reals))))
                        ("2"
                         (inst -6 "u")
                         (split)
                         (("1"
                           (field 1)
                           (div-by 1 "abs(FtoR(t)+FtoR(y))")
                           (field 1)
                           (case "1<=abs(Fnum(u)) *  (radix ^ (1 - Prec(b)))")
                           (("1"
                             (mult-by -1 "abs(FtoR(t) + FtoR(y))")
                             (assert))
                            ("2"
                             (hide 2)
                             (assert)
                             (mult-by 1 "radix ^ (Prec(b) - 1)")
                             (trans-ineq 1 "abs(Fnum(u))")
                             (("1" (assert))
                              ("2"
                               (div-by 1 "abs(Fnum(u))")
                               (field 1)
                               (rewrite "expt_plus" :dir rl)
                               (assert))))))
                          ("2" (propax))))))
                      ("2"
                       (trans-ineq 1 "1" :strict 1)
                       (("1" (assert)) ("2" (grind-reals))))
                      ("3" (assert))))
                    ("2" (rewrite "RoundGe")) ("3" (assert))
                    ("4" (assert))))
                  ("2"
                   (trans-ineq 1 "1" :strict 1)
                   (("1" (assert))
                    ("2" (move-terms 1 r 1) (assert) (grind-reals))))
                  ("3" (assert))))
                ("2"
                 (expand "Fnormal?" -1)
                 (flatten)
                 (hide-all-but (-2 1))
                 (grind-reals))))
              ("2" (rewrite "expt_inverse") (field 1))))))
          ("2"
           (rewrite "expt_inverse")
           (mult-by 1 "radix ^ Prec(b)")
           (trans-ineq 1 "abs(FtoR(u))")
           (("1" (field 1))
            ("2"
             (trans-ineq 1 " Fulp(b)(Fpred(b)(u))+ FtoR(Fpred(b)(u))")
             (("1"
               (rewrite "FpredDiff" :dir rl)
               (assert)
               (expand "abs" 1)
               (assert))
              ("2"
               (expand "FtoR" 1)
               (rewrite "FulpCanonic")
               (("1"
                 (div-by 1 "radix ^ (Fexp(Fpred(b)(u)))")
                 (trans-ineq 1 "Fnum(Fpred(b)(u))+1")
                 (("1" (field 1))
                  ("2"
                   (hide-all-but (-2 1))
                   (name-replace "ff" "Fpred(b)(u)")
                   (expand* "Fnormal?" "Fbounded?")
                   (flatten)
                   (case-replace " radix ^ Prec(b)= vNum(b)")
                   (("1"
                     (expand "abs" -2)
                     (grind-reals)
                     (case "FORALL (i,j:int): i<j => 1+i <= j")
                     (("1" (inst?) (assert)) ("2" (skeep) (assert))))
                    ("2" (assert) (expand "vNum") (propax))))))
                ("2" (rewrite "FpredCanonic"))))))))
          ("3" (assert)) ("4" (assert))))
        ("2"
         (lemma "Normal_iff")
         (inst-cp -1 "u")
         (inst -1 "Fpred(b)(u)")
         (split)
         (("1"
           (split)
           (("1"
             (flatten)
             (rewrite -2)
             (trans-ineq 1 " abs(FtoR[radix](Fpred(b)(u)))")
             (case " 0 <= FtoR(Fpred(b)(u))")
             (("1"
               (expand "abs" 1)
               (lemma "FpredLt")
               (inst -1 "b" "u")
               (assert))
              ("2" (rewrite "FpredPos"))))
            ("2" (assert))))
          ("2" (assert) (rewrite "FpredCanonic"))))))
      ("2"
       (lemma "Normal_iff")
       (inst-cp -1 "Fpred(b)(u)")
       (inst -1 "t")
       (split)
       (("1"
         (split)
         (("1"
           (flatten)
           (rewrite -2)
           (trans-ineq 1 "abs(FtoR(t))")
           (trans-ineq 1 "radix*abs(FtoR(t))")
           (("1" (div-by 1 "abs(FtoR[radix](t))") (assert))
            ("2"
             (expand "abs" 1 2)
             (grind-reals)
             (("1"
               (lemma "Axpy_opt_aux1")
               (inst -1 "a" "t" "u" "x" "y")
               (split)
               (("1" (assert)) ("2" (assert)) ("3" (propax))
                ("4" (assert)) ("5" (propax)) ("6" (propax))
                ("7" (propax))))
              ("2"
               (lemma "Axpy_opt_aux1")
               (inst -1 "a" "t" "u" "x" "y")
               (split)
               (("1" (propax)) ("2" (assert)) ("3" (propax))
                ("4" (assert)) ("5" (propax)) ("6" (propax))
                ("7" (propax))))))))
          ("2" (assert) (rewrite "FpredCanonic"))))
        ("2" (assert))))))
    ("2"
     (hide 2)
     (skeep)
     (expand "Fnormal?")
     (flatten)
     (case-replace "vNum(b)=radix ^ (Prec(b))")
     (("1"
       (rewrite "expt_div" :dir rl)
       (rewrite "abs_mult")
       (expand "abs" -3 1)
       (grind-reals))
      ("2" (assert) (expand "vNum") (propax)) ("3" (assert))))
    ("3" (hide 2) (skosimp*) (assert))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "-dExp(b) <= Fexp(u)")
   (("1"
     (split-ineq -1)
     (("1"
       (hide -2)
       (mult-by 1 "radix/2+radix")
       (mult-by 1 "radix ^ (Prec(b)-1)")
       (trans-ineq 1
        "abs(FtoR[radix](y)) * (radix ^ (1 - Prec(b)) * radix ^ (Prec(b) - 1))"
        :strict 2)
       (("1" (assert))
        ("2"
         (rewrite "expt_plus" :dir rl)
         (case-replace "FtoR(y)=FtoR(u)-FtoR(t)")
         (("1"
           (trans-ineq 1 "abs(FtoR(u))+abs(FtoR(t))" :strict 2)
           (("1" (hide-all-but 1) (expand "abs") (grind-reals))
            ("2"
             (rewrite "FulpCanonic")
             (("1"
               (case-replace "Fexp(Fpred(b)(u))=-dExp(b)")
               (("1"
                 (assert)
                 (case "abs(FtoR[radix](t)) <=  radix ^ (Prec(b) - 1) * radix ^ -dExp(b)*(radix/2)")
                 (("1"
                   (case "abs(FtoR[radix](u)) < radix ^ (Prec(b) - 1) * radix ^ -dExp(b) * radix")
                   (("1" (assert))
                    ("2"
                     (hide 2)
                     (rewrite "FabsCorrect" :dir rl)
                     (expand "Fabs")
                     (expand "FtoR" 1)
                     (rewrite -4 :dir rl)
                     (div-by 1 "radix ^ -dExp(b)")
                     (field 1)
                     (trans-ineq 1 "vNum(b)" :strict 1)
                     (("1"
                       (case "Fbounded?(b)(u)")
                       (("1" (expand "Fbounded?") (propax))
                        ("2" (rewrite "FcanonicBounded"))))
                      ("2"
                       (trans-ineq 1 "radix ^ (Prec(b))")
                       (("1" (assert) (expand "vNum") (assert))
                        ("2"
                         (lemma "expt_plus")
                         (inst -1 "1" "Prec(b)-1" "radix")
                         (rewrite "expt_x1")
                         (assert))))))))
                  ("2"
                   (hide-all-but (-8 1))
                   (expand* "Fsubnormal?" "FtoR")
                   (flatten)
                   (copy -3)
                   (rewrite -3)
                   (div-by 1 "radix ^ -dExp(b)")
                   (rewrite "abs_mult")
                   (rewrite "abs_mult")
                   (expand "abs" 1 2)
                   (field 1)
                   (case-replace " radix ^ (Prec(b) - 1)=vNum(b)/radix")
                   (("1"
                     (trans-ineq 1 "radix*abs(Fnum(t))")
                     (("1" (grind-reals))
                      ("2" (expand "abs" -3 1) (grind-reals))))
                    ("2"
                     (rewrite "expt_div" :dir rl)
                     (grind-reals)
                     (expand "vNum")
                     (propax))))))
                ("2"
                 (hide-all-but (-2 -5 1))
                 (expand "Fpred")
                 (expand "FtoR")
                 (grind-reals))))
              ("2" (rewrite "FpredCanonic"))))))
          ("2"
           (case "FtoR(u)=FtoR(t)+FtoR(y)")
           (("1" (assert))
            ("2"
             (hide 2 3)
             (lemma "ExactSum_Near")
             (inst?)
             (split)
             (("1" (propax))
              ("2"
               (trans-ineq 1 "radix ^ (-dExp(b))/2" :strict 2)
               (("1"
                 (trans-ineq 1 "Fulp(b)(u)/2")
                 (("1"
                   (rewrite "ClosestUlp")
                   (rewrite "FcanonicBounded"))
                  ("2" (rewrite "FulpCanonic") (assert))))
                ("2" (grind-reals))))
              ("3" (propax)) ("4" (rewrite "FcanonicBounded"))
              ("5" (rewrite "FcanonicBounded"))
              ("6" (rewrite "FcanonicBounded"))))))))))
      ("2"
       (case "-dExp(b) < Fexp(u)")
       (("1"
         (hide -2 1)
         (trans-ineq 1 "abs(FtoR(u))*radix^(-Prec(b)) ")
         (("1"
           (mult-by 1 "radix ^ (Prec(b))")
           (trans-ineq 1
            "abs(FtoR[radix](y)) / (radix/2 + radix)*(radix ^ (1 - Prec(b))*radix ^ (Prec(b)))")
           (("1" (assert))
            ("2"
             (rewrite "expt_plus" :dir rl)
             (trans-ineq 1
              "abs(FtoR(u))*(radix ^ (-Prec(b)) * radix ^ (Prec(b)))")
             (("1"
               (rewrite "expt_plus" :dir rl)
               (case-replace "(Prec(b)) + (-Prec(b))=0")
               (("1"
                 (assert)
                 (case "Fexp(u)=1-dExp(b) OR 2-dExp(b) <= Fexp(u)")
                 (("1"
                   (split)
                   (("1"
                     (hide -2 -3)
                     (div-by 1 "radix")
                     (mult-by 1 "radix/2+radix")
                     (trans-ineq 1
                      "abs(FtoR(u))+abs(FtoR(t))+abs(FtoR(u)-(FtoR(t)+FtoR(y)))")
                     (("1" (hide-all-but 1) (expand "abs") (grind-reals))
                      ("2"
                       (hide -7)
                       (trans-ineq 1
                        "abs(FtoR(u))+(radix^(Prec(b)-1)-1)*radix^(-dExp(b))+radix^(1-dExp(b))/2")
                       (("1"
                         (case "abs(FtoR[radix](t)) <= (radix ^ (Prec(b) - 1) - 1) * radix ^ (-dExp(b))")
                         (("1"
                           (case "abs(FtoR[radix](u) - (FtoR[radix](t) + FtoR[radix](y)))
                                                                                                                                                              <= radix ^ (1 - dExp(b)) / 2")
                           (("1" (assert))
                            ("2"
                             (hide 2)
                             (trans-ineq 1 "Fulp(b)(u)/2")
                             (("1"
                               (rewrite "ClosestUlp")
                               (rewrite "FcanonicBounded"))
                              ("2"
                               (rewrite "FulpCanonic")
                               (rewrite -2)
                               (assert))))))
                          ("2"
                           (expand "Fsubnormal?")
                           (flatten)
                           (expand "FtoR" 1)
                           (rewrite "abs_mult")
                           (expand "abs" 1 2)
                           (copy -8)
                           (rewrite -8)
                           (hide 2)
                           (div-by 1 " radix ^ -dExp(b)")
                           (trans-ineq 1 "(radix ^ (Prec(b) - 1)-1)")
                           (("1"
                             (rewrite "abs_mult" -1)
                             (expand "abs" -1 1)
                             (case-replace
                              "vNum(b)=radix*(radix ^ (Prec(b) - 1))")
                             (("1"
                               (div-by -2 "radix")
                               (case "FORALL (i,j:int):i<j=> i<= j-1")
                               (("1"
                                 (inst?)
                                 (("1" (assert))
                                  ("2" (hide-all-but (-7 1)) (grind))))
                                ("2" (skosimp*) (assert))))
                              ("2"
                               (rewrite "expt_div" :dir rl)
                               (grind-reals)
                               (expand "vNum")
                               (propax))))
                            ("2" (field 1))))))
                        ("2"
                         (mult-by 1 "radix")
                         (trans-ineq 1 "abs(FtoR(u))*(radix/2+radix)")
                         (("1"
                           (assert)
                           (move-terms 1 r 2)
                           (assert)
                           (mult-by 1 "2")
                           (field 1)
                           (div-by 1 "radix")
                           (trans-ineq 1
                            "(2 * (radix ^ (Prec(b) - 1) * radix ^ (-dExp(b)) ) -
                                                              2 * (radix ^ (-dExp(b)) )
                                                              + ((radix ^ (1 - dExp(b)))))")
                           (("1" (field 1))
                            ("2"
                             (rewrite "FabsCorrect" :dir rl)
                             (expand "FtoR" 1)
                             (expand "Fabs")
                             (rewrite -1)
                             (case-replace
                              "radix ^ (1 - dExp(b))=radix*radix ^ (-dExp(b))")
                             (("1"
                               (div-by 1 "radix ^ (-dExp(b))")
                               (trans-ineq 1
                                "(radix -2 +
                                                                      2 * (radix ^ (Prec(b) - 1)))")
                               (("1" (grind-reals)) ("2" (field 1))
                                ("3"
                                 (field 1)
                                 (trans-ineq 1 "(radix ^ (Prec(b)))")
                                 (("1"
                                   (case "2 <= radix")
                                   (("1"
                                     (split-ineq -1)
                                     (("1"
                                       (rewrite -1)
                                       (rewrite -1 :dir rl)
                                       (assert)
                                       (lemma "expt_plus")
                                       (inst -1 "1" "Prec(b)-1" "2")
                                       (rewrite "expt_x1")
                                       (assert))
                                      ("2"
                                       (case "2 < radix")
                                       (("1"
                                         (hide -2 1)
                                         (trans-ineq
                                          1
                                          "3 * (radix ^ (Prec(b) - 1))")
                                         (("1"
                                           (move-terms 1 l 1)
                                           (assert)
                                           (trans-ineq 1 "radix^1")
                                           (("1"
                                             (rewrite "expt_x1")
                                             (assert))
                                            ("2"
                                             (rewrite "Exp_increq_1"))))
                                          ("2"
                                           (trans-ineq
                                            1
                                            "radix * (radix ^ (Prec(b) - 1))")
                                           (("1" (grind-reals))
                                            ("2"
                                             (rewrite "expt_div" :dir rl)
                                             (grind-reals))))))
                                        ("2" (assert))))))
                                    ("2" (assert))))
                                  ("2"
                                   (typepred "u")
                                   (expand*
                                    "Fcanonic?"
                                    "Fsubnormal?"
                                    "Fnormal?")
                                   (flatten)
                                   (rewrite "abs_mult")
                                   (expand "abs" -2 1)
                                   (trans-ineq 1 "vNum(b)")
                                   (assert)
                                   (expand "vNum")
                                   (assert))))))
                              ("2"
                               (lemma "expt_plus")
                               (inst -1 "1" "-dExp(b)" "radix")
                               (rewrite "expt_x1")
                               (assert))))))
                          ("2" (field 1))))))))
                    ("2"
                     (div-by 1 "radix")
                     (mult-by 1 "radix / 2 + radix")
                     (case "0 < 1+radix^(1-Prec(b))/2")
                     (("1"
                       (trans-ineq 1
                        "abs(FtoR(u))*(1+radix^(1-Prec(b))/2+radix^(-2))")
                       (("1"
                         (assert)
                         (move-terms 1 r 2)
                         (trans-ineq 1
                          "abs(FtoR[radix](y)) - abs(FtoR(t))")
                         (("1"
                           (move-terms 1 r 2)
                           (move-terms 1 l 1)
                           (move-terms 1 l 1)
                           (assert)
                           (trans-ineq 1
                            "radix^(Prec(b)-1)*radix^(-dExp(b))")
                           (("1"
                             (hide-all-but (-9 1))
                             (rewrite "FabsCorrect" :dir rl)
                             (expand* "FtoR" "Fabs" "Fsubnormal?")
                             (flatten)
                             (trans-ineq 1
                              "vNum(b)/radix*radix ^(-dExp(b))")
                             (("1"
                               (rewrite "abs_mult")
                               (expand "abs" -3 1)
                               (copy -3)
                               (rewrite -3)
                               (div-by 1 "radix ^ -dExp(b) ")
                               (grind-reals))
                              ("2"
                               (div-by 1 "radix ^ -dExp(b) ")
                               (rewrite "expt_div" :dir rl)
                               (grind-reals)
                               (expand "vNum")
                               (assert))))
                            ("2"
                             (rewrite "FabsCorrect" :dir rl)
                             (expand "FtoR" 1)
                             (expand "Fabs")
                             (trans-ineq 1
                              "abs(Fnum(u))*(radix ^ Fexp(u)*radix ^ (-2))")
                             (("1"
                               (rewrite "expt_plus" :dir rl :subst
                                ("i" "Fexp(u)"))
                               (case "radix ^ (Prec(b) - 1) <= abs(Fnum(u))")
                               (("1"
                                 (case
                                  "radix ^ (-dExp(b)) <= radix ^ (Fexp(u) - 2)")
                                 (("1" (grind-reals))
                                  ("2" (rewrite "Exp_increq_1"))))
                                ("2"
                                 (hide-all-but (-2 1))
                                 (typepred "u")
                                 (expand*
                                  "Fcanonic?"
                                  "Fnormal?"
                                  "Fsubnormal?")
                                 (flatten)
                                 (rewrite "abs_mult")
                                 (expand "abs" -2 1)
                                 (trans-ineq 1 " vNum(b)/radix")
                                 (("1"
                                   (rewrite "expt_div" :dir rl)
                                   (grind-reals)
                                   (expand "vNum")
                                   (assert))
                                  ("2" (grind-reals))))))
                              ("2" (assert))))))
                          ("2"
                           (trans-ineq 1 "abs(FtoR(t)+FtoR(y))")
                           (("1"
                             (hide-all-but 1)
                             (expand "abs")
                             (grind-reals))
                            ("2"
                             (case " 0 < 2*abs(Fnum(u))")
                             (("1"
                               (case "0 < 1+1/(2*abs(Fnum(u)))")
                               (("1"
                                 (trans-ineq
                                  1
                                  " abs(FtoR[radix](u))*(1+  1 / (2 * abs(Fnum(u))))")
                                 (("1"
                                   (div-by
                                    1
                                    "1 + 1 / (2 * abs(Fnum(u)))")
                                   (rewrite "RoundGe"))
                                  ("2"
                                   (assert)
                                   (move-terms 1 l 1)
                                   (assert)
                                   (div-by 1 "abs(FtoR(u))")
                                   (mult-by 1 "2")
                                   (lemma "expt_inverse")
                                   (inst -1 "Prec(b)-1" "radix")
                                   (trans-ineq
                                    1
                                    "1 / (radix ^ (Prec(b) - 1))")
                                   (("1"
                                     (field 1)
                                     (hide-all-but (-7 1))
                                     (typepred "u")
                                     (expand*
                                      "Fcanonic?"
                                      "Fnormal?"
                                      "Fsubnormal?")
                                     (flatten)
                                     (rewrite "abs_mult")
                                     (expand "abs" -2 1)
                                     (trans-ineq 1 "vNum(b)/radix")
                                     (("1"
                                       (rewrite "expt_div" :dir rl)
                                       (grind-reals)
                                       (expand "vNum")
                                       (assert))
                                      ("2" (grind-reals))))
                                    ("2" (grind-reals))))))
                                ("2"
                                 (hide-all-but (-1 1))
                                 (trans-ineq 1 "1" :strict 1)
                                 (("1" (assert))
                                  ("2"
                                   (move-terms 1 l 1)
                                   (assert)
                                   (grind-reals))))
                                ("3" (assert))))
                              ("2"
                               (hide-all-but (-7 1))
                               (expand* "FtoR" "abs")
                               (grind-reals))))))))
                        ("2"
                         (div-by 1 "abs(FtoR(u))")
                         (field 1)
                         (move-terms 1 l 3)
                         (assert)
                         (case "(2 * (radix ^ (-2) * radix)) <= 1")
                         (("1"
                           (case "(radix * (radix ^ (1 - Prec(b)))) <= 1")
                           (("1" (assert))
                            ("2"
                             (hide-all-but (-11 1))
                             (lemma "expt_plus")
                             (inst -1 "1" "1-Prec(b)" "radix")
                             (rewrite "expt_x1")
                             (trans-ineq 1 "radix ^ (2 - Prec(b))")
                             (("1" (assert))
                              ("2"
                               (trans-ineq 1 "radix ^ 0")
                               (("1" (rewrite "Exp_increq_1"))
                                ("2" (rewrite "expt_x0") (assert))))))))
                          ("2"
                           (hide-all-but 1)
                           (rewrite "expt_inverse")
                           (rewrite "expt_x2")
                           (field 1))))))
                      ("2" (grind-reals))))))
                  ("2" (hide-all-but (-2 1)) (flatten) (grind-reals))))
                ("2" (assert))))
              ("2" (assert))))))
          ("2"
           (expand "abs" 1)
           (rewrite "expt_inverse")
           (cross-mult 1)
           (trans-ineq 1 "FtoR(u)")
           (("1" (assert))
            ("2"
             (trans-ineq 1 "Fulp(b)(Fpred(b)(u))+FtoR(Fpred(b)(u))")
             (("1" (rewrite "FpredDiff" :dir rl) (assert))
              ("2"
               (rewrite "FulpCanonic")
               (("1"
                 (expand "FtoR" 1)
                 (div-by 1 "radix ^ (Fexp(Fpred(b)(u)))")
                 (trans-ineq 1 "Fnum(Fpred(b)(u))+1")
                 (("1" (field 1))
                  ("2"
                   (case "Fbounded?(b)(Fpred(b)(u))")
                   (("1"
                     (expand "Fbounded?")
                     (flatten)
                     (hide-all-but (-1 1))
                     (case-replace "radix ^ (Prec(b))=vNum(b)")
                     (("1"
                       (expand "abs")
                       (grind-reals)
                       (case "FORALL (i,j:int): i<j => 1+i <= j")
                       (("1" (grind-reals)) ("2" (grind-reals))))
                      ("2" (assert) (expand "vNum") (propax))))
                    ("2"
                     (rewrite "FcanonicBounded")
                     (rewrite "FpredCanonic"))))))
                ("2" (rewrite "FpredCanonic"))))))))))
        ("2" (assert))))))
    ("2"
     (case "Fbounded?(b)(u)")
     (("1" (expand "Fbounded?") (flatten))
      ("2" (rewrite "FcanonicBounded"))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "AxpyPos")
   (inst?)
   (inst -1 "t" "u")
   (split)
   (("1" (propax))
    ("2"
     (trans-ineq 1
      "abs(FtoR[radix](y)) * radix ^ (1 - Prec(b)) / (6 * radix)" :strict
      1)
     (mult-by 1 "4")
     (typepred "t")
     (expand "Fcanonic?")
     (split)
     (("1"
       (trans-ineq 1 "abs(FtoR(y))*radix^(1-Prec(b))/(radix+1)" :strict
        2)
       (("1"
         (hide-all-but 1)
         (div-by 1 "abs(FtoR(y))")
         (trans-ineq 1 "radix ^ (1 - Prec(b)) / (6 * radix) * 4 ")
         (("1" (field 1))
          ("2"
           (trans-ineq 1 "radix ^ (1 - Prec(b)) / (radix + 1)")
           (("1"
             (div-by 1 "radix ^ (1 - Prec(b))")
             (trans-ineq 1 "4/(6*radix)")
             (("1" (field 1))
              ("2"
               (trans-ineq 1 "1/(radix + 1)")
               (("1" (grind-reals)) ("2" (field 1))))))
            ("2" (field 1))))))
        ("2"
         (lemma "Axpy_opt_aux2")
         (inst?)
         (inst -1 "t" "u")
         (split)
         (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))
          ("5" (propax)) ("6" (propax)) ("7" (propax))))))
      ("2"
       (trans-ineq 1 "abs(FtoR(y))*radix^(1-Prec(b))/(radix+radix/2)")
       (("1" (hide-all-but 1) (field 1))
        ("2"
         (lemma "Axpy_opt_aux3")
         (inst?)
         (inst -1 "t" "u")
         (split)
         (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (assert))
          ("5" (propax)) ("6" (propax)) ("7" (propax))))))))
    ("3"
     (skosimp*)
     (lemma "Axpy_opt_aux1")
     (inst?)
     (inst -1 "t" "u")
     (split)
     (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (assert))
      ("5" (propax)) ("6" (propax)) ("7" (propax))))
    ("4" (propax)) ("5" (propax)) ("6" (propax))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case "u=(# Fnum:= 0, Fexp:=-dExp(b) #)")
   (("1"
     (case "FtoR(u)=FtoR(t)+FtoR(y)")
     (("1"
       (case "FtoR(y)=0")
       (("1"
         (hide-all-but (-1 -8))
         (flip-ineq -2)
         (rewrite -1)
         (expand "abs")
         (grind-reals))
        ("2"
         (case "radix*abs(FtoR(y)) <= (radix+1)*Fulp(b)(y)/2")
         (("1"
           (hide-all-but (-1 1))
           (rewrite "FabsCorrect" :dir rl)
           (rewrite "FulpCanonic")
           (expand* "Fabs" "FtoR")
           (div-by -1 "radix ^ (Fexp(y))")
           (case-replace
            " radix * (abs(Fnum(y)) * radix ^ Fexp(y)) / radix ^ (Fexp(y))= radix * abs(Fnum(y))")
           (("1"
             (case-replace
              "(radix ^ (Fexp(y)) + radix ^ (Fexp(y)) * radix) / 2 /
                                              radix ^ (Fexp(y))=(radix+1)/2")
             (("1"
               (hide -1 -2)
               (div-by -1 "radix")
               (case "abs(Fnum(y)) < 1")
               (("1" (expand "abs" -1) (grind-reals))
                ("2"
                 (trans-ineq 1 "(radix + 1) / 2 / radix" :strict 2)
                 (grind-reals))))
              ("2" (field 1))))
            ("2" (field 1))))
          ("2"
           (case "(radix+1) * abs(FtoR[radix](y)) <= abs(FtoR(y))+(radix + 1) * Fulp(b)(y) / 2")
           (("1" (grind-reals))
            ("2"
             (hide 2 4)
             (div-by 1 "radix+1")
             (trans-ineq 1
              "abs(FtoR[radix](y))/(radix+1)+ Fulp(b)(y) / 2")
             (("1"
               (move-terms 1 r 2)
               (trans-ineq 1 "abs(FtoR(a)*FtoR(x))")
               (("1"
                 (move-terms 1 l 2)
                 (move-terms 1 r 1)
                 (case-replace "y=Fopp(t)")
                 (("1"
                   (rewrite "FulpOpp")
                   (("1"
                     (rewrite "FoppCorrect")
                     (case-replace "abs(-FtoR(t))=abs(FtoR(t))")
                     (("1"
                       (trans-ineq 1 "abs(FtoR(t)-FtoR(a)*FtoR(x))")
                       (("1"
                         (hide-all-but (-5 1))
                         (case "FORALL (v,w:real): (v>=0 => w>=0)=> (v<=0 => w<=0) => abs(w)-abs(v)<=abs(w-v)")
                         (("1"
                           (inst -1 "FtoR(a)*FtoR(x)" "FtoR(t)")
                           (split)
                           (("1" (propax))
                            ("2"
                             (skosimp*)
                             (lemma "RleRoundedLessR0")
                             (inst -1 "Closest?" "b" "t"
                              "FtoR(a)*FtoR(x)")
                             (split)
                             (("1" (propax)) ("2" (propax))
                              ("3" (propax))
                              ("4" (rewrite "Closest_RoundedMode"))
                              ("5" (rewrite "FcanonicBounded"))))
                            ("3"
                             (skosimp*)
                             (lemma "RleRoundedR0")
                             (inst -1 "Closest?" "b" "t"
                              "FtoR(a)*FtoR(x)")
                             (split)
                             (("1" (assert)) ("2" (assert))
                              ("3" (propax))
                              ("4" (rewrite "Closest_RoundedMode"))
                              ("5" (rewrite "FcanonicBounded"))))))
                          ("2"
                           (hide -1 2)
                           (skeep)
                           (expand "abs")
                           (grind-reals))))
                        ("2"
                         (rewrite "ClosestUlp")
                         (rewrite "FcanonicBounded"))))
                      ("2"
                       (hide-all-but 1)
                       (expand "abs")
                       (grind-reals))))
                    ("2" (rewrite "FcanonicBounded"))))
                  ("2"
                   (lemma "FcanonicUnique")
                   (inst -1 "b" "y" "Fopp(t)")
                   (split)
                   (("1" (propax)) ("2" (rewrite "FoppCorrect") (assert))
                    ("3"
                     (lemma "FcanonicOpp")
                     (inst -1 "b" "t")
                     (assert))
                    ("4" (assert))))))
                ("2"
                 (mult-by 1 "radix+1")
                 (trans-ineq 1
                  "(radix + 1 + radix ^ (4 - Prec(b))) *
                                                         abs(FtoR[radix](a) * FtoR[radix](x))")
                 (assert)
                 (move-terms 1 r 1)
                 (move-terms 1 r 2)
                 (assert))))
              ("2" (field 1))))))))))
      ("2"
       (rewrite "ExactSum_Near")
       (("1"
         (trans-ineq 1 "Fulp(b)(u)/2" :strict 2)
         (("1"
           (lemma "ClosestUlp")
           (inst -1 "b" "u" "FtoR(t)+FtoR(y)")
           (split)
           (("1" (assert)) ("2" (propax))
            ("3" (rewrite "FcanonicBounded"))))
          ("2" (rewrite "FulpCanonic") (rewrite -1) (grind-reals))))
        ("2" (rewrite "FcanonicBounded"))
        ("3" (rewrite "FcanonicBounded"))
        ("4" (rewrite "FcanonicBounded"))))))
    ("2"
     (lemma "FcanonicUnique")
     (inst -1 "b" "u" "(# Fnum := 0, Fexp := -dExp(b) #)")
     (split)
     (("1" (propax))
      ("2" (rewrite -3 :dir rl) (expand "FtoR" 1) (assert))
      ("3"
       (expand* "Fcanonic?" "Fsubnormal?" "Fbounded?")
       (flatten)
       (split)
       (("1" (expand "abs" 1) (grind-reals))
        ("2" (expand "abs" 1) (grind-reals))))
      ("4" (assert))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (case " 0 < FtoR(u)")
   (("1"
     (lemma "Axpy_optPos")
     (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
     (split)
     (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))
      ("5" (propax)) ("6" (propax)) ("7" (propax))))
    ("2"
     (case "0=FtoR(u)")
     (("1"
       (lemma "Axpy_optZero")
       (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
       (split)
       (("1" (propax)) ("2" (propax)) ("3" (propax)) ("4" (propax))
        ("5" (propax)) ("6" (propax))))
      ("2"
       (case "FtoR(u) < 0")
       (("1"
         (hide 1 2)
         (lemma "Axpy_optPos")
         (inst -1 "a" "a1" "Fopp(t)" "Fopp(u)" "Fopp(x)" "-x1" "Fopp(y)"
          "-y1")
         (("1"
           (split)
           (("1"
             (case "u=Fopp(Fopp(u))")
             (("1"
               (replace -1 1)
               (case-replace "y1 + a1 * x1=-(-y1 + a1 * -x1)")
               (("1"
                 (rewrite "MinOrMax_Fopp")
                 (rewrite "FoppBounded")
                 (rewrite "FcanonicBounded"))
                ("2" (assert))))
              ("2" (expand "Fopp" 1) (decompose-equality 1))))
            ("2"
             (trans-ineq 1
              "abs(y1 - FtoR[radix](y) + a1 * x1 - FtoR[radix](a) * FtoR[radix](x))"
              :strict 2)
             (("1"
               (hide-all-but 1)
               (rewrite "FoppCorrect")
               (rewrite "FoppCorrect")
               (expand "abs")
               (grind-reals))
              ("2"
               (rewrite "FoppCorrect")
               (case-replace "abs(-FtoR(y))= abs(FtoR[radix](y))")
               (expand "abs" 1)
               (grind-reals))))
            ("3"
             (rewrite "FoppCorrect")
             (rewrite "FoppCorrect")
             (case-replace "abs(-FtoR(y))= abs(FtoR[radix](y))")
             (("1"
               (case-replace
                "abs(FtoR[radix](a) * -FtoR(x))= abs(FtoR[radix](a) * FtoR[radix](x))")
               (hide-all-but 1)
               (rewrite "abs_mult")
               (rewrite "abs_mult")
               (expand "abs")
               (grind-reals))
              ("2" (hide-all-but 1) (expand "abs") (grind-reals))))
            ("4" (propax)) ("5" (rewrite "FoppCorrect") (grind-reals))
            ("6"
             (case-replace
              "FtoR(Fopp(t))+FtoR(Fopp(y))=-(FtoR(t)+FtoR(y))")
             (("1" (rewrite "ClosestFopp") (rewrite "FcanonicBounded"))
              ("2"
               (rewrite "FoppCorrect")
               (rewrite "FoppCorrect")
               (assert))))
            ("7"
             (case-replace "FtoR(a)*FtoR(Fopp(x))=-(FtoR(a)*FtoR(x))")
             (("1" (rewrite "ClosestFopp") (rewrite "FcanonicBounded"))
              ("2" (rewrite "FoppCorrect") (assert))))))
          ("2" (lemma "FcanonicOpp") (inst -1 "b" "y") (assert))
          ("3"
           (lemma "FcanonicOpp")
           (inst -1 "b" "y")
           (assert)
           (lemma "FcanonicOpp")
           (inst -1 "b" "x")
           (assert))
          ("4" (lemma "FcanonicOpp") (inst -1 "b" "u") (assert))
          ("5" (lemma "FcanonicOpp") (inst -1 "b" "t") (assert))))
        ("2" (grind-reals))))))))


proof_type: f_proof
decl_type: formula
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skeep)
   (lemma "Axpy_opt")
   (inst -1 "a" "a1" "t" "u" "x" "x1" "y" "y1")
   (split)
   (("1" (propax))
    ("2"
     (case-replace
      "abs(FtoR[radix](y)) * 2 ^ (1 - Prec(b)) / 12=abs(FtoR[radix](y)) * radix ^ (1 - Prec(b)) / (6 * radix)")
     (hide-all-but (-4 1))
     (replace -1)
     (assert))
    ("3"
     (trans-ineq 1
      " (3 + 1 / 100000) * abs(FtoR[radix](a) * FtoR[radix](x))")
     (div-by 1 "abs(FtoR(a)*FtoR(x))")
     (replace -4)
     (hide-all-but (-3 1))
     (assert)
     (move-terms 1 l 1)
     (assert)
     (trans-ineq 1 "2^(-20)")
     (("1"
       (reveal -4)
       (case-replace "2=radix")
       (("1" (rewrite "Exp_increq_1")) ("2" (assert))))
      ("2" (eval-formula))))
    ("4" (assert)) ("5" (propax)) ("6" (propax))))


proof_type: t_proof
decl_type: tcc
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (expand "abs" -5)
   (grind-reals)
   (hide -1 -4)
   (expand* "FtoR" "Fnormal?")
   (flatten)
   (expand "abs")
   (grind-reals)
   (expand "Fpred")
   (grind-reals)
   (("1" (lemma "radix_less_vNum") (inst -1 "b") (grind-reals))
    ("2"
     (case-replace "Fnum(u)=1")
     (("1"
       (case-replace "vNum(b)=radix^(Prec(b))")
       (("1"
         (flip-ineq -4)
         (assert)
         (case "radix^1 < radix ^ (Prec(b))")
         (("1" (rewrite "expt_x1") (assert))
          ("2" (rewrite "Exp_incr_1"))))
        ("2" (assert) (expand "vNum") (propax))))
      ("2" (assert))))
    ("3"
     (case-replace "Fnum(u)=1")
     (("1"
       (case "radix^1 < radix ^ (Prec(b))")
       (("1"
         (flip-ineq -4)
         (assert)
         (case-replace "vNum(b)=radix^(Prec(b))")
         (("1" (rewrite "expt_x1") (assert))
          ("2" (assert) (expand "vNum") (propax))))
        ("2" (rewrite "Exp_incr_1"))))
      ("2" (assert))))))


proof_type: t_proof
decl_type: tcc
library: float
theory: axpy
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skeep)
   (case "0 < (1 - 1 / (2 * abs(Fnum(t))))")
   (("1" (grind-reals))
    ("2"
     (hide -5)
     (case "0 < abs(Fnum(t))")
     (("1"
       (case "1 <= abs(Fnum(t))")
       (("1" (grind-reals) (move-terms 1 r 2) (assert))
        ("2" (grind-reals) (hide-all-but (-1 1)) (grind))))
      ("2"
       (expand "Fnormal?")
       (flatten)
       (hide-all-but (-2 1))
       (expand "abs")
       (grind-reals))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: matroids
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem! 1)
   (flatten)
   (expand "circuit?")
   (flatten)
   (bddsimp)
   (typepred "M!1")
   (expand "indep_subset")
   (lemma "finite_sets[T].same_card_subset")
   (lemma "finite_sets[T].smaller_card_subset")
   (lemma "finite_sets[T].card_subset")
   (inst -3 "B!1" "A!1")
   (bddsimp)
   (("1"
     (inst -2 "B!1" "A!1")
     (bddsimp)
     (("1" (skosimp*)) ("2" (inst -1 "B!1" "A!1") (bddsimp) (assert))))
    ("2"
     (inst -2 "B!1" "A!1")
     (inst -1 "B!1" "A!1")
     (bddsimp)
     (("1"
       (skosimp*)
       (case "subset?(B!1,remove(x!1,A!1))")
       (("1"
         (inst -6 "remove(x!1,A!1)" "B!1")
         (bddsimp)
         (hide -7)
         (inst -7 "x!1")
         (("1" (assert) (expand "member") (propax))
          ("2"
           (expand "member")
           (assert)
           (expand "indep_in_elem")
           (inst -5 "A!1")
           (reveal -3)
           (assert)
           (bddsimp)
           (expand "subset?")
           (inst -1 "x!1")
           (expand "member" -1)
           (propax))))
        ("2"
         (hide [-4 -5 -6 -7 -8])
         (hide [3 4 5 6])
         (ground)
         (hide -4 -5)
         (hide 3 4)
         (hide -2)
         (install-rewrites t "finite_sets[T]")
         (assert)
         (skosimp*)
         (bddsimp)
         (("1" (assert)) ("2" (assert) (inst -2 "x!2") (bddsimp))))))
      ("2" (hide-all-but (-2 1 2)) (grind))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: matroids
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "circuit?")
   (bddsimp)
   (skosimp*)
   (inst -2 "remove(x!1,A!1)")
   (bddsimp)
   (("1"
     (hide -1 1 3)
     (install-rewrites "finite_sets[T]")
     (assert)
     (expand "remove")
     (expand "member")
     (replace -1 -2 rl)
     (grind))
    ("2"
     (hide -1 1 3)
     (expand "subset?")
     (skosimp*)
     (expand "member")
     (expand "remove")
     (expand "member")
     (grind))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: matroids
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "finite_add[T]")
   (inst -1 "singleton[T](x!1)" "y!1")
   (expand "add")
   (expand "member")
   (expand "singleton")
   (case-replace
    "{y: T | (y!1 = y OR y = x!1)} = {t: T | t = x!1 OR t = y!1}")
   (hide -1 2)
   (apply-extensionality 1 :hide? t)
   (iff 1)
   (ground))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: matroids
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "a!1")
   (typepred "A!1")
   (expand "subset?")
   (expand "member")
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: matroids
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: V3
script:
  (""
   (skosimp*)
   (typepred "A!1")
   (lemma "finite_sets_eq[T,T].surjection_from_finite_set")
   (inst -1 "A!1" "{t: T | EXISTS (a: (A!1)): f!1(a) = t}")
   (("1"
     (bddsimp)
     (inst 1 "restrict[(elem(M1!1)),(A!1),(elem(M2!1))].restrict(f!1)")
     (("1"
       (expand "surjective?")
       (skosimp*)
       (typepred "y!1")
       (skosimp*)
       (inst 1 "a!1")
       (typepred "a!1")
       (hide -3 -4 2)
       (expand "restrict")
       (propax))
      ("2"
       (skosimp*)
       (typepred "x1!1")
       (expand "subset?")
       (expand "member")
       (inst -3 "x1!1")
       (bddsimp)
       (inst 1 "x1!1")
       (expand "restrict")
       (propax))
      ("3"
       (skosimp*)
       (install-rewrites "finite_sets[T]")
       (typepred "x!1")
       (expand "subset?")
       (expand "member")
       (inst -3 "x!1")
       (prop))))
    ("2"
     (install-rewrites "finite_sets[T]")
     (skosimp*)
     (typepred "a!1")
     (expand "subset?")
     (expand "member")
     (inst -3 "a!1")
     (bddsimp))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: doubletons
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (auto-rewrite-defs :always? t)
   (assert)
   (skolem-typepred)
   (skolem-typepred)
   (flatten)
   (replace*)
   (assert)
   (inst? :if-match t :polarity? nil)
   (flatten)
   (propax))


proof_type: f_proof
decl_type: formula
library: graphs
theory: doubletons
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "dbl")
   (assert)
   (lemma "choose_is_epsilon[T]")
   (inst?)
   (("1"
     (replace -1)
     (hide -1)
     (lemma "epsilon_ax[T]")
     (("1" (inst?) (assert) (inst + "x!1"))
      ("2" (assert) (inst + "x!1"))))
    ("2"
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (inst - "x!1"))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: doubletons
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "rest")
   (lemma "doubleton_nonempty")
   (inst - "dbl(x!1, y!1)")
   (("1"
     (expand "nonempty?")
     (assert)
     (use "dbl_choose")
     (ground)
     (("1" (replace -2) (expand "remove") (expand "member") (assert))
      ("2"
       (replace -1)
       (expand "remove")
       (expand "member")
       (assert)
       (expand "dbl")
       (hide -1 3)
       (rewrite "choose_is_epsilon[T]")
       (("1"
         (lemma "epsilon_ax[T]")
         (("1" (inst?) (assert) (inst + "y!1") (assert))
          ("2" (inst + "y!1"))))
        ("2"
         (expand "nonempty?")
         (expand "empty?")
         (expand "member")
         (inst - "y!1")
         (assert))))
      ("3" (replace -2) (expand "remove") (expand "member") (assert))
      ("4"
       (replace -1)
       (expand "remove")
       (expand "member")
       (expand "dbl")
       (assert)
       (hide -1)
       (hide 3)
       (lemma "epsilon_ax[T]")
       (("1"
         (assert)
         (hide -1)
         (hide 3)
         (rewrite "choose_is_epsilon[T]")
         (("1"
           (lemma "epsilon_ax[T]")
           (inst?)
           (assert)
           (inst + "x!1")
           (assert))
          ("2"
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (inst - "x!1")
           (assert))))
        ("2" (inst?))))))
    ("2" (hide 3) (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: doubletons
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "dbl[T](x!1, y!1) = add(x!1,singleton(y!1))")
   (("1" (hide -1) (rewrite "finite_add"))
    ("2" (hide 2) (apply-extensionality :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: doubletons
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case-replace "dbl(x!1, y!1) = add(x!1,singleton(y!1))")
   (("1"
     (hide -1)
     (rewrite "card_add")
     (rewrite "card_singleton")
     (expand "singleton")
     (assert))
    ("2" (hide 3) (apply-extensionality 1 :hide? t) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "e!1")
   (skosimp*)
   (replace -1)
   (hide -1)
   (lemma "dbl_to_pair_lem")
   (inst?)
   (assert)
   (prop)
   (("1"
     (hide -1)
     (expand "dbl" -1)
     (prop)
     (("1"
       (inst 2 "y!1")
       (assert)
       (typepred "G!1")
       (inst?)
       (("1" (assert) (inst -1 "y!1") (expand "dbl") (propax))
        ("2" (inst?) (assert))))
      ("2"
       (replace -1)
       (hide -1)
       (inst?)
       (typepred "G!1")
       (inst?)
       (("1" (assert) (inst?) (expand "dbl") (propax))
        ("2"
         (inst?)
         (assert)
         (hide -1 3)
         (apply-extensionality :hide? t)
         (grind))))))
    ("2"
     (hide -1)
     (expand "dbl" -1)
     (split)
     (("1"
       (replace -1)
       (hide -1)
       (inst 2 "y!1")
       (assert)
       (typepred "G!1")
       (inst?)
       (("1" (assert) (inst?) (expand "dbl") (propax))
        ("2" (inst?) (assert))))
      ("2"
       (replace -1)
       (hide -1)
       (inst 2 "x!2")
       (assert)
       (typepred "G!1")
       (inst?)
       (("1" (assert) (inst?) (expand "dbl") (propax))
        ("2" (inst?) (assert))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "e!1")
   (skosimp*)
   (replace -1)
   (hide -1)
   (expand "dbl" -1)
   (prop)
   (("1"
     (replace -1)
     (hide -1)
     (inst 2 "y!1")
     (typepred "G!1")
     (inst?)
     (("1"
       (assert)
       (inst -1 "y!1")
       (expand "dbl" -1)
       (assert)
       (hide -1 -2)
       (apply-extensionality 2 :hide? t)
       (grind))
      ("2" (inst?) (assert) (apply-extensionality 1 :hide? t) (grind))))
    ("2"
     (replace -1)
     (hide -1)
     (inst 2 "x!1")
     (typepred "G!1")
     (inst?)
     (("1" (assert) (inst -1 "x!1") (assert) (expand "dbl") (propax))
      ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "e!1")
   (skosimp*)
   (replace -1)
   (hide -1)
   (apply-extensionality 3 :hide? t)
   (expand "dbl")
   (iff)
   (ground))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "G!1")
   (inst?)
   (assert)
   (replace -2)
   (hide -2)
   (inst-cp -1 "x!1")
   (expand "dbl")
   (assert)
   (inst -1 "y!1"))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: Few TCC
script:
  (""
   (skosimp*)
   (typepred "G!1")
   (inst -1 "dbl[T](x!1, y!1)")
   (("1"
     (expand "edge?")
     (prop)
     (("1" (inst -1 "x!1") (expand "dbl") (propax))
      ("2" (inst -1 "y!1") (expand "dbl") (propax))))
    ("2" (expand "edge?") (inst 1 "x!1" "y!1") (prop))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "empty?")
   (apply-extensionality 1 :hide? t)
   (expand "emptyset")
   (expand "empty?")
   (typepred "x!1")
   (skosimp*)
   (inst -3 "y!1")
   (expand "member")
   (typepred "G!1")
   (inst?)
   (assert)
   (inst -1 "y!1")
   (replace -2)
   (expand "dbl")
   (propax))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "singleton?")
   (expand "size")
   (lemma "card_one[T]")
   (inst?)
   (assert)
   (hide -2)
   (skosimp*)
   (expand "empty?")
   (skosimp*)
   (expand "member")
   (typepred "x!2")
   (skosimp*)
   (replace -1)
   (hide -1)
   (typepred "G!1")
   (inst?)
   (("1"
     (assert)
     (inst-cp -1 "x!3")
     (inst -1 "y!1")
     (expand "dbl")
     (hide -4)
     (replace -3)
     (hide -3)
     (expand "singleton")
     (assert))
    ("2" (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "e!1")
   (skosimp*)
   (replace -1)
   (hide -1)
   (typepred "G!1")
   (assert)
   (inst?)
   (("1"
     (assert)
     (hide -2)
     (inst-cp -1 "x!1")
     (inst -1 "y!1")
     (expand "dbl")
     (case "subset?(add(x!1,singleton(y!1)),vert(G!1))")
     (("1"
       (lemma "card_subset[T]")
       (inst?)
       (("1"
         (rewrite "card_add")
         (("1"
           (rewrite "card_singleton")
           (assert)
           (hide -2)
           (expand "singleton")
           (assert))
          ("2" (hide -1) (rewrite "finite_singleton"))))
        ("2" (rewrite "finite_add") (rewrite "finite_singleton"))))
      ("2" (hide 3) (grind))))
    ("2" (inst?) (assert))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: graphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1" (skosimp*) (expand "emptyset") (propax))
    ("2"
     (expand "singleton?")
     (expand "size")
     (rewrite "card_singleton"))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "verts_in?")
   (skosimp*)
   (inst?)
   (("1"
     (typepred "i!2")
     (expand* "^" min empty_seq)
     (expand "empty_seq")
     (lift-if)
     (ground)
     (typepred "i!2")
     (expand* "^" min empty_seq)
     (typepred "j!1")
     (reveal -1)
     (inst?))
    ("2"
     (typepred "i!1")
     (typepred "i!2")
     (expand* "^" min empty_seq)
     (lift-if)
     (expand "empty_seq")
     (ground))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk_from?")
   (flatten)
   (expand "walk?")
   (flatten)
   (expand "verts_in?")
   (inst-cp -3 "0")
   (inst -3 "length(w!1)-1")
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (flatten)
   (split 1)
   (("1"
     (hide -2)
     (expand "verts_in?")
     (skosimp*)
     (inst?)
     (expand "verts_of")
     (hide -2)
     (expand "subset?")
     (expand "member")
     (inst?)
     (split -2)
     (("1" (propax)) ("2" (inst?) (expand "finseq_appl") (propax))))
    ("2"
     (skosimp*)
     (hide -5)
     (expand "subset?")
     (expand "member")
     (inst?)
     (assert)
     (expand "edge?")
     (flatten)
     (inst?)
     (("1" (expand "edges_of") (split -4) (("1" (assert)) ("2" (inst?))))
      ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (expand "gen_seq2")
   (split 2)
   (("1" (expand "verts_in?") (propax))
    ("2"
     (skosimp*)
     (expand "finseq_appl")
     (assert)
     (expand "edge?")
     (expand "edg")
     (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (flatten)
   (split +)
   (("1"
     (hide -2)
     (expand "verts_in?")
     (skosimp*)
     (typepred "i!1")
     (expand "rev")
     (inst?)
     (assert))
    ("2"
     (skosimp*)
     (expand "finseq_appl")
     (expand "edge?")
     (hide -2)
     (expand "rev")
     (inst - "length(ps!1) - 2 - n!1")
     (("1" (assert) (flatten) (assert) (rewrite "dbl_comm"))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk_from?")
   (flatten)
   (inst 1
    "(# length := length(w1!1),
           seq := (LAMBDA (i: below(length(w1!1))): w1!1`seq(length(w1!1)-1-i)) #)")
   (("1" (assert))
    ("2"
     (expand "walk?")
     (split)
     (("1"
       (assert)
       (expand "verts_in?")
       (skosimp*)
       (typepred "w1!1")
       (inst?))
      ("2"
       (skosimp*)
       (expand "finseq_appl")
       (lemma "edge?_comm")
       (inst?)
       (("1" (assert) (hide 2) (typepred "w1!1") (inst?) (assert))
        ("2" (assert)) ("3" (hide 2) (typepred "n!1") (assert))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (flatten)
   (split +)
   (("1" (rewrite "verts_in?_caret"))
    ("2"
     (skosimp*)
     (expand "finseq_appl")
     (expand "edge?")
     (expand* "^" min empty_seq)
     (assert)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk_from?")
   (flatten)
   (expand "o ")
   (assert)
   (auto-rewrite "finseq_appl")
   (expand "walk?")
   (assert)
   (flatten)
   (assert)
   (split +)
   (("1"
     (expand "verts_in?")
     (skosimp*)
     (hide -4)
     (ground)
     (("1" (inst?)) ("2" (hide -3) (inst?))))
    ("2"
     (skosimp*)
     (case "n!1 < length(w1!1)")
     (("1" (assert) (lift-if) (inst?) (ground))
      ("2" (assert) (hide -5) (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk_from?")
   (flatten)
   (assert)
   (expand "o ")
   (expand "rev")
   (expand* "^" min empty_seq)
   (expand "walk?")
   (expand "finseq_appl")
   (flatten)
   (split +)
   (("1"
     (expand "verts_in?")
     (skosimp*)
     (ground)
     (("1" (inst?))
      ("2"
       (hide -2 -3 -4 -5 -6 -7 -9)
       (inst - "length(w1!1) + length(w2!1) - 2 - i!1"))))
    ("2"
     (skosimp*)
     (expand "edge?")
     (case "n!1 < length(w1!1) - 1")
     (("1"
       (assert)
       (inst?)
       (assert)
       (flatten)
       (assert)
       (case "n!1 = length(w1!1) - 1")
       (("1" (replace -1) (hide -1) (assert)) ("2" (lift-if) (assert))))
      ("2"
       (assert)
       (hide -6)
       (inst - "length(w1!1) + length(w2!1) - 3 - n!1")
       (assert)
       (flatten)
       (assert)
       (rewrite "dbl_comm"))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk_from?")
   (flatten)
   (expand "walk?")
   (expand "finseq_appl")
   (expand "o ")
   (expand* "^" min empty_seq)
   (split 1)
   (("1" (propax))
    ("2"
     (flatten)
     (lift-if)
     (split 1)
     (("1" (flatten) (expand "verts_in?") (hide -7) (inst?) (ground))
      ("2" (flatten) (assert))))
    ("3"
     (flatten)
     (expand "verts_in?")
     (skosimp*)
     (hide -6)
     (split 1)
     (("1" (flatten) (inst?))
      ("2"
       (assert)
       (flatten)
       (assert)
       (typepred "i!2")
       (lift-if)
       (ground)
       (inst?))))
    ("4"
     (skosimp*)
     (lift-if)
     (split 1)
     (("1"
       (flatten)
       (ground)
       (("1" (inst?) (assert)) ("2" (inst?) (assert))
        ("3"
         (assert)
         (inst?)
         (assert)
         (case "n!1 = i!1")
         (("1"
           (replace -1)
           (hide -1)
           (assert)
           (replace -4)
           (reveal -2)
           (inst -1 "j!1")
           (assert))
          ("2" (assert))))))
      ("2" (flatten) (ground) (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "length(p2!1) = 1")
   (("1"
     (inst 1 "rev(p1!1)")
     (("1"
       (expand "walk_from?")
       (flatten)
       (expand "rev")
       (assert)
       (lemma "walk?_rev")
       (inst?)
       (assert)
       (expand "rev")
       (propax))
      ("2" (expand "rev") (assert))))
    ("2"
     (inst + "trunc1(p2!1) o rev(p1!1)")
     (("1"
       (expand "walk_from?")
       (expand "o ")
       (expand "trunc1")
       (expand "rev")
       (expand* "^" min empty_seq)
       (assert)
       (flatten)
       (assert)
       (expand "walk?")
       (split +)
       (("1"
         (expand "verts_in?")
         (skosimp*)
         (assert)
         (typepred "i!1")
         (hide -5 -9)
         (hide -2 -3 -5 -6)
         (ground)
         (("1" (hide -3) (inst?)) ("2" (inst?))))
        ("2"
         (skosimp*)
         (expand "finseq_appl")
         (lift-if)
         (ground)
         (("1"
           (expand "edge?")
           (inst -10 "n!1")
           (assert)
           (flatten)
           (assert)
           (lift-if)
           (assert))
          ("2"
           (expand "edge?")
           (inst -5 "length(p1!1) + length(p2!1) - 3 - n!1")
           (assert)
           (flatten)
           (assert)
           (rewrite "dbl_comm"))))))
      ("2"
       (expand "o ")
       (expand "rev")
       (expand "trunc1")
       (expand* "^" min empty_seq)
       (expand "empty_seq")
       (assert))
      ("3" (assert))))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "surjection_from_finite_set[below(length(ww!1)),T]")
   (inst?)
   (inst -1 "fullset[below(length(ww!1))]")
   (("1"
     (assert)
     (hide 2)
     (inst 1 "(LAMBDA (i: below(length(ww!1))): ww!1`seq(i))")
     (("1"
       (expand "restrict")
       (expand "surjective?")
       (skosimp*)
       (typepred "y!1")
       (skosimp*)
       (inst?)
       (("1" (assert) (expand "finseq_appl") (propax))
        ("2" (expand "fullset") (propax))))
      ("2" (skosimp*) (inst?) (expand "finseq_appl") (propax))
      ("3" (skosimp*) (inst?) (expand "finseq_appl") (propax))))
    ("2"
     (hide 2)
     (expand "is_finite")
     (inst 1 "length(ww!1)" "(LAMBDA (ii: below(length(ww!1))): ii)")
     (expand "injective?")
     (expand "restrict")
     (skosimp*))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "is_finite")
   (inst 1 "length(ww!1) - 1"
    "(LAMBDA (e: {e: doubleton[T] |
               EXISTS (i: below(length(ww!1) - 1)):
                 e = dbl[T](finseq_appl[T](ww!1)(i), finseq_appl[T](ww!1)(i + 1))}):
            choose({i: below(length(ww!1) - 1) |
                       e = dbl[T](finseq_appl[T](ww!1)(i), finseq_appl[T](ww!1)(i + 1))}))")
   (("1" (expand "injective?") (skosimp*) (assert))
    ("2"
     (skosimp*)
     (expand "nonempty?")
     (expand "empty?")
     (expand "member")
     (expand "finseq_appl")
     (typepred "ww!1")
     (typepred "e!1")
     (skosimp*)
     (inst -4 "i!1")
     (expand "finseq_appl")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "verts_in?")
   (expand* "^" min empty_seq)
   (expand "empty_seq")
   (lift-if)
   (ground))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "edg")
   (typepred "G!1")
   (inst?)
   (("1" (assert) (inst?) (hide -2) (expand "dbl") (propax))
    ("2" (inst?) (assert))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: walks
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "G!1")
   (inst?)
   (("1" (assert) (inst -1 "v!1") (expand "edg") (expand "dbl") (propax))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path?")
   (expand "finseq_appl")
   (flatten)
   (split 1)
   (("1"
     (expand "walk?")
     (split 1)
     (("1"
       (flatten)
       (hide -4 -5)
       (expand "verts_in?")
       (skosimp*)
       (typepred "i!2")
       (("1" (expand* "^" min empty_seq) (lift-if) (assert) (inst?))
        ("2" (skosimp*))))
      ("2"
       (skosimp*)
       (hide -6)
       (expand "finseq_appl")
       (expand "edge?")
       (inst - "n!1+i!1")
       (expand* "^" min empty_seq)
       (assert))))
    ("2"
     (skosimp*)
     (expand* "^" min empty_seq)
     (assert)
     (inst - "i!1+i!2" "i!1+j!2")
     (("1" (assert))
      ("2"
       (typepred "i!2")
       (typepred "j!2")
       (expand* "^" min empty_seq)
       (assert))
      ("3"
       (typepred "i!2")
       (typepred "i!1")
       (expand* "^" min empty_seq)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path_from?")
   (flatten)
   (rewrite "path?_caret")
   (expand "from?")
   (expand* "^" min empty_seq)
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path?")
   (flatten)
   (rewrite "walk?_rev")
   (assert)
   (skosimp*)
   (expand "finseq_appl")
   (typepred "i!1")
   (typepred "j!1")
   (expand "rev")
   (inst?)
   (("1"
     (inst - "length(ps!1) - 1 - j!1")
     (("1" (assert)) ("2" (assert))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "gen_seq2")
   (expand "path?")
   (expand "finseq_appl")
   (split +)
   (("1"
     (expand "walk?")
     (split +)
     (("1" (expand "verts_in?") (propax))
      ("2" (skosimp*) (expand "finseq_appl") (lift-if) (ground))))
    ("2" (skosimp*) (expand "edge?") (flatten) (lift-if) (ground))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "path?")
   (expand "finseq_appl")
   (flatten)
   (split +)
   (("1" (rewrite "walk?_add1"))
    ("2"
     (skosimp*)
     (expand "add1")
     (lift-if)
     (lift-if)
     (expand "verts_of")
     (typepred "i!1")
     (typepred "j!1")
     (expand "add1")
     (expand "finseq_appl")
     (ground)
     (("1" (inst - "i!1" "j!1") (assert)) ("2" (inst + "i!1"))
      ("3" (inst + "j!1") (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path_from?")
   (split 1)
   (("1"
     (expand "trunc1")
     (lemma "path?_caret")
     (inst?)
     (("1" (assert)) ("2" (assert))))
    ("2"
     (expand "from?")
     (expand "trunc1")
     (expand* "^" min empty_seq)
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "subgraph")
   (apply-extensionality 1 :hide? t)
   (expand "subset?")
   (inst?)
   (expand "member")
   (iff 1)
   (ground))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "finite_subset[doubleton[T]]")
   (inst?)
   (assert)
   (inst - "edges(G!1)")
   (assert)
   (hide 2)
   (grind))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (split +)
   (("1"
     (skosimp*)
     (typepred "G!1")
     (inst?)
     (assert)
     (inst?)
     (inst?)
     (assert))
    ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "num_edges")
   (case-replace "edges(del_edge(G!1,e!1)) = remove(e!1,edges(G!1))")
   (("1" (rewrite "card_remove[doubleton[T]]"))
    ("2"
     (hide 2)
     (apply-extensionality :hide? t)
     (iff 1)
     (prop)
     (("1"
       (lemma "del_edge_lem2")
       (inst?)
       (lemma "del_edge_lem")
       (inst?)
       (expand "member")
       (assert)
       (grind :exclude ("edges" "del_edge")))
      ("2"
       (rewrite "del_edge_lem3")
       (("1" (hide 2) (grind :exclude "edges"))
        ("2" (hide 2) (grind :exclude "edges"))))))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: graph_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "union")
   (expand "member")
   (flatten)
   (prop)
   (("1" (typepred "G1!1") (inst?) (assert) (inst?) (assert))
    ("2" (typepred "G2!1") (inst?) (assert) (inst?) (assert))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: graph_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "finite_subset[doubleton[T]]")
   (inst?)
   (inst - "edges(G!1)")
   (assert)
   (hide 2)
   (grind))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: graph_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "remove")
   (flatten)
   (expand "member")
   (typepred "G!1")
   (inst?)
   (assert)
   (inst?)
   (assert))


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


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (case-replace
    "incident_edges(y!1, del_edge(G!1,e!1)) =
                         remove(e!1,incident_edges(y!1, G!1))")
   (("1"
     (rewrite "card_remove[doubleton[T]]")
     (lift-if)
     (ground)
     (hide -1 2)
     (hide -2)
     (grind))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (iff 1)
     (prop)
     (("1"
       (expand "incident_edges")
       (ground)
       (expand "remove")
       (expand "member")
       (ground)
       (("1"
         (replace -1)
         (hide -1)
         (lemma "del_edge_lem[T]")
         (inst?)
         (expand "member")
         (propax))
        ("2" (lemma "del_edge_lem2[T]") (inst?) (assert))))
      ("2"
       (expand "incident_edges")
       (expand "remove")
       (flatten)
       (expand "member")
       (ground)
       (rewrite "del_edge_lem3"))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deg_del_edge")
   (inst?)
   (typepred "e!1")
   (skosimp*)
   (case "x!1=y!1")
   (("1"
     (replace -1)
     (hide -1)
     (inst -2 "y!2")
     (split -2)
     (("1" (propax))
      ("2"
       (replace -1)
       (hide -1)
       (hide -1 -2 3)
       (expand "dbl")
       (apply-extensionality :hide? t)
       (iff 1)
       (ground))
      ("3" (propax))))
    ("2"
     (case "y!2 = y!1")
     (("1" (replace -1) (hide -1) (inst -2 "x!1") (assert))
      ("2"
       (hide -2 -4 4)
       (replace -1)
       (hide -1)
       (expand "dbl")
       (ground))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (case "incident_edges(y!1, G!1) = incident_edges(y!1, del_edge(G!1, e!1))")
   (("1" (assert))
    ("2"
     (hide 3)
     (apply-extensionality 1 :hide? t)
     (expand "incident_edges")
     (iff 1)
     (ground)
     (("1" (lemma "del_edge_lem3[T]") (inst?) (assert))
      ("2" (lemma "del_edge_lem2[T]") (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "e!1(y!1)")
   (("1"
     (lemma "deg_del_edge2")
     (inst?)
     (assert)
     (lemma "del_edge_lem5[T]")
     (inst?)
     (assert))
    ("2" (lemma "deg_del_edge3") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (rewrite "nonempty_card[doubleton[T]]" :dir rl)
   (expand "nonempty?")
   (expand "empty?")
   (expand "incident_edges")
   (skosimp*)
   (expand "member")
   (inst?)
   (flatten)
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "deg_edge_exists")
   (inst?)
   (assert)
   (skosimp*)
   (hide -1 -3)
   (typepred "G!1")
   (inst?)
   (assert)
   (typepred "e!1")
   (skosimp*)
   (inst-cp -2 "x!1")
   (inst -2 "y!1")
   (replace -1)
   (hide -1)
   (hide -3)
   (expand "dbl")
   (expand "size")
   (case "subset?(add[T](x!1,singleton(y!1)),vert(G!1))")
   (("1"
     (lemma "card_subset[T]")
     (inst?)
     (("1"
       (assert)
       (hide -2)
       (lemma "card_add[T]")
       (inst?)
       (lemma "card_singleton[T]")
       (inst?)
       (replace -1)
       (hide -1)
       (expand "singleton")
       (replace -1)
       (hide -1)
       (assert))
      ("2" (rewrite "finite_add[T]"))))
    ("2" (hide 3) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (lemma "card_empty?[doubleton[T]]")
   (inst?)
   (iff)
   (assert)
   (hide -2)
   (expand "incident_edges")
   (expand "empty?")
   (expand "member")
   (apply-extensionality 1 :hide? t)
   (expand "del_vert")
   (inst?)
   (iff 1)
   (ground))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (case-replace
    "incident_edges(v!1, del_vert(G!1, x!1)) =
                 incident_edges(v!1, del_edge(G!1,dbl[T](x!1,v!1)))")
   (("1"
     (hide -1)
     (lemma "deg_del_edge")
     (inst?)
     (("1" (inst -1 "x!1" "v!1") (prop) (expand "deg") (assert))
      ("2" (inst?) (assert))))
    ("2"
     (hide 3)
     (apply-extensionality 1 :hide? t)
     (("1"
       (expand "incident_edges")
       (grind)
       (("1" (hide -3) (replace -2 * rl) (grind))
        ("2"
         (hide -1 -4)
         (lemma "edge_has_2_verts[T]")
         (inst?)
         (inst?)
         (assert))))
      ("2" (inst?) (assert))))
    ("3" (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (case-replace
    "incident_edges(x!1, G!1) = incident_edges(x!1, del_vert(G!1, v!1))")
   (hide 4)
   (apply-extensionality 1 :hide? t)
   (expand "incident_edges")
   (iff 1)
   (prop)
   (("1"
     (lemma "edge_in_del_vert")
     (inst?)
     (assert)
     (lemma "edge_has_2_verts")
     (inst?)
     (inst?)
     (assert))
    ("2" (expand "del_vert") (flatten) (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "singleton?")
   (expand "deg")
   (rewrite "card_is_0[doubleton[T]]")
   (apply-extensionality 1 :hide? t)
   (expand "incident_edges")
   (expand "emptyset")
   (flatten)
   (lemma "edge_in_card_gt_1[T]")
   (inst?)
   (split -1)
   (("1" (assert) (expand "size") (assert)) ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (lemma "card_one[Dbl]")
   (inst?)
   (flatten)
   (assert)
   (hide -2)
   (skosimp*)
   (inst?)
   (assert)
   (case-replace "incident_edges(v!1, G!1)(x!1) = singleton(x!1)(x!1)")
   (("1"
     (hide -2)
     (expand "incident_edges")
     (expand "singleton")
     (flatten)
     (assert))
    ("2" (assert))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: graph_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "finite_subset[doubleton[T]]")
   (inst?)
   (inst -1 "edges(G!1)")
   (assert)
   (hide 2)
   (grind))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg_sum
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "num_edges")
   (rewrite "card_is_0[doubleton[T]]")
   (assert)
   (expand "deg")
   (lemma "finite_emptyset[doubleton[T]]")
   (case-replace
    " (LAMBDA (v: T): card(incident_edges(v, G!1))) =
                           (LAMBDA (v: T): card(emptyset[doubleton[T]]))")
   (("1"
     (hide -1)
     (rewrite "card_emptyset[doubleton[T]]")
     (rewrite "sum_const")
     (assert))
    ("2"
     (hide 2)
     (apply-extensionality 1 :hide? t)
     (("1"
       (lemma "incident_edges_emptyset")
       (inst -1 "G!1" "x!1")
       (assert))
      ("2"
       (skosimp*)
       (rewrite "card_def[doubleton[T]]")
       (lemma "incident_edges_emptyset")
       (inst?)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg_sum
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (rewrite "sum_f_g[T,real,0,+]")
   (hide 2)
   (skosimp*)
   (typepred "x!2")
   (replace -2 * rl)
   (hide -2)
   (expand "deg")
   (case-replace
    "incident_edges(x!2, del_edge(G!1,e!1)) = incident_edges(x!2, G!1)")
   (hide 2)
   (apply-extensionality 1 :hide? t)
   (expand "incident_edges")
   (iff 1)
   (ground)
   (("1" (lemma "del_edge_lem2[T]") (inst?) (assert))
    ("2" (rewrite "del_edge_lem3") (hide -5 -6 2) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg_sum
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "edge_induction")
   (inst -1
    "(LAMBDA G: sum(vert(G), (LAMBDA (v: T): deg(v, G))) = 2 * num_edges(G))")
   (flatten)
   (hide -1)
   (split -1)
   (("1" (inst -1 "G!1"))
    ("2"
     (hide 2)
     (induct "n")
     (("1" (skosimp*) (rewrite "deg_lem0") (assert))
      ("2"
       (skosimp*)
       (name "Eo" "choose(edges(G!2))")
       (("1"
         (inst -2 "del_edge(G!2,Eo)")
         (rewrite "del_edge_num")
         (assert)
         (typepred "Eo")
         (skosimp*)
         (case "member(x!1, remove(y!1, vert(G!2))) AND member(y!1, vert(G!2))
                                                      AND is_finite[T](remove(x!1, remove(y!1, vert(G!2))))
                                                      AND is_finite[T](remove[T](y!1, vert(G!2)))")
         (("1"
           (flatten)
           (name "V_r" "remove(x!1,remove(y!1,vert(G!2)))")
           (replace -1)
           (case-replace
            "sum(vert(G!2), (LAMBDA (v: T): deg(v, G!2))) =
                                                      sum(V_r, (LAMBDA (v: T): deg(v, G!2)))
                                                  + deg(x!1, G!2)
                                                  + deg(y!1, G!2)")
           (("1"
             (hide -1)
             (case-replace
              "deg(x!1, G!2) = deg(x!1, del_edge(G!2,Eo)) + 1")
             (("1"
               (case-replace
                "deg(y!1, G!2) = deg(y!1, del_edge(G!2,Eo)) + 1")
               (("1"
                 (case-replace
                  "sum(V_r, (LAMBDA (v: T): deg(v, G!2))) =
                                                                        sum(V_r, (LAMBDA (v: T): deg(v, del_edge(G!2,Eo))))")
                 (("1"
                   (case-replace
                    "sum(V_r, (LAMBDA (v: T): deg(v, del_edge(G!2,Eo))))
                                                                               = sum(vert(G!2), (LAMBDA (v: T): deg(v, del_edge(G!2,Eo))))
                                                                    - deg(x!1, del_edge(G!2,Eo))
                                                                    - deg(y!1, del_edge(G!2,Eo)) ")
                   (("1" (assert) (rewrite "vert_del_edge") (assert))
                    ("2"
                     (hide -1 -2 -3 -9 -10 -11 -12 -13 2 3)
                     (replace -1 + rl)
                     (rewrite "sum_remove_rew")
                     (rewrite "sum_remove_rew")
                     (assert))))
                  ("2"
                   (hide -1 -2 -11 -12 3)
                   (lemma "deg_lem2")
                   (inst?)
                   (inst -1 "dbl[T](x!1, y!1)")
                   (("1"
                     (assert)
                     (hide -1 -2 -3 -5 -6 2 3)
                     (grind :exclude "edges"))
                    ("2" (inst?) (assert))))))
                ("2"
                 (hide -1 -2 -3 -4 -10 -11 2 3)
                 (lemma "deg_del_edge")
                 (inst?)
                 (inst -1 "x!1")
                 (assert))))
              ("2"
               (hide -1 -2 -3 -8 -9 -10 2 3)
               (lemma "deg_del_edge")
               (inst?)
               (inst -1 "y!1")
               (rewrite "dbl_comm")
               (assert))))
            ("2"
             (hide -4 -5 -8 -9 -10 2 3)
             (replace -1 + rl)
             (rewrite "sum_remove_rew")
             (rewrite "sum_remove_rew")
             (assert))))
          ("2"
           (rewrite "finite_remove")
           (rewrite "finite_remove")
           (assert)
           (expand "member")
           (expand "remove")
           (expand "member")
           (hide -3 -4 -5 3)
           (replace -1)
           (hide -1)
           (typepred "G!2")
           (inst?)
           (("1"
             (assert)
             (inst-cp -1 "x!1")
             (inst -1 "y!1")
             (expand "dbl")
             (assert))
            ("2" (inst?) (assert))))))
        ("2"
         (hide -1 2)
         (expand "nonempty?")
         (lemma "deg_lem0")
         (inst?)
         (split -1)
         (("1"
           (expand "num_edges")
           (lemma "card_empty?[doubleton[T]]")
           (inst?)
           (assert)
           (replace -3)
           (assert))
          ("2"
           (expand "num_edges")
           (lemma "card_empty?[doubleton[T]]")
           (inst?)
           (assert)
           (replace -2)
           (propax))))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg_sum
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (expand "incident_edges")
   (expand "subgraph?")
   (flatten)
   (hide -1 -3)
   (lemma "card_subset[doubletons[T].doubleton]")
   (inst?)
   (("1"
     (assert)
     (hide 2)
     (expand "subset?")
     (skosimp*)
     (expand "member")
     (flatten)
     (inst?)
     (assert))
    ("2"
     (hide -1 2)
     (lemma "finite_subset[doubletons[T].doubleton]")
     (inst?)
     (inst?)
     (assert)
     (hide -1 2)
     (grind))
    ("3"
     (hide -1 2)
     (lemma "finite_subset[doubletons[T].doubleton]")
     (inst?)
     (inst?)
     (assert)
     (hide -1 2)
     (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg_sum
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (induct "S" 1 "finite_set_induction_rest")
   (("1"
     (skosimp*)
     (rewrite "sum_emptyset")
     (rewrite "card_emptyset")
     (hide -1)
     (assert))
    ("2"
     (skosimp*)
     (expand "sum" 1)
     (inst -1 "B!1" "f!1")
     (split -1)
     (("1" (inst -2 "choose(SS!1)") (rewrite "card_rest") (assert))
      ("2"
       (hide 2)
       (skosimp*)
       (inst -1 "t!1")
       (typepred "t!1")
       (grind :exclude "choose"))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_deg_sum
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "sum_gt_bound")
   (inst -1 "2" "vert(G!1)" "LAMBDA (v:T):deg(v,G!1)")
   (bddsimp)
   (("1"
     (lemma "deg_thm")
     (inst -1 "G!1")
     (replace -1 -2)
     (hide -1 -3)
     (grind))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subgraph_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (split 1)
   (("1"
     (flatten)
     (expand "verts_in?")
     (skosimp*)
     (inst?)
     (expand "subgraph?")
     (hide -3)
     (expand "subset?")
     (flatten)
     (hide -2)
     (expand "member")
     (inst?)
     (assert))
    ("2"
     (flatten)
     (skosimp*)
     (hide -3)
     (inst?)
     (assert)
     (expand "subgraph?")
     (expand "subset?")
     (flatten)
     (hide -2)
     (expand "member")
     (expand "edge?")
     (expand "finseq_appl")
     (flatten)
     (assert)
     (inst?)
     (("1" (assert)) ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subgraph_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path?")
   (flatten)
   (split 1)
   (("1" (lemma "walk?_subgraph") (inst?) (inst?) (assert))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: cycles
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: Fewer
script:
  (""
   (skosimp*)
   (lemma "cycle_l_gt_3")
   (inst?)
   (assert)
   (case "walk?(G!1, w!1)")
   (("1"
     (inst 1 "length(w!1)-2")
     (expand "path?")
     (expand "finseq_appl")
     (prop)
     (("1" (rewrite "walk?_caret"))
      ("2"
       (skosimp*)
       (expand "^")
       (typepred "j!1")
       (typepred "i!1")
       (expand* "^" min empty_seq)
       (expand "cycle?")
       (expand "finseq_appl")
       (flatten)
       (inst -7 "i!1" "j!1")
       (bddsimp)
       (install-rewrites "walks[T]")
       (assert))))
    ("2"
     (expand "cycle?")
     (expand "finseq_appl")
     (flatten)
     (expand "pre_circuit?")
     (expand "finseq_appl")
     (flatten))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: cycles
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "cycle?")
   (expand "pre_circuit?")
   (flatten)
   (inst - "1" "(length(w!1) - 2)")
   (("1" (expand "endpoint?") (assert)) ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: cycles
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "cycle?")
   (expand "endpoint?")
   (expand "pre_circuit?")
   (ground)
   (inst - "1" "(length(w!1) - 2)")
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "trunc1")
   (expand "walk?")
   (flatten)
   (prop)
   (("1" (grind))
    ("2"
     (skosimp*)
     (expand "finseq_appl")
     (inst - "n!1")
     (expand* "^" min empty_seq)
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "trunc1")
   (skosimp*)
   (expand "reduced?" 2)
   (expand "reducible?" -)
   (skolem! -8)
   (case "k!1 < length(u!1)-1")
   (("1"
     (hide -3)
     (expand "reduced?" -5)
     (expand "reducible?" 1)
     (inst 1 "k!1")
     (assert)
     (expand "finseq_appl")
     (grind))
    ("2"
     (hide -1)
     (case "k!1 >length(u!1) -1")
     (("1"
       (expand "reduced?" -6)
       (expand "reducible?" 2)
       (inst 2 "k!1 - length(u!1) +1")
       (("1" (assert) (expand "finseq_appl") (grind)) ("2" (grind))))
      ("2" (hide -1) (assert) (expand "finseq_appl") (grind))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (flatten)
   (extensionality "prewalk")
   (inst -1 "p!1" "q!1")
   (assert)
   (grind)
   (extensionality "[below[length(p!1)]-> T]")
   (inst -1 "p!1`seq" "q!1`seq")
   (("1" (assert)) ("2" (assert) (skosimp*) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "path_reduc")
   (lemma "path?_rev")
   (lemma "walks_concat_red")
   (lemma "index_rev")
   (inst -1 "q!1")
   (inst -3 "G!1" "q!1")
   (inst-cp -4 "G!1" "p!1")
   (("1"
     (inst -2 "G!1" "p!1" "rev(q!1)")
     (("1"
       (lemma "path_from_l")
       (inst-cp -1 "G!1" "p!1" "s!1" "t!1")
       (inst-cp -1 "G!1" "q!1" "s!1" "t!1")
       (hide -1)
       (hide -6)
       (reveal -1)
       (inst -1 "G!1" "rev(q!1)")
       (("1"
         (expand "path_from?")
         (flatten)
         (expand "from?")
         (expand "finseq_appl")
         (flatten)
         (assert)
         (grind))
        ("2" (grind))))
      ("2" (assert) (grind))))
    ("2" (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "red_compos")
   (skosimp 1)
   (expand "cyclically_reduced?" 4)
   (lemma "index_rev")
   (inst -2 "G!1" "p!1" "q!1" "s!1" "t!1")
   (inst -1 "q!1")
   (lemma "compose_long")
   (inst -1 "p!1" "q!1" "s!1" "t!1")
   (lemma "second_in_cat")
   (lemma "sec_from_last")
   (inst -1 "p!1" "q!1" "s!1" "t!1")
   (inst -2 "p!1" "q!1" "s!1" "t!1")
   (assert)
   (expand "finseq_appl")
   (expand "path_from?" -7)
   (assert)
   (prop)
   (("1" (assert)) ("2" (grind)) ("3" (grind)) ("4" (grind))
    ("5" (grind)) ("6" (grind)) ("7" (grind)) ("8" (grind)) ("9" (grind))
    ("10" (grind)) ("11" (grind)) ("12" (grind)) ("13" (grind))
    ("14" (grind)) ("15" (grind)) ("16" (grind)) ("17" (grind))
    ("18" (grind)) ("19" (grind)) ("20" (grind)) ("21" (grind))
    ("22" (grind)) ("23" (grind)) ("24" (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (expand "circuit?")
   (flatten)
   (split)
   (("1"
     (expand "path_from?")
     (expand "cyclically_reduced?")
     (expand "finseq_appl")
     (lemma "path_reduc")
     (inst -1 "G!1" "p!1")
     (("1"
       (assert)
       (expand "path?")
       (expand "finseq_appl")
       (flatten)
       (inst -6 "1" "length(p!1)-2")
       (assert)
       (bddsimp)
       (("1"
         (expand "walk?")
         (expand "finseq_appl")
         (flatten)
         (inst -7 "1")
         (assert)
         (expand "edge?" -7)
         (expand "from?" -9)
         (hide -2 -3 -6)
         (flatten)
         (hide -4)
         (expand "reduced?" -1)
         (expand "reducible?" 1)
         (expand "finseq_appl")
         (inst 1 "1")
         (assert))
        ("2"
         (hide -1 -3 -6)
         (expand "from?" -4)
         (assert)
         (flatten)
         (grind))))
      ("2" (flatten))))
    ("2" (assert) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality 1 :hide? t)
   (("1" (expand "rev") (propax))
    ("2" (lemma "rev_rev") (inst-cp -1 "p!1") (inst -1 "q!1") (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality 2 :hide? t)
   (("1" (hide-all-but (-3 1)) (grind))
    ("2"
     (lemma "l_trunc1")
     (inst-cp -1 "p!1")
     (inst - "q!1")
     (lemma "front_back")
     (expand "finseq_appl")
     (inst -1 "p!1" "q!1" "s!1" "t!1")
     (lemma "walk_from_l")
     (expand "trunc1" *)
     (inst-cp -1 "p!1" "s!1" "t!1")
     (inst -1 "q!1" "s!1" "t!1")
     (assert)
     (apply-extensionality 1 :hide? t)
     (flatten)
     (typepred "x!1")
     (expand* "^" min)
     (case-replace
      "(LAMBDA (x: below[min(length(p!1) - 1, p!1`length)]): p!1`seq(x))(x!1) = (LAMBDA (x: below[min(length(q!1) - 1, q!1`length)]): q!1`seq(x))(x!1)")
     (("1" (assert)) ("2" (replace -10) (propax))
      ("3"
       (hide-all-but 1)
       (skosimp)
       (typepred "x!2")
       (expand "min")
       (assert))
      ("4" (hide-all-but (-2 1)) (expand "min") (assert))
      ("5" (expand "min") (assert))
      ("6" (hide-all-but (-1 1)) (skosimp) (assert))
      ("7" (hide-all-but (-3 1)) (expand "min") (assert))
      ("8"
       (hide-all-but (-1 -5 1 2))
       (case-replace "x!1 = length(p!1) - 1")
       (("1" (assert)) ("2" (hide (-2 3)) (expand "min") (assert))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "walk_concat")
   (lemma "walk_from_l")
   (inst -1 "p!1" "s!1" "t!1")
   (inst -2 "G!1" "s!1" "s!1" "t!1" "p!1" "q!1")
   (expand "pre_circuit?" +)
   (expand "walk_from?" -)
   (assert)
   (expand "from?")
   (expand "trunc1")
   (expand "finseq_appl")
   (assert)
   (bddsimp)
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (inst 3 "p!1^(0,length(p!1)-2)" "q!1^(0,length(q!1)-2)")
   (("1"
     (lemma "plus_up")
     (inst -1 "p!1" "q!1" "s!1" "t!1")
     (lemma "path?_trunc1")
     (inst-cp -1 "G!1" "p!1")
     (inst -1 "G!1" "q!1")
     (lemma "walk_from_l")
     (inst-cp -1 "p!1" "s!1" "t!1")
     (inst -1 "q!1" "s!1" "t!1")
     (expand "path_from?")
     (expand "trunc1")
     (assert)
     (flatten)
     (assert)
     (expand "from?" -6)
     (expand "from?" -8)
     (expand "finseq_appl")
     (assert)
     (flatten)
     (bddsimp)
     (("1" (assert) (grind)) ("2" (assert) (grind)) ("3" (grind))
      ("4" (grind))))
    ("2" (grind)) ("3" (grind)) ("4" (grind)) ("5" (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (inst 3 "(rev(p!1))^(0,length(p!1)-2)" "(rev(q!1))^(0,length(q!1)-2)")
   (("1"
     (lemma "plus_up")
     (inst -1 "rev(p!1)" "rev(q!1)" "t!1" "s!1")
     (("1"
       (lemma "path?_trunc1")
       (inst-cp -1 "G!1" "rev(p!1)")
       (("1"
         (inst -1 "G!1" "rev(q!1)")
         (("1"
           (lemma "walk_from_l")
           (inst-cp -1 "p!1" "s!1" "t!1")
           (inst -1 "q!1" "s!1" "t!1")
           (expand "path_from?")
           (expand "trunc1")
           (assert)
           (flatten)
           (assert)
           (lemma "ind_rev_rev")
           (inst-cp -1 "p!1")
           (inst -1 "q!1")
           (lemma "index_rev")
           (inst-cp -1 "p!1")
           (inst -1 "q!1")
           (assert)
           (flatten)
           (expand "from?" -17)
           (expand "from?" -19)
           (lemma "path?_rev")
           (inst-cp -1 "G!1" "p!1")
           (inst -1 "G!1" "q!1")
           (lemma "rev_eq")
           (inst -1 "p!1" "q!1")
           (assert)
           (lemma "from_rev")
           (assert)
           (inst-cp -1 "p!1" "s!1" "t!1")
           (inst -1 "q!1" "s!1" "t!1")
           (assert)
           (expand "finseq_appl")
           (assert)
           (hide -1 -2 -3 -4)
           (hide -15 -17)
           (bddsimp)
           (("1" (assert) (grind)) ("2" (assert) (grind)) ("3" (assert))
            ("4" (assert)) ("5" (grind)) ("6" (grind))))
          ("2" (assert) (grind))))
        ("2" (grind))))
      ("2" (grind)) ("3" (grind))))
    ("2" (grind)) ("3" (grind)) ("4" (grind)) ("5" (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (install-rewrites "walks[T]")
   (assert)
   (grind)
   (apply-extensionality 2 :hide? t)
   (("1"
     (install-rewrites "walks[T]")
     (lift-if 1)
     (case "x!2<length(w!1)")
     (("1"
       (prop)
       (case "x!2<length(w!1)-1")
       (("1" (assert)) ("2" (lift-if 2) (assert))))
      ("2" (assert))))
    ("2" (skosimp*) (assert))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: path_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "trunc_long")
   (lemma "verts_in?_concat")
   (lemma "trunc_walk")
   (skosimp*)
   (inst -3 "u!1" "w!1")
   (inst -2 "G!1" "trunc1(u!1)" "w!1")
   (("1" (inst -1 "G!1" "u!1") (grind)) ("2" (grind)) ("3" (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subgraphs_from_walk
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "G_from")
   (expand "edge?")
   (typepred "w!1")
   (expand "walk?")
   (flatten)
   (inst?)
   (assert)
   (expand "edge?")
   (flatten)
   (assert)
   (expand "edges_of")
   (inst?))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subgraphs_from_walk
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "G_from")
   (typepred "w!1")
   (expand "walk?")
   (flatten)
   (inst - "i!1")
   (assert)
   (expand "edge?")
   (rewrite "dbl_comm")
   (ground)
   (expand "edges_of")
   (inst?)
   (rewrite "dbl_comm"))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subgraphs_from_walk
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (auto-rewrite-theory "sets")
   (expand "subgraph?")
   (prop)
   (("1" (hide -2) (expand "del_vert") (rewrite "vert_G_from_not"))
    ("2"
     (lemma "vert_G_from_not")
     (inst?)
     (inst?)
     (assert)
     (skosimp*)
     (rewrite "edge_in_del_vert")
     (("1" (hide -1 -3 2 3) (inst?) (assert))
      ("2"
       (hide -2 -4 -5 1)
       (expand "G_from")
       (expand "verts_of")
       (expand "edges_of")
       (skosimp*)
       (replace -2)
       (hide -2)
       (expand "dbl")
       (split -1)
       (("1" (inst?) (assert)) ("2" (inst?) (assert))))))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: subgraphs_from_walk
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (typepred "w!1")
   (split +)
   (("1"
     (skosimp*)
     (expand "walk?")
     (flatten)
     (expand "verts_of")
     (expand "verts_in?")
     (expand "finseq_appl")
     (hide -4)
     (expand "edges_of")
     (skosimp*)
     (replace -1)
     (hide -1)
     (expand "finseq_appl")
     (expand "dbl")
     (split -1)
     (("1" (replace -1) (hide -1) (inst?))
      ("2" (inst?) (inst?) (assert))))
    ("2"
     (expand "subgraph?")
     (expand "walk?")
     (flatten)
     (expand "subset?")
     (expand "member")
     (expand "verts_of")
     (expand "edges_of")
     (expand "finseq_appl")
     (split +)
     (("1" (skosimp*) (expand "verts_in?") (inst?) (assert))
      ("2" (skosimp*) (expand "edge?") (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: circuit_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: Did not use e_duo
script:
  (""
   (skosimp*)
   (expand "edge?")
   (flatten)
   (expand "deg")
   (case " card(incident_edges(z!1, G!1)) =0")
   (("1"
     (lemma "finite_sets[doubleton[T]].card_empty?")
     (inst?)
     (iff)
     (bddsimp)
     (expand "empty?")
     (inst -2 "dbl[T](a!1, z!1)")
     (expand "member")
     (hide -1 -4 5)
     (install-rewrites "graphs[T]")
     (assert))
    ("2"
     (case " card(incident_edges(z!1, G!1)) =1")
     (("1"
       (lemma "finite_sets[doubleton[T]].card_one")
       (inst?)
       (bddsimp)
       (skosimp*)
       (hide -1 1 5)
       (install-rewrites "graphs[T]")
       (assert)
       (grind)
       (expand "incident_edges")
       (expand "singleton")
       (decompose-equality -1)
       (copy -1)
       (inst -1 "dbl[T](a!1, z!1)")
       (inst -2 "dbl[T](b!1, z!1)")
       (bddsimp)
       (("1"
         (install-rewrites "doubletons[T]")
         (assert)
         (replace -3 -6 rl)
         (hide -1 -3 -4)
         (grind)
         (lemma "doubletons[T].dbl_eq")
         (inst -1 "a!1" "b!1" "z!1" "z!1")
         (prop)
         (assert))
        ("2" (install-rewrites "doubletons[T]") (assert)) ("3" (assert))
        ("4" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: circuit_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: Update from cir_deg_G
script:
  (""
   (skosimp*)
   (lemma " cir_deg_G")
   (inst -1 "G_from(G!1,w!1)" "w!1`seq(i!1)")
   (expand "finseq_appl")
   (bddsimp)
   (hide 2)
   (typepred "i!1")
   (expand "circuit?")
   (expand "cyclically_reduced?")
   (expand "finseq_appl")
   (flatten)
   (case "i!1=length(w!1)-1")
   (("1"
     (expand "pre_circuit?")
     (expand "finseq_appl")
     (inst 1 "w!1(1)" "w!1(length(w!1)-2)")
     (("1"
       (expand "finseq_appl")
       (prop)
       (("1"
         (hide -4)
         (install-rewrites "walks[T]")
         (assert)
         (inst 1 "i!1"))
        ("2"
         (replace -1 1 lr)
         (replace -5 * rl)
         (hide -4)
         (install-rewrites "walks[T]")
         (assert)
         (prop)
         (("1"
           (typepred "w!1")
           (expand "walk?")
           (expand "finseq_appl")
           (prop)
           (inst -3 "0")
           (assert))
          ("2"
           (inst 1 "0")
           (assert)
           (expand "dbl")
           (ground)
           (grind)
           (apply-extensionality 1 :hide? t)
           (iff)
           (grind))))
        ("3"
         (replace -1 1 lr)
         (hide -4)
         (typepred "w!1")
         (expand "walk?")
         (expand "finseq_appl")
         (flatten)
         (inst -3 "length(w!1)-2")
         (("1"
           (assert)
           (install-rewrites "walks[T]")
           (assert)
           (flatten)
           (bddsimp)
           (inst 2 "length(w!1)-2")
           (assert))
          ("2" (assert))))))
      ("2"
       (expand "finseq_appl")
       (assert)
       (install-rewrites "walks[T]")
       (assert)
       (inst 1 "length(w!1)-2"))
      ("3" (assert))
      ("4" (install-rewrites "walks[T]") (assert) (inst 1 "1"))))
    ("2"
     (case "i!1=0")
     (("1"
       (replace -1 + lr)
       (inst 2 " w!1`seq(1)" "w!1`seq(length(w!1) - 2)")
       (("1"
         (prop)
         (("1"
           (hide -4 -5)
           (typepred "w!1")
           (install-rewrites "walks[T]")
           (assert)
           (inst 1 "0"))
          ("2"
           (hide -4 -5)
           (typepred "w!1")
           (install-rewrites "walks[T]")
           (assert)
           (prop)
           (("1" (inst -4 "0") (prop) (("1" (assert)) ("2" (assert))))
            ("2"
             (inst 1 "0")
             (hide -2 -3)
             (assert)
             (lemma "dbl_comm")
             (inst?))))
          ("3"
           (hide -4)
           (expand "pre_circuit?")
           (expand "finseq_appl")
           (replace -4 1 lr)
           (hide -4)
           (typepred "w!1")
           (install-rewrites "walks[T]")
           (assert)
           (flatten)
           (bddsimp)
           (("1" (assert) (reveal -1) (inst -4 "length(w!1)-2") (assert))
            ("2" (inst 1 "length(w!1)-2") (assert))))))
        ("2"
         (hide -4 -5)
         (install-rewrites "walks[T]")
         (assert)
         (inst 1 "length(w!1)-2"))
        ("3" (assert))
        ("4"
         (hide -4 -5)
         (install-rewrites "walks[T]")
         (assert)
         (inst 1 "1"))))
      ("2"
       (inst 3 "seq(w!1)(i!1-1)" "seq(w!1)(i!1+1)")
       (("1"
         (hide -4)
         (bddsimp)
         (("1"
           (hide -3)
           (install-rewrites "walks[T]")
           (assert)
           (prop)
           (("1"
             (assert)
             (typepred "w!1")
             (assert)
             (flatten)
             (inst -3 "i!1")
             (assert))
            ("2" (inst 1 "i!1") (rewrite "dbl_comm"))))
          ("2"
           (hide -3)
           (typepred "w!1")
           (install-rewrites "walks[T]")
           (assert)
           (bddsimp)
           (("1" (inst -3 "i!1-1") (assert))
            ("2" (inst 3 "i!1-1") (assert))))
          ("3"
           (prop)
           (expand "reduced?")
           (expand "reducible?")
           (expand "finseq_appl")
           (inst 3 "i!1")
           (("1" (assert)) ("2" (assert))))
          ("4"
           (typepred "w!1")
           (install-rewrites "walks[T]")
           (assert)
           (inst 3 "i!1"))))
        ("2"
         (hide -3 -4)
         (typepred "w!1")
         (install-rewrites "walks[T]")
         (assert)
         (flatten)
         (inst 1 "i!1+1")
         (assert))
        ("3" (assert))
        ("4"
         (hide -3 -4)
         (typepred "w!1")
         (install-rewrites "walks[T]")
         (assert)
         (flatten)
         (inst 1 "i!1-1"))
        ("5" (assert))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: circuit_deg
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "circuit?")
   (expand "cyclically_reduced?")
   (expand "pre_circuit?")
   (flatten)
   (typepred "w!1")
   (expand "walk?")
   (flatten)
   (case "subset?(add[T](finseq_appl(w!1)(0), singleton[T](finseq_appl(w!1)(1))),vert(G_from(G!1, w!1)))")
   (("1"
     (lemma "card_subset[T]")
     (inst?)
     (assert)
     (case-replace
      "card(add[T](finseq_appl(w!1)(0), singleton[T](finseq_appl(w!1)(1)))) = 2")
     (("1" (assert))
      ("2"
       (hide -1 -2 -3 -4 -5 -6 -7 -8 2 3)
       (rewrite "card_add")
       (rewrite "card_singleton")
       (lift-if)
       (ground)
       (hide 1)
       (expand "singleton")
       (typepred "w!1")
       (expand "walk?")
       (inst?)
       (assert)
       (expand "edge?")
       (propax))))
    ("2" (hide -1 -2 -3 -5 -6 3) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_inductions
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "graph_induction_vert")
   (inst -1 "(LAMBDA (GG: graph[T]): NOT P!1(GG))")
   (prop)
   (("1" (inst?))
    ("2"
     (skosimp*)
     (inst -3 "G!2")
     (assert)
     (skosimp*)
     (inst -1 "GG!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: trees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "empty?")
   (use "card_empty?[T]")
   (assert)
   (iff)
   (assert)
   (expand "tree?")
   (skosimp*)
   (use "deg_to_card")
   (assert)
   (expand "size")
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: trees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "G" 1 "graph_induction_vert")
   (skosimp*)
   (expand "tree?" -2)
   (bddsimp)
   (("1"
     (lemma "singleton_edges")
     (inst -1 "G!1")
     (expand "singleton?" -1)
     (expand "size" -1)
     (assert)
     (lemma "finite_sets[doubleton[T]].empty_card")
     (inst -1 "edges(G!1)")
     (bddsimp)
     (assert)
     (expand "size" 1)
     (assert))
    ("2"
     (skosimp*)
     (lemma "size_del_vert")
     (inst -1 "G!1" "v!1")
     (inst -2 "del_vert(G!1,v!1)")
     (assert)
     (replace -1 -2)
     (expand "deg" -3)
     (expand "incident_edges" -3)
     (lemma "finite_sets[doubleton[T]].card_one")
     (inst -1 "{e: doubleton[T] | edges(G!1)(e) AND e(v!1)}")
     (("1"
       (flatten)
       (prop)
       (skosimp*)
       (expand "del_vert" -4)
       (lemma "finite_sets[doubleton[T]].card_disj_union")
       (inst -1 "{e: doubleton[T] | edges(G!1)(e) AND e(v!1)}"
        "{e: doubleton[T] | edges(G!1)(e) AND NOT e(v!1)}")
       (("1"
         (prop)
         (("1"
           (lemma "finite_sets[doubleton[T]].card_singleton")
           (inst -1 "x!1")
           (replace -4 -1 rl)
           (replace -1 -2)
           (assert -6)
           (replace -6 -2 rl)
           (expand "union" -2)
           (expand "member" -2)
           (assert -2)
           (hide-all-but -2 -)
           (case "{x: doubleton[T] |
                                                               edges(G!1)(x) AND x(v!1) OR edges(G!1)(x) AND NOT x(v!1)}=edges(G!1)")
           (("1" (replace -1 -2) (assert))
            ("2"
             (hide -1 2)
             (grind)
             (apply-extensionality 1)
             (hide 2)
             (iff 1)
             (prop))))
          ("2"
           (hide -1 -2 -3 -4 -5 2)
           (expand "disjoint?")
           (install-rewrites "finite_sets[doubleton[T]]")
           (hide -1)
           (grind))))
        ("2"
         (lemma "finite_subset[doubleton[T]]")
         (inst - "edges(G!1)"
          "{e: doubleton[T] | edges(G!1)(e) AND NOT e(v!1)}")
         (assert)
         (hide 2)
         (expand "subset?")
         (skosimp*)
         (expand "member")
         (assert))
        ("3"
         (hide-all-but 1)
         (lemma "finite_subset[doubleton[T]]")
         (inst - "edges(G!1)"
          "{e: doubleton[T] | edges(G!1)(e) AND e(v!1)}")
         (assert)
         (hide 2)
         (grind))))
      ("2"
       (hide-all-but 1)
       (lemma "finite_subset[doubleton[T]]")
       (inst - "edges(G!1)"
        "{e: doubleton[T] | edges(G!1)(e) AND e(v!1)}")
       (assert)
       (hide 2)
       (grind))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: trees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (inst? -1)
   (inst -1 "size(G!1)-2")
   (("1" (lemma "tree_nonempty") (inst? -1) (bddsimp) (assert 2))
    ("2"
     (expand "size" 1)
     (assert 1)
     (case "card[T](vert(G!1))  > 0")
     (("1" (hide -2 -3 2) (grind))
      ("2"
       (lemma "tree_nonempty")
       (inst? -1)
       (bddsimp)
       (expand "empty?" 1)
       (lemma "finite_sets[T].empty_card")
       (inst -1 "vert(G!1)")
       (bddsimp)
       (hide -1 -2 1 4 5 6)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: trees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "k" 1 "nat_induction")
   (("1"
     (skosimp*)
     (copy -2)
     (expand "size" -1)
     (expand "tree?" -2)
     (case "card[T](vert(G!1)) = 1")
     (("1" (propax))
      ("2"
       (split)
       (("1" (propax))
        ("2"
         (hide -3 1 3)
         (skosimp*)
         (case "v!2=v!1")
         (("1" (replace -1 -2) (assert))
          ("2"
           (lemma "size_del_vert")
           (inst -1 "G!1" "v!2")
           (reveal -2)
           (replace -1 -2)
           (assert -2)
           (expand "size" -2)
           (lemma "finite_sets[T].card_one")
           (inst -1 "vert(del_vert(G!1, v!2))")
           (bddsimp)
           (hide -1 -3 -5)
           (skosimp*)
           (name "HH" "del_vert(G!1, v!2)")
           (replace -1 -2)
           (typepred "HH")
           (expand "del_vert" -2)
           (case "vert(HH)= remove[T](v!2, vert(G!1))")
           (("1"
             (hide -3)
             (expand "deg" -4)
             (lemma "finite_sets[doubleton[T]].card_one")
             (inst -1 "incident_edges(v!2, G!1)")
             (bddsimp)
             (hide -1)
             (skosimp*)
             (expand "incident_edges" -1)
             (replace -2 -4)
             (hide -2 -3 -5)
             (case " ({e: doubleton[T] | edges(G!1)(e) AND e(v!2)})(x!2) = singleton(x!2)(x!2)")
             (("1"
               (hide -2)
               (beta -1)
               (case "singleton(x!2)(x!2)")
               (("1"
                 (iff -2)
                 (bddsimp)
                 (lemma "other_vert")
                 (inst -1 "G!1" "x!2" "v!2")
                 (bddsimp)
                 (skosimp*)
                 (hide -2 -5)
                 (case " ({y: T | v!2 /= y AND member(y, vert(G!1))})(x!1) = singleton(x!1)(x!1)")
                 (("1"
                   (case " ({y: T | v!2 /= y AND member(y, vert(G!1))})(u!1) = singleton(x!1)(u!1)")
                   (("1"
                     (case " ({y: T | v!2 /= y AND member(y, vert(G!1))})(v!1) = singleton(x!1)(v!1)")
                     (("1"
                       (case " ({y: T | v!2 /= y AND member(y, vert(G!1))})(v!2) = singleton(x!1)(v!2)")
                       (("1"
                         (beta -1 -2 -3 -4)
                         (beta -2)
                         (beta -3)
                         (beta -4)
                         (hide -8)
                         (expand "member" -)
                         (expand "singleton" *)
                         (iff *)
                         (bddsimp)
                         (("1"
                           (assert)
                           (replace -3 (-6 -7 -8 1) rl)
                           (hide -3)
                           (replace -5 -9)
                           (reveal -3)
                           (hide -2 -3 -4 -5 -6 -7 2 3)
                           (expand "deg" 2)
                           (lemma
                            "finite_sets[doubleton[T]].nonempty_card")
                           (inst -1 "incident_edges(v!1, G!1)")
                           (bddsimp)
                           (expand "nonempty?" 1)
                           (expand "empty?" -1)
                           (inst -1 "x!2")
                           (hide 2)
                           (expand "member" 1)
                           (grind))
                          ("2" (grind)) ("3" (grind)) ("4" (grind))))
                        ("2"
                         (expand "singleton")
                         (expand "remove")
                         (expand "member")
                         (ground))))
                      ("2"
                       (expand "member")
                       (expand "singleton")
                       (expand "remove")
                       (expand "member")
                       (flatten)
                       (ground)
                       (decompose-equality -6)
                       (inst - "v!1")
                       (ground))))
                    ("2"
                     (hide-all-but -5 -)
                     (name "hh"
                           "({y: T | v!2 /= y AND member(y, vert(G!1))})")
                     (replace -1 1)
                     (grind)
                     (("1"
                       (expand "remove")
                       (expand "member")
                       (expand "singleton")
                       (ground)
                       (replace -1 * rl)
                       (hide -1)
                       (assert)
                       (decompose-equality -2)
                       (inst - "u!1")
                       (assert))
                      ("2"
                       (expand "remove")
                       (expand "member")
                       (expand "singleton")
                       (ground)
                       (replace -1 * rl)
                       (assert)
                       (decompose-equality -3)
                       (inst - "x!1")
                       (assert))))))
                  ("2"
                   (name "hh"
                         "({y: T | v!2 /= y AND member(y, vert(G!1))})")
                   (replace -1 1)
                   (grind)
                   (expand "singleton")
                   (expand "remove")
                   (expand "member")
                   (replace -1 * rl)
                   (assert)
                   (decompose-equality -5)
                   (inst - "u!1")
                   (assert))))
                ("2" (expand "singleton" 1) (propax))))
              ("2"
               (name "bb"
                     "({e: doubleton[T] | edges(G!1)(e) AND e(v!2)})")
               (replace -1 -2)
               (replace -1 1)
               (grind))))
            ("2" (hide-all-but -2 -) (grind))))))))))
    ("2"
     (skosimp*)
     (expand "tree?" -2)
     (bddsimp)
     (copy -3)
     (expand "size" -1)
     (typepred "j!1")
     (skosimp*)
     (case "v!1=v!2")
     (("1" (replace -1 -5 rl) (hide-all-but -5 -) (assert))
      ("2"
       (inst -3 "del_vert[T](G!1, v!2)" "v!1")
       (bddsimp)
       (("1"
         (expand "deg" -4)
         (lemma "finite_sets[doubleton[T]].nonempty_card")
         (inst-cp -1 "incident_edges(v!1, del_vert[T](G!1, v!2))")
         (bddsimp)
         (hide -3)
         (expand "nonempty?" -2)
         (expand "empty?" 1)
         (skosimp*)
         (expand "member" -2)
         (expand "deg" 3)
         (inst -1 "incident_edges(v!1, G!1)")
         (bddsimp)
         (expand "nonempty?" 1)
         (expand "empty?" -1)
         (inst -1 "x!1")
         (expand "member" 1)
         (hide 2)
         (expand "incident_edges" *)
         (expand "del_vert" -1)
         (assert)
         (flatten)
         (hide-all-but (-1 -2) -)
         (assert))
        ("2"
         (lemma "finite_sets[T].card_one")
         (inst -1 "vert(del_vert[T](G!1, v!2))")
         (bddsimp)
         (hide -1)
         (skosimp*)
         (hide -4 -6 2)
         (expand "del_vert" -1)
         (hide -2 -3)
         (expand "deg" -2)
         (lemma "finite_sets[doubleton[T]].card_one")
         (inst -1 "incident_edges(v!2, G!1)")
         (bddsimp)
         (hide -1)
         (skosimp*)
         (expand "incident_edges" *)
         (case " ({e: doubleton[T] | edges(G!1)(e) AND e(v!2)})(x!2) =
                singleton(x!2)(x!2)")
         (("1"
           (beta -1)
           (case "({y: T | v!2 /= y AND vert(G!1)(y)})(x!1) = singleton(x!1)(x!1)")
           (("1"
             (case "({y: T | v!2 /= y AND vert(G!1)(y)})(v!1) = singleton(x!1)(v!1)")
             (("1"
               (case "({y: T | v!2 /= y AND vert(G!1)(y)})(v!2) = singleton(x!1)(v!2)")
               (("1"
                 (hide -5 -6)
                 (beta -1)
                 (beta -2)
                 (beta -3)
                 (assert -1)
                 (expand "singleton" *)
                 (iff -1)
                 (bddsimp)
                 (("1"
                   (lemma "other_vert")
                   (inst -1 "G!1" "x!2" "v!2")
                   (bddsimp)
                   (skosimp*)
                   (reveal -3)
                   (case "({y: T | v!2 /= y AND vert(G!1)(y)})(u!1) = singleton(x!1)(u!1)")
                   (("1"
                     (beta -1)
                     (hide -2)
                     (expand "singleton" *)
                     (iff -1)
                     (bddsimp)
                     (("1"
                       (replace -3 -8 rl)
                       (replace -8 -6 rl)
                       (hide -1 -2 -3 -8 -9 4)
                       (expand "deg" +)
                       (lemma "finite_sets[doubleton[T]].nonempty_card")
                       (inst -1 "incident_edges(v!1, G!1)")
                       (bddsimp)
                       (hide 2)
                       (expand "nonempty?" +)
                       (expand "empty?")
                       (inst -1 "x!2")
                       (expand "member")
                       (expand "incident_edges" +)
                       (assert)
                       (replace -3 1)
                       (grind))
                      ("2" (grind))))
                    ("2"
                     (hide-all-but -1 -)
                     (name "jj" "({y: T | v!2 /= y AND vert(G!1)(y)})")
                     (replace -1 1)
                     (grind)
                     (("1"
                       (expand "remove")
                       (expand "member")
                       (expand "singleton")
                       (replace -1 * rl)
                       (assert)
                       (decompose-equality -3)
                       (inst - "u!1")
                       (assert))
                      ("2"
                       (replace -1 * rl)
                       (assert)
                       (expand "remove")
                       (expand "member")
                       (expand "singleton")
                       (decompose-equality -3)
                       (inst - "u!1")
                       (assert))))))
                  ("2" (grind))))
                ("2"
                 (hide-all-but -5 -)
                 (name "jj" "({y: T | v!2 /= y AND vert(G!1)(y)})")
                 (replace -1 1)
                 (grind)
                 (("1"
                   (expand "remove")
                   (expand "member")
                   (expand "singleton")
                   (replace -1 * rl)
                   (assert))
                  ("2"
                   (replace -1 * rl)
                   (expand "remove")
                   (expand "member")
                   (expand "singleton")
                   (assert)
                   (decompose-equality -3)
                   (inst - "v!2")
                   (assert))))))
              ("2"
               (hide-all-but -4 -)
               (name "jj" "({y: T | v!2 /= y AND vert(G!1)(y)})")
               (replace -1 1)
               (grind)
               (("1"
                 (expand "remove")
                 (expand "member")
                 (expand "singleton")
                 (replace -1 * rl)
                 (assert)
                 (decompose-equality -3)
                 (inst - "v!1")
                 (assert))
                ("2"
                 (expand "remove")
                 (expand "member")
                 (expand "singleton")
                 (replace -1 * rl)
                 (assert)
                 (decompose-equality -3)
                 (inst - "v!1")
                 (assert))))))
            ("2"
             (hide-all-but -3 -)
             (name "jj" "({y: T | v!2 /= y AND vert(G!1)(y)})")
             (replace -1 1)
             (grind)
             (expand "singleton")
             (expand "remove")
             (expand "member")
             (replace -1 * rl)
             (assert)
             (decompose-equality -2)
             (assert)
             (inst - "x!1"))))
          ("2"
           (hide -2 3)
           (name "cc" "({e: doubleton[T] | edges(G!1)(e) AND e(v!2)})")
           (replace -1 -2)
           (replace -1 1)
           (grind))))
        ("3" (hide -2 -3 -5 3 4) (grind))
        ("4"
         (lemma "size_del_vert")
         (inst -1 "G!1" "v!2")
         (replace -6 -1)
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: trees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (inst? -1)
   (inst -1 "size(G!1) -1")
   (("1" (assert))
    ("2"
     (lemma "tree_nonempty")
     (inst? -1)
     (bddsimp)
     (expand "empty?")
     (expand "size" 2)
     (assert 2)
     (lemma "finite_sets[T].nonempty_card")
     (inst -1 "vert(G!1)")
     (bddsimp)
     (("1" (assert)) ("2" (hide -1 -2 -3 2 4 5) (grind))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: trees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "k" 1 "nat_induction")
   (("1"
     (skosimp*)
     (name "H!1" "del_vert(G!1,v!1)")
     (assert -3)
     (copy 1)
     (replace -1 1)
     (expand "tree?" -2)
     (bddsimp)
     (("1"
       (hide -3)
       (lemma "finite_sets[T].card_one")
       (inst -1 "vert(G!1)")
       (bddsimp)
       (expand "deg" -5)
       (reveal -1)
       (lemma "finite_sets[doubleton[T]].card_one")
       (hide -2)
       (inst -1 "incident_edges(v!1,G!1)")
       (bddsimp -1 -6)
       (("1"
         (delete -1)
         (skosimp*)
         (typepred "x!1")
         (skosimp*)
         (case "x!1(x!2)")
         (("1"
           (hide -4 -6 -7 -8 2 3)
           (grind)
           (("1"
             (expand "singleton" -4)
             (expand "dbl" -2)
             (case "vert(G!1)(y!1)")
             (("1" (grind))
              ("2"
               (case "edges(G!1)(x!1)")
               (("1"
                 (typepred "G!1")
                 (inst -1 "x!1")
                 (bddsimp -1 -2)
                 (("1"
                   (inst-cp -1 "x!3")
                   (inst -1 "y!1")
                   (assert)
                   (hide -4 -6)
                   (hide -3)
                   (grind))
                  ("2" (propax))))
                ("2"
                 (expand "incident_edges" -)
                 (expand "dbl" -3)
                 (replace -2 -3 rl)
                 (hide -1 -2 -4 2 3)
                 (case "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!1)")
                 (("1" (grind))
                  ("2"
                   (hide 2)
                   (grind)
                   (("1"
                     (expand "singleton" -1)
                     (lemma
                      "functions[doubleton[T],bool].extensionality_postulate")
                     (inst -1
                      "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})"
                      "({y: doubleton[T] | y = x!1})")
                     (bddsimp)
                     (inst -1 "x!1")
                     (assert))
                    ("2"
                     (lemma
                      "functions[doubleton[T],bool].extensionality_postulate")
                     (inst -1
                      "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})"
                      "({y: doubleton[T] | y = x!1})")
                     (bddsimp)
                     (("1" (inst -1 "x!1") (assert))
                      ("2"
                       (assert)
                       (hide 1 3)
                       (expand "singleton" -1)
                       (propax))))))))))))
            ("2"
             (case "vert(G!1)(x!3)")
             (("1" (grind))
              ("2"
               (replace -2 -3 rl)
               (expand "incident_edges" -3)
               (case "singleton(x!1)(x!1)")
               (("1"
                 (replace -4 -1 rl)
                 (case "edges(G!1)(x!1)")
                 (("1"
                   (typepred "G!1")
                   (inst -1 "x!1")
                   (bddsimp -1 -2)
                   (("1"
                     (case "x!1(x!3)")
                     (("1" (inst -2 "x!3") (assert))
                      ("2" (assert) (hide -1 -2 -3 -4 -6 -7) (grind))))
                    ("2" (propax))))
                  ("2" (hide -2 -3 -4 -5) (grind))))
                ("2" (grind))))))))
          ("2"
           (hide -3 -5 -7 3 4)
           (install-rewrites "graphs")
           (assert)
           (expand "incident_edges" -)
           (expand "singleton" -3)
           (expand "singleton" -2)
           (replace -3 -4)
           (beta -4)
           (replace -4 -2)
           (case "({e: doubleton[T] | edges(G!1)(e) AND e(x!2)})(x!1) = ({y: doubleton[T] | y = x!1})(x!1)")
           (("1" (assert -1)) ("2" (hide -1 -3 -4 2 3) (grind))))))
        ("2" (propax))))
      ("2"
       (lemma "finite_sets[T].card_one")
       (inst -1 "vert(G!1)")
       (bddsimp)
       (("1"
         (hide -4)
         (skosimp*)
         (hide -4)
         (expand "deg" -5)
         (lemma "finite_sets[doubleton[T]].card_one")
         (inst -1 "incident_edges(v!1,G!1)")
         (bddsimp -1 -6)
         (("1"
           (delete -1)
           (skosimp*)
           (typepred "x!2")
           (skosimp*)
           (case "x!2(x!1)")
           (("1"
             (expand "incident_edges" -3)
             (case "singleton(x!2)(x!2)")
             (("1"
               (case "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!2) = singleton(x!2)(x!2)")
               (("1"
                 (beta -1)
                 (typepred "G!1")
                 (inst -1 "x!2")
                 (bddsimp)
                 (hide -1 -3 -7 -10 -11 -12 2 3)
                 (inst-cp -1 "x!3")
                 (inst -1 "y!1")
                 (grind))
                ("2"
                 (hide-all-but -4 -)
                 (hide 2 3 4)
                 (name "ff"
                       "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
                 (replace -1 -2)
                 (replace -1 1)
                 (hide -1)
                 (grind))))
              ("2" (hide-all-but -1 -) (hide 2 3 4) (grind))))
            ("2"
             (hide -3 -5 -6 -7 3 4)
             (expand "incident_edges" -2)
             (case "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!2) = singleton(x!2)(x!2)")
             (("1"
               (beta -1)
               (typepred "G!1")
               (inst -1 "x!2")
               (bddsimp)
               (("1"
                 (inst-cp -2 "x!3")
                 (inst -2 "y!1")
                 (case "x!2(y!1) AND x!2(x!3)")
                 (("1" (bddsimp) (hide -1 -2 -3 -6 -7 -8 -9) (grind))
                  ("2" (hide-all-but -6 -) (grind))))
                ("2" (grind)) ("3" (grind))))
              ("2"
               (hide -1 -3 2 3)
               (name "ff"
                     "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
               (replace -1 -2)
               (replace -1 1)
               (hide -1)
               (grind))))))
          ("2" (propax))))
        ("2" (expand "size" -3) (propax))))))
    ("2"
     (skosimp*)
     (copy 1)
     (name "H!1" "del_vert(G!1, v!1)")
     (replace -1 1)
     (expand "tree?" -3)
     (expand "size" -4)
     (typepred "j!1")
     (case "NOT card[T](vert(G!1)) = 1")
     (("1"
       (bddsimp)
       (skosimp*)
       (name "W!1" "del_vert[T](G!1, v!2)")
       (copy -6)
       (replace -2 -1)
       (hide -3 1)
       (lemma "del_vert_comm")
       (inst -1 "G!1" "v!1" "v!2")
       (replace -3 -1)
       (replace -4 -1)
       (lemma "size_del_vert")
       (inst-cp -1 "G!1" "v!1")
       (inst-cp -1 "G!1" "v!2")
       (inst-cp -1 "H!1" "v!2")
       (("1"
         (inst-cp -1 "W!1" "v!1")
         (("1"
           (replace -8 -4)
           (replace -9 -5)
           (name "U!1" "del_vert(W!1, v!1)")
           (hide -2)
           (inst -10 "W!1" "v!1")
           (case "v!1=v!2")
           (("1"
             (replace -1 -9 rl)
             (replace -9 -10)
             (replace -10 -8)
             (propax))
            ("2"
             (case "size(G!1) = j!1+2")
             (("1"
               (case "vert(W!1)(v!1) AND deg(v!1,W!1)=1")
               (("1"
                 (replace -2 -6)
                 (assert -6)
                 (bddsimp -1 -6 -9 -12)
                 (simplify)
                 (case "tree?(W!1) AND vert(W!1)(v!1) AND deg(v!1, W!1) = 1")
                 (("1"
                   (bddsimp -1 -14)
                   (case "tree?(del_vert(W!1, v!1))")
                   (("1"
                     (replace -8 -1)
                     (replace -8 -13)
                     (case "deg(v!2,H!1)=1")
                     (("1"
                       (expand "tree?" 2)
                       (flatten)
                       (inst 3 "v!2")
                       (("1" (replace -14 3 rl) (assert))
                        ("2"
                         (copy -17)
                         (expand "del_vert" -1)
                         (hide-all-but (-1 -18 -20 -23 -24) -)
                         (hide 4)
                         (case "remove[T](v!1, vert(G!1))=vert(H!1)")
                         (("1"
                           (case "remove[T](v!1, vert(G!1))(v!2)=vert(H!1)(v!2)")
                           (("1"
                             (hide -2 -3)
                             (expand "remove" -1)
                             (expand "member" -1)
                             (assert))
                            ("2"
                             (hide-all-but -1 -)
                             (hide 2 3 4)
                             (name "gg" "remove[T](v!1, vert(G!1))")
                             (replace -1 -2)
                             (replace -1 1)
                             (hide -1)
                             (assert))))
                          ("2"
                           (hide -2 -3 -4 -5)
                           (hide 2 3 4)
                           (grind))))))
                      ("2"
                       (copy -16)
                       (expand "del_vert" -1)
                       (case "remove[T](v!1, vert(G!1))=vert(H!1)")
                       (("1"
                         (hide -2)
                         (case "remove[T](v!1, vert(G!1))(v!2)=vert(H!1)(v!2)")
                         (("1"
                           (hide -2)
                           (expand "remove" -1)
                           (bddsimp)
                           (("1"
                             (hide -4 -5 -6 -7 -9 -10 -11 -12 -14 -15 -17
                              -19 -20 3 4)
                             (expand "deg" -7 1)
                             (expand "deg" 1)
                             (expand "member" -2)
                             (hide 2)
                             (expand "del_vert" -6)
                             (lemma "finite_sets[T].card_one")
                             (hide -1)
                             (lemma "finite_sets[doubleton[T]].card_one")
                             (inst-cp -1 "incident_edges(v!2, G!1)")
                             (inst -1 "incident_edges(v!2, H!1)")
                             (bddsimp)
                             (hide -1 1)
                             (skosimp*)
                             (inst 1 "x!1")
                             (expand "incident_edges")
                             (case "j!1>0")
                             (("1"
                               (case "edges(H!1)=({e: doubleton[T] | edges(G!1)(e) AND NOT e(v!1)})")
                               (("1"
                                 (apply-extensionality 1)
                                 (hide 2)
                                 (case
                                  " ({e: doubleton[T] | edges(G!1)(e) AND e(v!2)})(x!2)
                                                                                                         = singleton(x!1)(x!2)")
                                 (("1"
                                   (beta -1)
                                   (assert)
                                   (replace -2 1)
                                   (beta 1)
                                   (hide -2 -4 -9)
                                   (replace -1 1 rl)
                                   (iff 1)
                                   (bddsimp)
                                   (reveal -9 -10 -16)
                                   (expand "deg" -2)
                                   (reveal -5)
                                   (inst -1 "incident_edges(v!1, W!1)")
                                   (bddsimp)
                                   (skosimp*)
                                   (expand "incident_edges" -2)
                                   (hide -1)
                                   (expand "del_vert" -3)
                                   (case
                                    "edges(W!1)=({e: doubleton[T] | edges(G!1)(e) AND NOT e(v!2)})")
                                   (("1"
                                     (replace -1 -2)
                                     (beta -2)
                                     (case
                                      " ({e: doubleton[T] | (edges(G!1)(e) AND NOT e(v!2)) AND e(v!1)})(x!3) = singleton(x!3)(x!3)")
                                     (("1"
                                       (hide -2 -3 -5)
                                       (beta -1)
                                       (case "singleton(x!3)(x!3)")
                                       (("1"
                                         (iff -2)
                                         (bddsimp)
                                         (expand "deg" -15)
                                         (reveal -9)
                                         (inst
                                          -1
                                          "incident_edges(v!1, G!1)")
                                         (bddsimp)
                                         (skosimp*)
                                         (expand "incident_edges" -2)
                                         (case
                                          " ({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!2)
                                                                                                                                 = singleton(x!4)(x!2)")
                                         (("1"
                                           (case
                                            " ({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!3)
                                                                                                                                       = singleton(x!4)(x!3)")
                                           (("1"
                                             (hide -4)
                                             (beta -1)
                                             (beta -2)
                                             (iff -1)
                                             (iff -2)
                                             (bddsimp)
                                             (hide
                                              -1
                                              -4
                                              -7
                                              -8
                                              -9
                                              -14
                                              -15
                                              -16
                                              -17)
                                             (grind))
                                            ("2"
                                             (hide-all-but -3 -)
                                             (name
                                              "kkk"
                                              "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
                                             (replace -1 -2)
                                             (replace -1 1)
                                             (grind))))
                                          ("2"
                                           (hide-all-but -2 -)
                                           (name
                                            "kkk"
                                            "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
                                           (replace -1 1)
                                           (replace -1 -2)
                                           (grind))))
                                        ("2"
                                         (hide-all-but -7 -)
                                         (grind))))
                                      ("2"
                                       (hide-all-but -2 -)
                                       (name
                                        "ww"
                                        "({e: doubleton[T] | (edges(G!1)(e) AND NOT e(v!2)) AND e(v!1)})")
                                       (replace -1 -2)
                                       (replace -1 1)
                                       (grind))))
                                    ("2" (hide-all-but -3 -) (grind))))
                                  ("2"
                                   (hide-all-but -3 -)
                                   (name
                                    "mm"
                                    "({e: doubleton[T] | edges(G!1)(e) AND e(v!2)})")
                                   (replace -1 -2)
                                   (replace -1 1)
                                   (grind))))
                                ("2"
                                 (hide-all-but -7 -)
                                 (hide 2)
                                 (grind))))
                              ("2"
                               (typepred "j!1")
                               (case "j!1=0")
                               (("1"
                                 (replace -1 -6)
                                 (replace -6 -7)
                                 (assert -7)
                                 (expand "size" -7)
                                 (reveal 4)
                                 (expand "tree?" 1)
                                 (hide-all-but -7 -)
                                 (hide 2 3 4)
                                 (assert))
                                ("2" (hide-all-but -1 -) (assert))))))
                            ("2"
                             (hide-all-but -15 -)
                             (hide 2 3 4 5 6)
                             (grind))
                            ("3" (hide-all-but -15 -) (assert))))
                          ("2"
                           (hide-all-but -1 -)
                           (hide 2 3 4 5)
                           (name "kk" "remove[T](v!1, vert(G!1))")
                           (replace -1 -2)
                           (replace -1 1)
                           (grind))))
                        ("2" (hide-all-but -1 -) (grind))))))
                    ("2"
                     (hide-all-but (-1 -2 -3 -16) -)
                     (hide 2 3 4)
                     (assert))))
                  ("2" (assert))))
                ("2"
                 (case "j!1>0")
                 (("1"
                   (hide -3 -12 -14 3 4)
                   (expand "del_vert" -9)
                   (case "vert(W!1)=remove[T](v!2, vert(G!1))")
                   (("1"
                     (case "edges(W!1)=({e: doubleton[T] | edges(G!1)(e) AND NOT e(v!2)})")
                     (("1"
                       (expand "remove" -2)
                       (case "vert(W!1)(v!1) = ({y: T | v!2 /= y AND member(y, vert(G!1))})(v!1)")
                       (("1"
                         (beta -1)
                         (expand "member" -1)
                         (iff -1)
                         (bddsimp)
                         (("1"
                           (expand "deg" 1)
                           (lemma "finite_sets[doubleton[T]].card_one")
                           (inst -1 "incident_edges(v!1, W!1)")
                           (bddsimp)
                           (lemma "finite_sets[doubleton[T]].card_one")
                           (inst -1 "incident_edges(v!1, G!1)")
                           (expand "deg" -19)
                           (bddsimp)
                           (skosimp*)
                           (inst 2 "x!1")
                           (hide -1 -14 -15 1 4)
                           (expand "incident_edges")
                           (lemma "tree_edge_all")
                           (reveal -2)
                           (inst -2 "W!1" "v!1")
                           (bddsimp)
                           (("1"
                             (hide -1 -10 -11 -13 -14 -15 -17)
                             (expand "deg" -2)
                             (lemma
                              "finite_sets[doubleton[T]].nonempty_card")
                             (inst -1 "incident_edges(v!1, W!1)")
                             (bddsimp)
                             (expand "nonempty?" -1)
                             (expand "empty?" 1)
                             (skosimp*)
                             (expand "member")
                             (expand "incident_edges" -1)
                             (flatten)
                             (apply-extensionality 1)
                             (hide -3 2)
                             (replace -6 1)
                             (beta 1)
                             (hide -6 -7)
                             (case "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!1)
                                                                                                      = singleton(x!1)(x!1)")
                             (("1"
                               (case "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!2)
                                                                                                            = singleton(x!1)(x!2)")
                               (("1"
                                 (case
                                  "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})(x!3)
                                                                                                   = singleton(x!1)(x!3)")
                                 (("1"
                                   (iff 1)
                                   (iff -1)
                                   (iff -2)
                                   (iff -3)
                                   (bddsimp)
                                   (("1"
                                     (hide -11)
                                     (beta)
                                     (flatten)
                                     (grind)
                                     (reveal -2)
                                     (case
                                      "edges(W!1)(x!1) = ({e: doubleton[T] | edges(G!1)(e) AND NOT e(v!2)})(x!1)")
                                     (("1"
                                       (iff -1)
                                       (beta -1)
                                       (hide -2 -4 -5)
                                       (bddsimp))
                                      ("2" (hide-all-but -1 -) (grind))))
                                    ("2" (hide-all-but -1 -) (grind))
                                    ("3" (hide-all-but -1 -) (grind))
                                    ("4"
                                     (hide-all-but -11 -)
                                     (hide 1)
                                     (grind))
                                    ("5" (grind))
                                    ("6" (grind))
                                    ("7"
                                     (grind)
                                     (reveal -1)
                                     (case
                                      "edges(W!1)(x!2) = ({e: doubleton[T] | edges(G!1)(e) AND NOT e(v!2)})(x!2)")
                                     (("1" (iff -1) (beta -1) (bddsimp))
                                      ("2" (hide-all-but -1 -) (grind))))
                                    ("8" (grind))
                                    ("9"
                                     (replace -8 -2 rl)
                                     (beta -2)
                                     (bddsimp))
                                    ("10" (grind))
                                    ("11" (grind))
                                    ("12" (grind))
                                    ("13" (beta 1) (bddsimp))
                                    ("14" (grind))
                                    ("15"
                                     (hide-all-but (-3 -4) -)
                                     (hide 2 3 4 5 6)
                                     (beta 1)
                                     (assert))
                                    ("16" (grind))))
                                  ("2"
                                   (hide-all-but -6 -)
                                   (hide 2)
                                   (name
                                    "kkk"
                                    "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
                                   (replace -1 -2)
                                   (replace -1 1)
                                   (grind))))
                                ("2"
                                 (hide-all-but -5 -)
                                 (name
                                  "kkk"
                                  "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
                                 (replace -1 -2)
                                 (replace -1 1)
                                 (grind))))
                              ("2"
                               (hide-all-but -4 -)
                               (name "kkk"
                                     "({e: doubleton[T] | edges(G!1)(e) AND e(v!1)})")
                               (replace -1 -2)
                               (replace -1 1)
                               (grind))))
                            ("2"
                             (assert)
                             (replace -9 -12)
                             (assert -12)
                             (expand "size" -12)
                             (hide-all-but (-3 -8 -12) -)
                             (assert))))
                          ("2" (assert))))
                        ("2"
                         (hide-all-but -2 -)
                         (name "jj"
                               "({y: T | v!2 /= y AND member(y, vert(G!1))})")
                         (replace -1 -2)
                         (replace -1 1)
                         (grind))))
                      ("2" (hide-all-but -10 -) (grind))))
                    ("2" (hide-all-but -9 -) (grind))))
                  ("2"
                   (typepred "j!1")
                   (case "j!1=0")
                   (("1"
                     (replace -1 -3)
                     (replace -3 -8)
                     (assert -8)
                     (expand "size" -8)
                     (expand "tree?" 4)
                     (hide-all-but -8 -)
                     (assert))
                    ("2" (hide-all-but -1 -) (assert))))))))
              ("2" (expand "size" 1) (propax))))))
          ("2"
           (case "v!1=v!2")
           (("1"
             (replace -1 -7 rl)
             (replace -7 -8)
             (replace -8 -6)
             (propax))
            ("2"
             (copy -6)
             (expand "del_vert" -1)
             (hide-all-but (-1 -13) -)
             (hide 3 4)
             (grind)
             (case "remove[T](v!2,vert(G!1))=vert(W!1)")
             (("1"
               (hide -2)
               (case " remove[T](v!2, vert(G!1))(v!1) = vert(W!1)(v!1)")
               (("1"
                 (hide -2)
                 (expand "remove" -1)
                 (expand "member" 1)
                 (propax))
                ("2" (grind))))
              ("2" (grind))))))))
        ("2"
         (case "v!1=v!2")
         (("1"
           (replace -1 -6 rl)
           (replace -6 -7)
           (replace -7 -5)
           (propax))
          ("2"
           (copy -6)
           (expand "del_vert" -1)
           (hide-all-but (-1 -9 -13) -)
           (hide 3 4)
           (grind)
           (case "remove[T](v!1,vert(G!1))=vert(H!1)")
           (("1"
             (case " remove[T](v!1, vert(G!1))(v!2) = vert(H!1)(v!2)")
             (("1"
               (hide -2)
               (expand "remove" -1)
               (expand "member" 1)
               (propax))
              ("2" (grind))))
            ("2" (grind))))))))
      ("2" (hide-all-but (-1 -6 -8) -) (typepred "j!1") (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1" (assert))
    ("2"
     (lemma
      "min_in[Tree[T],(LAMBDA GT: size(GT)),
                               (LAMBDA GT: subgraph?(G_from(GT!1,w!1),GT))]")
     (("1" (beta) (expand "c_tree") (propax))
      ("2" (lemma "exists_c_tree") (inst?))))
    ("3"
     (skosimp*)
     (lemma
      "min_is_min[Tree[T],(LAMBDA GT: size(GT)),
                               (LAMBDA GT: subgraph?(G_from(GT!1,w!1),GT))]")
     (("1" (expand "c_tree") (inst -1 "GG!1") (beta) (assert))
      ("2" (lemma "exists_c_tree") (inst?))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "deg")
   (lemma "card_subset[doubleton[T]]")
   (inst -1 "incident_edges(v!1, G_from(GT!1, w!1))"
    "incident_edges(v!1, c_tree(GT!1, G_from(GT!1, w!1)))")
   (assert)
   (hide -1 -2 2)
   (expand "subset?")
   (skosimp*)
   (expand "member")
   (expand "incident_edges")
   (lemma "tree_containing_lem")
   (inst?)
   (flatten)
   (hide -1 -3)
   (expand "subgraph?")
   (flatten)
   (hide -1)
   (expand "subset?")
   (expand "member")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "size")
   (lemma "circuit_subgraph_len_1")
   (inst?)
   (assert)
   (lemma "G_from_vert")
   (inst?)
   (replace -1)
   (hide -1)
   (lemma "verts_of_subset")
   (inst?)
   (inst?)
   (("1" (lemma "card_subset[T]") (inst?) (assert))
    ("2" (assert) (typepred "w!1") (expand "walk?") (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_circ
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "card(vert(G!1)) <= 1")
   (("1" (rewrite "small_tree_lem") (expand "size") (propax))
    ("2"
     (name "Gp" "c_tree(G!1,G_from(G!1,w!1))")
     (("1"
       (case "size(G_from(G!1,w!1)) <= size(Gp)")
       (("1"
         (expand "size")
         (lemma "tree_containing_lem")
         (inst?)
         (assert)
         (flatten)
         (typepred "c_tree(G!1, G_from(G!1, w!1))")
         (expand "tree?" -2)
         (split -2)
         (("1" (lemma "circuit_subgraph_len_1") (inst?) (assert))
          ("2"
           (skosimp*)
           (hide -3)
           (expand "subgraph?" -3)
           (flatten)
           (lemma "card_subset[T]")
           (inst?)
           (assert)
           (lemma "circuit_deg")
           (inst?)
           (assert)
           (hide -3 -8 -9)
           (typepred "v!1")
           (hide -3)
           (case "NOT verts_of(w!1)(v!1)")
           (("1"
             (case "subgraph?(G_from(G!1,w!1),del_vert(Gp,v!1))")
             (("1"
               (case "size(del_vert(Gp, v!1)) = size(Gp) - 1")
               (("1" (inst -8 "del_vert(Gp, v!1)") (assert))
                ("2"
                 (expand "size")
                 (hide -5)
                 (expand "del_vert")
                 (rewrite "card_remove"))))
              ("2"
               (expand "verts_of")
               (rewrite "del_vert_subgraph" +)
               (("1" (hide 2) (expand "subgraph?") (propax))
                ("2" (expand "verts_of") (propax))))))
            ("2"
             (expand "verts_of")
             (skosimp*)
             (inst?)
             (hide -5 -6 -7 -8 -9)
             (replace -1)
             (hide -1)
             (lemma "tree_deg")
             (inst?)
             (assert))))))
        ("2"
         (typepred "w!1")
         (expand "walk?")
         (flatten)
         (hide -2 -3 2)
         (hide -1)
         (lemma "tree_containing_lem")
         (inst -1 "G!1" "w!1")
         (flatten)
         (hide -3)
         (expand "subgraph?")
         (flatten)
         (hide -1 -3)
         (expand "size")
         (lemma "card_subset[T]")
         (inst?)
         (assert))))
      ("2" (propax))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (flatten)
   (assert)
   (typepred "min_dual_paths(G!1, r!1, s!1)")
   (assert)
   (expand "is_min_dual?")
   (skosimp*)
   (expand "min_dual_paths")
   (typepred
    "min[[Path(G!1), Path(G!1)],
                         LAMBDA (r: Path(G!1), s_2847: Path(G!1)):
                           length(r) + length(s_2847),
                         LAMBDA (r: Path(G!1), s_2848: Path(G!1)):
                           dual_paths?(G!1, r, s_2848)]")
   (("1"
     (name-replace minp
      "min[[Path(G!1), Path(G!1)],
                           LAMBDA (r: Path(G!1), s_2847: Path(G!1)):
                             length(r) + length(s_2847),
                           LAMBDA (r: Path(G!1), s_2848: Path(G!1)):
                             dual_paths?(G!1, r, s_2848)]")
     (expand "minimal?")
     (assert)
     (inst - "(r!2,s!2)")
     (assert))
    ("2" (hide-all-but (-8 1)) (inst + "(r!1,s!1)") (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (inst 1 "proj_1(min_dual_paths(G!1,r!1,s!1))"
    "proj_2(min_dual_paths(G!1,r!1,s!1))")
   (lemma "min_dual_def")
   (inst -1 "G!1" "r!1" "s!1")
   (bddsimp))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "length(p!1)>1")
   (("1"
     (case "length(q!1)>1")
     (("1"
       (bddsimp)
       (("1"
         (typepred "q!1")
         (lemma "path?_caret")
         (inst? -1)
         (bddsimp (-1 -3 -4))
         (("1" (propax)) ("2" (assert)) ("3" (assert))))
        ("2"
         (lemma "path?_caret")
         (inst? -1)
         (typepred "p!1")
         (bddsimp (-2 -3 -5))
         (("1" (propax)) ("2" (assert)) ("3" (assert))))
        ("3"
         (typepred "q!1")
         (lemma "path?_caret")
         (inst? -1)
         (("1"
           (bddsimp (-1 -3 -4))
           (("1" (propax)) ("2" (assert)) ("3" (assert))))
          ("2" (assert))))
        ("4"
         (typepred "p!1")
         (lemma "path?_caret")
         (inst? -1)
         (("1"
           (bddsimp (-1 -3 -5))
           (("1" (propax)) ("2" (assert)) ("3" (assert))))
          ("2" (assert))))))
      ("2"
       (hide 2)
       (expand "dual_paths?")
       (bddsimp)
       (flatten)
       (case "length(q!1)=1")
       (("1"
         (replace -1 * lr)
         (assert)
         (replace -4 -3 rl)
         (typepred "p!1")
         (expand "path?")
         (flatten)
         (inst -3 "0" "length(p!1)-1")
         (assert))
        ("2" (assert))))))
    ("2"
     (hide 2)
     (case "length(p!1)=1")
     (("1"
       (expand "dual_paths?")
       (flatten)
       (replace -1 * lr)
       (assert)
       (replace -3 -2 lr)
       (typepred "q!1")
       (expand "path?")
       (flatten)
       (inst -3 "0" "length(q!1)-1")
       (assert)
       (flatten)
       (case "length(q!1)=1")
       (("1"
         (apply-extensionality 2 :hide? t)
         (apply-extensionality 1 :hide? t)
         (grind))
        ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (auto-rewrite "finseq_appl")
   (skosimp*)
   (lemma " dual_path_trunc")
   (inst -1 "G!1" "p!1" "q!1")
   (prop)
   (hide -3 -4 -5 -6)
   (case "length(p!1)=2 AND length(q!1)=2")
   (("1"
     (hide -2 -3 1 2)
     (flatten)
     (expand "dual_paths?")
     (flatten)
     (lemma "plus_up")
     (assert)
     (inst -1 "p!1" "q!1" "seq(p!1)(0)" "seq(p!1)(length(p!1)-1)")
     (assert)
     (prop)
     (("1"
       (expand "trunc1")
       (decompose-equality 1)
       (("1" (expand* "^" "min") (assert))
        ("2"
         (decompose-equality 1)
         (typepred "x!1")
         (expand* "^" "min")
         (assert))))
      ("2"
       (lemma "path_one")
       (inst -1 "G!1" "q!1" "seq(q!1)(0)" "seq(q!1)(length(q!1)-1)")
       (assert)
       (expand* "path_from?" "from?")
       (expand "circuit?")
       (flatten)
       (expand "cyclically_reduced?")
       (propax))
      ("3" (expand "from?") (propax)) ("4" (expand "from?") (propax))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "finseq_appl")
   (lemma "dual_path_trunc")
   (inst? -1)
   (inst -1 "q!1")
   (expand "is_min_dual?")
   (flatten)
   (bddsimp (-1 -2))
   (inst -8 "p!1^(0,length(p!1)-2)" "q!1^(0,length(q!1)-2)")
   (("1"
     (bddsimp)
     (("1" (hide -1 -4 -5 -6 -7) (install-rewrites "walks[T]") (assert))
      ("2" (hide -1 -4 -5 -6 -7) (install-rewrites "walks[T]") (assert))
      ("3"
       (expand "dual_paths?")
       (expand "finseq_appl")
       (flatten)
       (bddsimp)
       (("1" (expand "^" 2) (assert) (expand "min") (propax))
        ("2" (expand "^" 2) (expand "empty_seq") (assert))
        ("3"
         (flatten)
         (hide -5 -6 -7 -8)
         (install-rewrites "walks[T]")
         (apply-extensionality 1)
         (apply-extensionality 1 :hide? t)
         (flatten)
         (case "(LAMBDA (x: below[min(length(p!1) - 1, p!1`length)]): p!1`seq(x))(x!1) =
                                                  (LAMBDA (x: below[min(length(q!1) - 1, q!1`length)]): q!1`seq(x))(x!1)")
         (("1" (hide -7) (beta -1) (propax))
          ("2" (replace -6 1 lr) (propax))
          ("3"
           (typepred "x!1")
           (replace -6 -1 lr)
           (case "x!1=length(q!1)-1")
           (("1" (replace -1 2 lr) (replace -7 -4 lr) (propax))
            ("2" (assert))))
          ("4"
           (typepred "x!1")
           (case "x!1=length(p!1)-1")
           (("1" (replace -1 2 lr) (replace -7 -4 rl) (propax))
            ("2" (assert))))))))
      ("4"
       (expand "dual_paths?")
       (expand "finseq_appl")
       (flatten)
       (bddsimp)
       (("1"
         (expand "^" 2)
         (assert)
         (expand "min")
         (reveal -1)
         (inst -1 "p!1^(1,length(p!1)-1)" "q!1^(1,length(q!1)-1)")
         (bddsimp)
         (("1" (hide -6 -7 -8 -9) (install-rewrites "walks[T]") (assert))
          ("2"
           (expand "dual_paths?")
           (expand "finseq_appl")
           (bddsimp)
           (("1" (expand "^" 1) (expand "min") (propax))
            ("2" (expand "^" 1) (propax))
            ("3"
             (flatten)
             (hide -6 -7 -8 -9)
             (install-rewrites "walks[T]")
             (assert)
             (flatten)
             (apply-extensionality 1 :hide? t)
             (apply-extensionality 1 :hide? t)
             (case "(LAMBDA (x: below[min(length(p!1) - 1, p!1`length - 1)]): p!1`seq(1 + x))(x!1-1) =
                                 (LAMBDA (x: below[min(length(q!1) - 1, q!1`length - 1)]): q!1`seq(1 + x))(x!1-1)")
             (("1" (beta -1) (assert))
              ("2" (replace -2 1 lr) (propax))))))))
        ("2" (expand "^" 2) (expand "empty_seq") (assert))
        ("3"
         (expand "^" 2)
         (assert)
         (hide -5 -6 -7 -8)
         (expand "min")
         (install-rewrites "walks[T]")
         (apply-extensionality 1 :hide? t)
         (flatten)
         (apply-extensionality 1 :hide? t)
         (case "(LAMBDA (x: below[min(length(p!1) - 1, p!1`length)]): p!1`seq(x))(x!1) =
                                                  (LAMBDA (x: below[min(length(q!1) - 1, q!1`length)]): q!1`seq(x))(x!1)")
         (("1" (hide -7) (beta -1) (propax))
          ("2" (replace -6 1 lr) (propax))))))))
    ("2" (bddsimp) (("1" (assert)) ("2" (assert)))) ("3" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "min_dual_reduc")
   (expand "finseq_appl")
   (inst? -1)
   (bddsimp (-1 -2))
   (expand "is_min_dual?")
   (flatten)
   (lemma "dual_path_trunc")
   (inst? -1)
   (bddsimp (-1 -2))
   (delete -4 -5 -6 -7)
   (hide -2 -3)
   (inst -2 "p!1^(0,i!1)" "q!1^(0,j!1)")
   (("1"
     (expand "dual_paths?")
     (expand "finseq_appl")
     (flatten)
     (bddsimp)
     (("1" (expand* "^" "min") (assert))
      ("2" (expand* "^" "min") (assert))
      ("3" (expand* "^" "min") (assert))
      ("4" (expand* "^" "min") (assert)) ("5" (expand* "^" "min"))
      ("6" (expand* "^" "min"))
      ("7"
       (expand* "^" "min")
       (flatten)
       (case " (LAMBDA (x: below[min(1 + i!1, p!1`length)]): p!1`seq(x))(1) = (LAMBDA (x: below[min(1 + j!1, q!1`length)]): q!1`seq(x))(1)")
       (("1" (beta -1) (propax)) ("2" (replace -4 1 lr) (propax))
        ("3" (skosimp*) (assert)) ("4" (expand "min") (assert))
        ("5" (skosimp*) (assert)) ("6" (expand "min") (assert))))
      ("8"
       (expand* "^" "min")
       (flatten)
       (assert)
       (case " (LAMBDA (x: below[min(1 + i!1, p!1`length)]): p!1`seq(x))(1) = (LAMBDA (x: below[min(1 + j!1, q!1`length)]): q!1`seq(x))(1)")
       (("1" (beta -1) (propax)) ("2" (replace -4 1 lr) (propax))
        ("3" (skosimp*) (assert)) ("4" (expand "min") (assert))
        ("5" (skosimp*) (assert)) ("6" (expand "min") (assert))))))
    ("2"
     (assert)
     (lemma "path?_caret")
     (inst -1 "G!1" "0" "j!1" "q!1")
     (typepred "j!1")
     (expand "dual_paths?")
     (expand "finseq_appl")
     (typepred "q!1")
     (assert (-3 -4 -7))
     (bddsimp)
     (("1" (expand "^" 1) (expand "min") (assert))
      ("2" (expand "^" 1) (expand "min") (assert))))
    ("3"
     (bddsimp)
     (("1"
       (lemma "path?_caret")
       (inst -1 "G!1" "0" "i!1" "p!1")
       (typepred "p!1")
       (assert (-2 -3 -4))
       (assert))
      ("2"
       (lemma "path?_caret")
       (inst -1 "G!1" "0" "i!1" "p!1")
       (typepred "i!1")
       (typepred "p!1")
       (assert (-2 -3 -4))
       (assert))
      ("3" (expand* "^" min) (assert))
      ("4" (expand* "^" min) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "dual_path_length")
   (inst? -1)
   (bddsimp (-1 -2))
   (("1"
     (hide -2)
     (expand "cycle?")
     (expand "finseq_appl")
     (bddsimp)
     (("1"
       (skosimp*)
       (typepred "i!1")
       (typepred "j!1")
       (case "i!1<length(p!1)-1")
       (("1"
         (case "j!1<length(p!1)-1")
         (("1"
           (hide -6)
           (expand "dual_paths?")
           (expand "finseq_appl")
           (bddsimp)
           (("1"
             (typepred "p!1")
             (typepred "q!1")
             (expand "trunc1")
             (expand "endpoint?")
             (expand "o ")
             (expand* "^" min empty_seq)
             (expand "rev")
             (install-rewrites "walks[T]")
             (assert)
             (flatten)
             (hide -11 -12 -3 -7)
             (inst -6 "i!1" "j!1")
             (bddsimp))
            ("2"
             (typepred "p!1")
             (typepred "q!1")
             (expand "trunc1")
             (expand "endpoint?")
             (expand "o ")
             (expand* "^" min empty_seq)
             (expand "rev")
             (install-rewrites "walks[T]")
             (assert)
             (flatten)
             (hide -2 -3 -4 -7 -11 -12)
             (inst -4 "i!1" "j!1")
             (bddsimp))))
          ("2"
           (inst -5 "i!1" "length(q!1)+length(p!1)-j!1-2")
           (("1"
             (assert)
             (expand "endpoint?")
             (expand "o" 3)
             (expand "rev" 3)
             (expand "trunc1" 3)
             (expand "^" 3)
             (expand "min" 3)
             (expand "trunc1" -6)
             (expand "o" -6)
             (expand "rev" -6)
             (expand "^" -6)
             (expand "min" -6)
             (bddsimp (-5 -6))
             (("1" (assert))
              ("2"
               (assert)
               (case "j!1=length(p!1)-1")
               (("1"
                 (replace -1 * lr)
                 (assert)
                 (expand "dual_paths?")
                 (flatten)
                 (expand "finseq_appl")
                 (replace -2 -7 rl)
                 (typepred "p!1")
                 (expand "path?")
                 (flatten)
                 (expand "finseq_appl")
                 (inst -3 "length(p!1)-1" "i!1")
                 (assert))
                ("2" (assert))))))
            ("2"
             (assert)
             (hide -4 -5 4)
             (install-rewrites "walks[T]")
             (assert))))))
        ("2"
         (case "j!1<length(p!1)-1")
         (("1"
           (inst -5 "j!1" "length(q!1)+length(p!1)-i!1-2")
           (("1"
             (expand "endpoint?")
             (hide -2 -3 -4)
             (expand "o")
             (expand "rev")
             (expand "trunc1")
             (expand* "^" min empty_seq)
             (install-rewrites "walks[T]")
             (assert)
             (bddsimp -2 -3)
             (("1" (assert)) ("2" (assert))
              ("3"
               (assert)
               (case "i!1=length(p!1)-1")
               (("1"
                 (replace -1 * lr)
                 (assert)
                 (reveal -3)
                 (expand "dual_paths?")
                 (flatten)
                 (expand "finseq_appl")
                 (replace -2 -5 rl)
                 (typepred "p!1")
                 (expand "path?")
                 (flatten)
                 (expand "finseq_appl")
                 (inst -3 "length(p!1)-1" "j!1")
                 (assert))
                ("2" (assert))))))
            ("2" (hide -4 -5 4) (install-rewrites "walks[T]") (assert))))
          ("2"
           (hide -4)
           (typepred "q!1")
           (expand "path?")
           (expand "finseq_appl")
           (flatten)
           (hide -2 -6)
           (inst -2 "length(q!1)+length(p!1)-i!1-2"
            "length(q!1)+length(p!1)-j!1-2")
           (("1"
             (expand "endpoint?")
             (expand "o")
             (expand "rev")
             (expand "trunc1")
             (expand* "^" min empty_seq)
             (install-rewrites "walks[T]")
             (assert)
             (lift-if -4)
             (assert))
            ("2"
             (hide -4 5)
             (install-rewrites "walks[T]")
             (assert)
             (expand* "^" min empty_seq)
             (assert)
             (lift-if -2)
             (assert))
            ("3"
             (hide -4 5)
             (install-rewrites "walks[T]")
             (assert)
             (expand* "^" min empty_seq)
             (lift-if -2)
             (assert)
             (lift-if -3)
             (assert))))))))
      ("2"
       (expand "dual_paths?")
       (flatten)
       (hide -1 -2)
       (inst -1 "1" "1")
       (reveal -4)
       (assert (-1 -2))
       (bddsimp)
       (("1"
         (expand "o")
         (expand "trunc1")
         (expand* "^" min empty_seq)
         (expand "rev")
         (assert)
         (case "length(q!1)>1")
         (("1" (assert))
          ("2"
           (reveal -2 -3)
           (expand "finseq_appl")
           (case "length(q!1)=1")
           (("1"
             (lemma "walk_from_l")
             (inst -1 "q!1" "q!1`seq(0)" "q!1`seq(length(q!1)-1)")
             (expand "from?")
             (assert)
             (hide -1)
             (replace -1 * lr)
             (assert)
             (lemma "path_one")
             (inst -1 "G!1" "p!1" "p!1`seq(0)" "p!1`seq(length(p!1)-1)")
             (typepred "p!1")
             (expand "path_from?")
             (expand "from?")
             (expand "circuit?")
             (expand "cyclically_reduced?")
             (expand "finseq_appl")
             (propax))
            ("2" (assert))))))
        ("2"
         (case "length(q!1)=1")
         (("1"
           (reveal -2 -3)
           (expand "finseq_appl")
           (lemma "walk_from_l")
           (inst -1 "q!1" "q!1`seq(0)" "q!1`seq(length(q!1)-1)")
           (expand "from?")
           (assert)
           (hide -1)
           (replace -3 * lr)
           (assert)
           (lemma "path_one")
           (inst -1 "G!1" "p!1" "p!1`seq(0)" "p!1`seq(length(p!1)-1)")
           (typepred "p!1")
           (expand "path_from?")
           (expand "from?")
           (expand "trunc1")
           (expand "o ")
           (expand "^")
           (expand "min")
           (expand "rev")
           (replace -6)
           (assert)
           (expand "circuit?")
           (expand "cyclically_reduced?")
           (expand "finseq_appl")
           (propax))
          ("2"
           (assert)
           (typepred "q!1")
           (assert)
           (reveal -2 -3)
           (hide -4)
           (expand "o ")
           (expand "trunc1")
           (expand "rev")
           (expand* "^" min empty_seq)
           (expand "finseq_appl")
           (case "length(q!1)=2")
           (("1"
             (replace -1 * lr)
             (assert)
             (typepred "p!1")
             (expand "path?")
             (flatten)
             (hide -2)
             (expand "finseq_appl")
             (inst -2 "1" "length(p!1)-1")
             (replace -5 -8 rl)
             (assert))
            ("2" (assert))))))))
      ("3"
       (lemma "dual_path_trunc")
       (inst? -1)
       (bddsimp (-1 -2))
       (delete -4 -5 -6 7-)
       (hide -1)
       (hide -3 -4)
       (install-rewrites "walks[T]")
       (assert))
      ("4"
       (hide -2)
       (lemma "dual_path_trunc")
       (inst -1 "G!1" "p!1" "q!1")
       (bddsimp (-1 -2))
       (delete -4 -5 -6 -7)
       (expand "dual_paths?")
       (flatten)
       (expand "pre_circuit?")
       (expand "finseq_appl")
       (bddsimp)
       (("1" (install-rewrites "walks[T]") (assert))
        ("2"
         (lemma "walk_concat")
         (inst -1 "G!1" "p!1`seq(0)" "q!1`seq(0)"
          "p!1`seq(length(p!1)-1)" "p!1" "q!1")
         (typepred "p!1")
         (typepred "q!1")
         (expand "path?")
         (flatten)
         (hide -3 -6 -1 -4)
         (expand "walk_from?")
         (bddsimp)
         (("1" (hide -1 -2 -4 -5) (expand "trunc1") (propax))
          ("2" (assert))))))))
    ("2"
     (hide -2)
     (expand "cycle?")
     (expand "finseq_appl")
     (bddsimp)
     (("1"
       (skosimp*)
       (typepred "i!1")
       (typepred "j!1")
       (case "i!1<length(p!1)-1")
       (("1"
         (case "j!1<length(p!1)-1")
         (("1"
           (hide -6)
           (expand "dual_paths?")
           (expand "finseq_appl")
           (bddsimp)
           (("1"
             (typepred "p!1")
             (typepred "q!1")
             (expand "trunc1")
             (expand "endpoint?")
             (expand "o ")
             (expand* "^" min empty_seq)
             (expand "rev")
             (install-rewrites "walks[T]")
             (assert)
             (flatten)
             (hide -11 -12 -3 -7)
             (inst -6 "i!1" "j!1")
             (bddsimp))
            ("2"
             (typepred "p!1")
             (typepred "q!1")
             (expand "trunc1")
             (expand "endpoint?")
             (expand "o ")
             (expand* "^" min empty_seq)
             (expand "rev")
             (install-rewrites "walks[T]")
             (assert)
             (flatten)
             (hide -2 -3 -4 -7 -11 -12)
             (inst -4 "i!1" "j!1")
             (bddsimp))))
          ("2"
           (inst -5 "i!1" "length(q!1)+length(p!1)-j!1-2")
           (("1"
             (assert)
             (expand "endpoint?")
             (expand "o" 3)
             (expand "rev" 3)
             (expand "trunc1" 3)
             (expand "^" 3)
             (expand "trunc1" -6)
             (expand "o" -6)
             (expand "rev" -6)
             (expand "^" -6)
             (expand "min")
             (bddsimp (-5 -6))
             (("1" (assert))
              ("2"
               (case "j!1=length(p!1)-1")
               (("1"
                 (replace -1 * lr)
                 (assert)
                 (expand "dual_paths?")
                 (flatten)
                 (typepred "p!1")
                 (expand "path?")
                 (flatten)
                 (expand "finseq_appl")
                 (replace -10 -5 rl)
                 (inst -3 "i!1" "length(p!1)-1")
                 (assert))
                ("2" (assert))))))
            ("2"
             (assert)
             (hide -4 -5 4)
             (install-rewrites "walks[T]")
             (assert))))))
        ("2"
         (case "j!1<length(p!1)-1")
         (("1"
           (inst -5 "j!1" "length(q!1)+length(p!1)-i!1-2")
           (("1"
             (expand "endpoint?")
             (hide -2 -3 -4)
             (expand "o")
             (expand "rev")
             (expand "trunc1")
             (expand* "^" min empty_seq)
             (install-rewrites "walks[T]")
             (assert)
             (bddsimp -2 -3)
             (("1" (assert)) ("2" (assert))
              ("3"
               (case "i!1=length(p!1)-1")
               (("1"
                 (replace -1 * lr)
                 (assert)
                 (reveal -3)
                 (expand "dual_paths?")
                 (flatten)
                 (expand "finseq_appl")
                 (replace -5 -2 lr)
                 (typepred "p!1")
                 (expand "path?")
                 (flatten)
                 (expand "finseq_appl")
                 (inst -3 "length(p!1)-1" "j!1")
                 (assert))
                ("2" (assert))))))
            ("2" (hide -4 -5 4) (install-rewrites "walks[T]") (assert))))
          ("2"
           (hide -4)
           (typepred "q!1")
           (expand "path?")
           (flatten)
           (hide -2 -6)
           (expand "finseq_appl")
           (inst -2 "length(q!1)+length(p!1)-i!1-2"
            "length(q!1)+length(p!1)-j!1-2")
           (("1"
             (expand "endpoint?")
             (expand "o")
             (expand "rev")
             (expand "trunc1")
             (expand* "^" min empty_seq)
             (install-rewrites "walks[T]")
             (assert)
             (lift-if -4)
             (assert))
            ("2"
             (hide -4 5)
             (install-rewrites "walks[T]")
             (assert)
             (expand* "^" min empty_seq)
             (assert)
             (lift-if -2)
             (assert))
            ("3"
             (hide -4 5)
             (install-rewrites "walks[T]")
             (assert)
             (expand* "^" min empty_seq)
             (lift-if -2)
             (assert)
             (lift-if -3)
             (assert))))))))
      ("2"
       (expand "dual_paths?")
       (flatten)
       (hide -1 -2)
       (inst -1 "1" "1")
       (reveal -4)
       (assert (-1 -2))
       (bddsimp)
       (("1"
         (expand "o")
         (expand "trunc1")
         (expand* "^" min empty_seq)
         (expand "rev")
         (assert)
         (case "length(p!1)>1")
         (("1"
           (assert)
           (case "length(p!1)=2")
           (("1"
             (replace -1 * lr)
             (assert)
             (typepred "q!1")
             (expand "path?")
             (flatten)
             (expand "finseq_appl")
             (inst -3 "length(q!1)-1" "1")
             (assert))
            ("2" (assert))))
          ("2"
           (hide -2)
           (lemma "dual_path_trunc")
           (inst? -1)
           (inst? -1)
           (expand "dual_paths?")
           (bddsimp)
           (reveal -5 -6)
           (expand "finseq_appl")
           (lemma "walk_from_l")
           (inst? -1)
           (inst -1 "p!1`seq(0)" "p!1`seq(length(p!1)-1)")
           (expand "from?")
           (assert)
           (case "length(p!1)=1")
           (("1"
             (replace -1 * lr)
             (assert)
             (lemma "path_one")
             (inst -1 "G!1" "q!1" "q!1`seq(0)" "q!1`seq(length(q!1)-1)")
             (expand "path_from?")
             (expand "from?")
             (reveal -6)
             (expand "circuit?")
             (expand "pre_circuit?")
             (expand "cyclically_reduced?")
             (expand "finseq_appl")
             (flatten)
             (assert))
            ("2" (assert))))))
        ("2"
         (case "length(p!1)=1")
         (("1"
           (reveal -2 -3)
           (replace -3 * lr)
           (assert)
           (expand "finseq_appl")
           (replace -1 -2 lr)
           (lemma "path_one")
           (inst -1 "G!1" "q!1" "q!1`seq(0)" "q!1`seq(length(q!1)-1)")
           (expand "path_from?")
           (expand "from?")
           (expand "o ")
           (expand "rev")
           (expand "trunc1")
           (expand* "^" min empty_seq)
           (expand "circuit?")
           (expand "cyclically_reduced?")
           (expand "finseq_appl")
           (assert))
          ("2"
           (assert)
           (reveal -2 -3)
           (expand "finseq_appl")
           (case "length(p!1)=2")
           (("1"
             (replace -1 * lr)
             (assert)
             (install-rewrites "walks[T]")
             (assert)
             (replace -1 * lr)
             (assert)
             (typepred "q!1")
             (expand "path?")
             (flatten)
             (expand "finseq_appl")
             (inst -3 "length(q!1)-1" "1")
             (assert))
            ("2" (assert))))))))
      ("3"
       (lemma "dual_path_trunc")
       (inst? -1)
       (bddsimp)
       (delete -4 -5 -6 -7)
       (hide -1 -4)
       (install-rewrites "walks[T]")
       (assert))
      ("4"
       (expand "pre_circuit?")
       (expand "finseq_appl")
       (bddsimp)
       (("1"
         (lemma "dual_path_trunc")
         (inst? -1)
         (bddsimp)
         (delete -4 -5 -6 -7)
         (expand "dual_paths?")
         (flatten)
         (expand "finseq_appl")
         (hide -5)
         (install-rewrites "walks[T]")
         (assert))
        ("2"
         (lemma "dual_path_trunc")
         (inst? -1)
         (bddsimp)
         (delete -4 -5 -6 -7)
         (hide -4)
         (expand "dual_paths?")
         (expand "finseq_appl")
         (typepred "p!1")
         (typepred "q!1")
         (expand "path?")
         (flatten)
         (hide -1 -3 -4 -6)
         (lemma "walk_concat")
         (inst -1 "G!1" "p!1`seq(0)" "q!1`seq(0)"
          "p!1`seq(length(p!1)-1)" "p!1" "q!1")
         (expand "walk_from?")
         (bddsimp)
         (("1" (expand "trunc1") (propax)) ("2" (assert))))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "u!1=v!1")
   (("1"
     (lemma "tree_no_circuits")
     (inst-cp -1 "G!1" "p!1")
     (("1"
       (inst -1 "G!1" "q!1")
       (("1"
         (lemma "prewalk_same")
         (inst -1 "p!1" "q!1" "u!1" "v!1")
         (lemma "path_one")
         (inst-cp -1 "G!1" "p!1" "u!1" "v!1")
         (inst -1 "G!1" "q!1" "u!1" "v!1")
         (expand "path_from?")
         (bddsimp))
        ("2"
         (hide -1)
         (expand "path_from?" -4)
         (expand "path?" -4)
         (assert))))
      ("2" (expand "path_from?" -3) (expand "path?" -3) (assert))))
    ("2"
     (lemma "tree_no_circuits")
     (lemma "min_dual_def")
     (inst -1 "G!1" "p!1" "q!1")
     (("1"
       (name-replace PRO_1 "PROJ_1(min_dual_paths(G!1, p!1, q!1))")
       (("1"
         (name-replace PRO_2 "PROJ_2(min_dual_paths(G!1, p!1, q!1))")
         (("1"
           (lemma "cycl_red_compos")
           (inst -1 "G!1" "PRO_1" "PRO_2" "PRO_1(0)"
            "PRO_1(length(PRO_1)-1)")
           (("1"
             (lemma "path_one")
             (inst-cp -1 "G!1" "PRO_1" "PRO_1(0)"
              "PRO_1(length(PRO_1)-1)")
             (("1"
               (inst -1 "G!1" "PRO_2" "PRO_2(0)"
                "PRO_2(length(PRO_2)-1)")
               (("1"
                 (inst-cp -5 "G!1" "PRO_1")
                 (("1"
                   (inst-cp -5 "G!1" "PRO_2")
                   (("1"
                     (inst -5 "G!1" "trunc1(PRO_1) o rev(PRO_2)")
                     (("1"
                       (assert)
                       (lemma "back_short")
                       (inst -1 "G!1" "PRO_1" "PRO_2" "PRO_1(0)"
                        "PRO_1(length(PRO_1) -1)")
                       (lemma "front_short")
                       (inst -1 "G!1" "PRO_1" "PRO_2" "PRO_1(0)"
                        "PRO_1(length(PRO_1) -1)")
                       (expand "circuit?" 1)
                       (lemma "two_walks")
                       (inst -1 "G!1" "PRO_1" "PRO_2" "PRO_1(0)"
                        "PRO_1(length(PRO_1) -1)")
                       (expand "pre_circuit?")
                       (assert)
                       (expand "is_min_dual?")
                       (expand "dual_paths?" -7)
                       (typepred "PRO_1")
                       (typepred "PRO_2")
                       (expand "path_from?")
                       (copy -2)
                       (copy -5)
                       (expand "path?" -1)
                       (expand "path?" -2)
                       (flatten)
                       (hide -2 -4)
                       (copy -16)
                       (copy -19)
                       (expand "from?" -1)
                       (expand "from?" -2)
                       (lemma "walkers")
                       (inst -1 "PRO_1" "PRO_2")
                       (expand "finseq_appl")
                       (assert)
                       (flatten)
                       (replace -2 -4 rl)
                       (replace -3 -5 rl)
                       (assert)
                       (flatten)
                       (hide 1)
                       (hide -21 -22)
                       (assert)
                       (bddsimp -1 -15 -16 -18 -19)
                       (case "seq(PRO_1)(0) = seq(PRO_1)(length(PRO_1) - 1)")
                       (("1"
                         (assert)
                         (hide -14 -15 -16)
                         (hide -16)
                         (hide -10 -12 -19 -20 -21 -22)
                         (lemma "prewalk_same")
                         (inst -1 "PRO_1" "PRO_2" "seq(PRO_1)(0)"
                          "seq(PRO_1)(length(PRO_1)-1)")
                         (assert))
                        ("2"
                         (assert)
                         (hide -16 -17)
                         (case "seq(PRO_1)(length(PRO_1) - 2) /= seq(PRO_2)(length(PRO_2) - 2) AND
                                                                   seq(PRO_1)(1) /= seq(PRO_2)(1)")
                         (("1" (flatten) (assert))
                          ("2"
                           (case "seq(PRO_1)(length(PRO_1) - 2) = seq(PRO_2)(length(PRO_2) - 2)")
                           (("1"
                             (assert)
                             (hide -17 1)
                             (skolem! -16)
                             (inst -19 "pp!1" "qq!1")
                             (("1"
                               (assert)
                               (expand "from?" -16)
                               (hide-all-but (-16 -19) -)
                               (flatten)
                               (assert))
                              ("2" (assert)) ("3" (grind))))
                            ("2"
                             (case "seq(PRO_1)(1) = seq(PRO_2)(1)")
                             (("1"
                               (assert)
                               (hide -16 -17)
                               (skolem! -15)
                               (inst -18 "pp!1" "qq!1")
                               (("1"
                                 (expand "from?" -15)
                                 (hide-all-but (-15 -18) -)
                                 (flatten)
                                 (assert))
                                ("2" (assert)) ("3" (grind))))
                              ("2" (grind))))))))))
                      ("2"
                       (hide-all-but (-4 -8 -9) -)
                       (expand "path_from?")
                       (expand "dual_paths?")
                       (expand "from?")
                       (expand "finseq_appl")
                       (typepred "PRO_1")
                       (typepred "PRO_2")
                       (expand "path?" (-2 -4))
                       (assert)
                       (flatten)
                       (hide -3 -6 -8 -11)
                       (replace -8 -6 rl)
                       (replace -9 -7 rl)
                       (hide -8 -9)
                       (assert)
                       (flatten)
                       (reveal -7 -8 -10 -11 -12)
                       (bddsimp -4 -5)
                       (("1"
                         (bddsimp -3 -4)
                         (("1"
                           (hide -3)
                           (lemma "prewalk_same")
                           (inst -1 "PRO_1" "PRO_2"
                            "finseq_appl(PRO_1)(0)"
                            "finseq_appl(PRO_1)(length(PRO_1) - 1)")
                           (assert)
                           (expand "finseq_appl")
                           (case "length(PRO_1)>1")
                           (("1"
                             (lemma "walk_concat")
                             (inst -1 "G!1" "seq(PRO_1)(0)"
                              "seq(PRO_1)(0)"
                              "seq(PRO_1)(length(PRO_1)-1)" "PRO_1"
                              "PRO_2")
                             (hide -3 -4 -7 -12 -13 1 2 3 5)
                             (grind))
                            ("2"
                             (assert)
                             (expand "path_from?")
                             (hide -2 -10 -11 3 4 5)
                             (grind))))
                          ("2" (propax))))
                        ("2" (propax))))
                      ("3"
                       (expand "dual_paths?")
                       (hide -3)
                       (expand "path_from?")
                       (typepred "PRO_1" "PRO_2")
                       (flatten)
                       (hide -11 -13)
                       (bddsimp -8 -10)
                       (("1"
                         (bddsimp -8 -9)
                         (("1"
                           (hide -8)
                           (expand "from?" (-8 -9))
                           (flatten)
                           (replace -10 -8 rl)
                           (replace -11 -9 rl)
                           (hide -10 -11)
                           (assert)
                           (expand "finseq_appl")
                           (flatten)
                           (hide -6 -7)
                           (lemma "prewalk_same")
                           (inst -1 "PRO_1" "PRO_2" "seq(PRO_1)(0)"
                            "seq(PRO_1)(length(PRO_1)-1)")
                           (hide -9 -10 1 2)
                           (grind))
                          ("2" (propax))))
                        ("2" (propax))))))
                    ("2"
                     (hide -1 -2 -3 -5 -6)
                     (expand "dual_paths?")
                     (expand "path_from?")
                     (flatten)
                     (expand "from?")
                     (flatten)
                     (expand "is_min_dual?")
                     (replace -6 -3 rl)
                     (replace -7 -4 rl)
                     (hide -2 -5 -6 -7)
                     (expand "finseq_appl")
                     (assert)
                     (flatten)
                     (hide -2 -5 -6)
                     (expand "dual_paths?")
                     (typepred "PRO_2")
                     (grind))))
                  ("2"
                   (typepred "PRO_1")
                   (hide-all-but (-2) -)
                   (grind))))
                ("2" (typepred "PRO_2") (hide-all-but (-1) -) (assert))
                ("3" (typepred "PRO_2") (hide-all-but (-1) -) (assert))))
              ("2" (typepred "PRO_1") (hide-all-but (-1) -) (assert))
              ("3" (typepred "PRO_1") (hide-all-but (-1) -) (assert))))
            ("2" (typepred "PRO_1") (hide-all-but (-1) -) (assert))
            ("3" (typepred "PRO_1") (hide-all-but (-1) -) (assert))))
          ("2"
           (hide -1 -2)
           (expand "path_from?")
           (flatten)
           (expand "from?")
           (flatten)
           (assert)
           (expand "dual_paths?")
           (expand "finseq_appl")
           (propax))
          ("3" (hide -1 -2) (expand "path_from?") (assert))
          ("4"
           (hide -1 -2)
           (lemma "tree_nonempty")
           (inst?)
           (assert)
           (expand "empty?")
           (expand "nonempty?")
           (propax))))
        ("2"
         (hide -1 -2)
         (expand "path_from?")
         (flatten)
         (assert)
         (expand "from?")
         (flatten)
         (expand "dual_paths?")
         (expand "finseq_appl")
         (assert))
        ("3" (hide -1 -2) (expand "path_from?") (flatten))
        ("4"
         (lemma "tree_nonempty")
         (inst -1 "G!1")
         (assert)
         (expand "nonempty?")
         (expand "empty?" +)
         (propax))))
      ("2" (hide -1 -2) (grind)) ("3" (hide -1 -2) (grind))
      ("4"
       (hide -1 -3 -4)
       (lemma "tree_nonempty")
       (inst -1 "G!1")
       (assert)
       (hide -1)
       (grind))))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem-typepred)
   (typepred
    "min[[Path(G!1), Path(G!1)],
                           LAMBDA (r: Path(G!1), s: Path(G!1)): length(r) + length(s),
                           LAMBDA (r: Path(G!1), s: Path(G!1)):
                             dual_paths?(G!1, r, s)]")
   (("1" (assert) (expand "minimal?") (propax))
    ("2" (hide 2) (inst + "(r!1,s!1)"))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "is_min_dual?")
   (flatten)
   (lemma "dual_path_trunc")
   (inst? -1)
   (bddsimp (-1 -2))
   (assert))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "finseq_appl")
   (expand "is_min_dual?")
   (flatten)
   (lemma "dual_path_trunc")
   (inst? -1)
   (bddsimp (-1 -2))
   (assert))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "dual_path_trunc")
   (inst? -1)
   (bddsimp (-1 -2))
   (("1" (assert)) ("2" (propax))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: tree_paths
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (hide -2)
   (lemma "dual_path_trunc")
   (inst? -1)
   (bddsimp (-1 -2))
   (delete -4 -5 -6 -7)
   (lemma "walk_concat")
   (inst -1 "G!1" "p!1`seq(0)" "q!1`seq(0)" "p!1`seq(length(p!1)-1)"
    "p!1" "q!1")
   (expand "walk_from?")
   (expand "dual_paths?")
   (expand "finseq_appl")
   (flatten)
   (typepred "p!1")
   (typepred "q!1")
   (delete -1 -3)
   (expand "path?")
   (flatten)
   (hide -2 -4)
   (bddsimp (-1 -2 -6 -3))
   (("1"
     (expand "trunc1")
     (bddsimp)
     (("1" (expand "walk?" -6) (expand "finseq_appl") (assert))
      ("2"
       (expand "rev" 2)
       (expand "^" 2)
       (assert)
       (hide -1 -2 -4 -5 -6)
       (grind))))
    ("2" (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_pair
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (expand "well_founded?")
   (skosimp*)
   (expand "lsth")
   (lemma "wf_nat")
   (expand "well_founded?" -1)
   (inst-cp -1 "(LAMBDA (i:nat): Exists (j:nat): p!1(i,j))")
   (assert)
   (bddsimp)
   (("1"
     (skosimp*)
     (inst -1 "(LAMBDA (j:nat):p!1(y!2,j))")
     (typepred "y!2")
     (skosimp*)
     (bddsimp)
     (("1"
       (skosimp*)
       (typepred "y!3")
       (inst 1 "(y!2,y!3)")
       (skosimp*)
       (typepred "x!1")
       (assert)
       (inst -5 "x!1`1")
       (("1"
         (inst -4 "x!1`2")
         (("1" (assert))
          ("2"
           (assert)
           (bddsimp)
           (assert)
           (replace*)
           (case "x!1=(proj_1(x!1),proj_2(x!1))")
           (("1" (replace -1 -2) (assert)) ("2" (assert))))))
        ("2"
         (case "x!1=(proj_1(x!1),proj_2(x!1))")
         (("1" (replace -1 -2) (inst 1 "x!1`2")) ("2" (assert))))))
      ("2" (assert))))
    ("2" (inst 1 "y!1`1") (inst 1 "y!1`2") (hide -1 2) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_pair
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "wf_induction[[nat,nat],lsth]")
   (("1"
     (inst -1 "p!1")
     (assert)
     (split -1)
     (("1" (inst -1 "(i!1,j!1)"))
      ("2"
       (hide 2)
       (skosimp*)
       (inst -2 "x!1")
       (assert)
       (skosimp*)
       (inst -1 "(l!1,m!1)")
       (assert)
       (case-replace "(x!1`1, x!1`2) = x!1")
       (apply-extensionality 1 :hide? t))))
    ("2" (lemma "wf_lsth") (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_pair
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp)
   (rewrite "size_up" +)
   (skosimp*)
   (lemma "NAT_pair_induct")
   (inst -1
    "lambda (l,m):(FORALL (GG,HH): size(GG)=l AND size(HH)=m IMPLIES Q!1(GG,HH))")
   (assert)
   (bddsimp)
   (("1" (inst -1 "size(G!1)" "size(H!1)" "G!1" "H!1") (assert))
    ("2"
     (skosimp*)
     (inst -4 "GG!1" "HH!1")
     (replace -2 -1 rl)
     (replace -3 -1 rl)
     (hide -2 -3 -5 -6 2)
     (assert)
     (expand "lsth")
     (assert)
     (skosimp*)
     (inst -1 "size(GG!2)" "size(HH!2)")
     (bddsimp)
     (("1" (inst -2 "GG!2" "HH!2") (assert))
      ("2" (inst -3 "GG!2" "HH!2") (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_pair
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "graph_induct_pair")
   (inst -1 "(LAMBDA (GG,HH): NOT P!1(GG,HH))")
   (beta)
   (prop)
   (("1" (inst?))
    ("2"
     (skosimp*)
     (inst -3 "G!2" "H!2")
     (assert)
     (skosimp*)
     (inst -1 "GG!1" "HH!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "e!1")
   (skosimp*)
   (typepred "G!1")
   (inst?)
   (assert)
   (inst-cp -1 "x!1")
   (inst -1 "y!1")
   (replace -3 -1)
   (replace -3 -2)
   (expand "dbl" -1)
   (expand "dbl" -2)
   (replace -6)
   (expand "dbl" -1)
   (expand "dbl" -2)
   (ground)
   (("1"
     (replace -1)
     (hide -1)
     (replace -1)
     (hide -1)
     (replace -1)
     (expand "dbl")
     (propax))
    ("2"
     (replace -1)
     (hide -1)
     (replace -1)
     (hide -1)
     (replace -1)
     (hide -1)
     (expand "dbl")
     (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "G" 1 "graph_induction_vert")
   (skosimp*)
   (expand "connected?" -3)
   (prop)
   (("1"
     (hide -2)
     (typepred "v!1")
     (expand "singleton?")
     (expand "size")
     (assert)
     (expand "del_vert")
     (rewrite "empty_card[T]")
     (rewrite "card_remove")
     (assert))
    ("2"
     (skosimp*)
     (inst -3 "del_vert(G!1, v!2)")
     (rewrite "size_del_vert")
     (assert)
     (inst -3 "v!1")
     (("1"
       (prop)
       (("1"
         (case "vert(G!1) = dbl[T](v!1,v!2)")
         (("1"
           (hide -2 -4 1)
           (expand "deg")
           (rewrite "card_is_0[doubleton[T]]")
           (lemma "nonempty_card[doubleton[T]]")
           (inst?)
           (assert)
           (expand "nonempty?")
           (expand "empty?")
           (expand "member")
           (skosimp*)
           (hide -3)
           (case "incident_edges(v!1, G!1)(x!1) = emptyset(x!1)")
           (("1"
             (hide -4)
             (expand "incident_edges")
             (expand "emptyset")
             (flatten)
             (assert)
             (lemma "two_vertices")
             (inst?)
             (inst -1 "x!1")
             (assert))
            ("2" (assert))))
          ("2"
           (hide -2 -3 -4 2)
           (expand "del_vert")
           (expand "remove")
           (expand "empty?")
           (expand "member")
           (expand "dbl")
           (apply-extensionality 1 :hide? t)
           (inst -1 "x!1")
           (ground))))
        ("2"
         (hide -2 2)
         (case "v!1 = v!2")
         (("1" (assert))
          ("2"
           (lemma "del_vert_not_incident")
           (inst?)
           (assert)
           (hide -2 2)
           (expand "deg")
           (rewrite "card_empty?[doubleton[T]]")
           (expand "empty?")
           (expand "member")
           (expand "incident_edges")
           (inst?)
           (assert)
           (expand "dbl")
           (propax))))))
      ("2"
       (assert)
       (typepred "v!1")
       (hide -2 -3 -4 2)
       (rewrite "del_vert_still_in"))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "G" 1 "graph_induction_vert")
   (skosimp*)
   (lemma "singleton_deg")
   (inst?)
   (assert)
   (case "(EXISTS (x: (vert(G!1))): deg(x,G!1) > 0 AND
                       connected?(del_vert(G!1, x)))")
   (("1"
     (skosimp*)
     (case-replace "x!1 = v!1")
     (case "edges(G!1)(dbl[T](x!1,v!1))")
     (("1"
       (case "vert(del_vert(del_vert(G!1, x!1), v!1)) = emptyset[T]")
       (("1"
         (hide -5)
         (expand "connected?" 3)
         (flatten)
         (hide -2 -3 -4 -5 -6 2 4)
         (expand "singleton?")
         (expand "size")
         (lemma "card_is_0[T]")
         (inst -1 "vert(del_vert(del_vert(G!1, x!1), v!1))")
         (iff -1)
         (flatten)
         (assert)
         (lemma "size_del_vert ")
         (inst -1 "del_vert(G!1, v!1)" "x!1")
         (("1" (rewrite "del_vert_comm") (expand "size") (assert))
          ("2" (rewrite "del_vert_still_in"))))
        ("2"
         (hide -4)
         (lemma "sub_T")
         (inst -1 "del_vert(G!1,x!1)" "v!1")
         (("1"
           (assert)
           (prop)
           (("1"
             (hide -2 -3 -4 -5 -6 3 4)
             (lemma "emptyset_is_empty?[T]")
             (inst?)
             (assert))
            ("2"
             (hide -2 -3 -4 2 4 5 6)
             (assert)
             (lemma "deg_del_vert")
             (inst?)
             (assert))))
          ("2" (rewrite "del_vert_still_in"))))))
      ("2"
       (inst -3 "del_vert(G!1,x!1)")
       (prop)
       (("1"
         (inst -1 "v!1")
         (("1"
           (expand "connected?" 4)
           (prop)
           (("1"
             (inst?)
             (("1"
               (rewrite "del_vert_comm")
               (assert)
               (rewrite "del_vert_not_incident"))
              ("2" (rewrite "del_vert_still_in"))))
            ("2"
             (lemma "del_vert_not_incident")
             (inst?)
             (rewrite "dbl_comm")
             (assert))))
          ("2" (rewrite "del_vert_still_in"))))
        ("2" (rewrite "size_del_vert") (assert))))
      ("3" (inst 1 "x!1" "v!1") (assert))))
    ("2" (hide -1) (expand "connected?" -1) (propax))))


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


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "connected?" -1)
   (prop)
   (("1" (hide 2 3) (expand "isolated?") (rewrite "singleton_edges"))
    ("2"
     (skosimp*)
     (case "(EXISTS (e: doubleton[T], y:T): e = dbl(y,v!1) AND edges(G!1)(e))")
     (("1"
       (skosimp*)
       (inst 3 "e!1")
       (name "HH" "del_edge(G!1,e!1)")
       (name "KK" "del_vert(G!1,v!1)")
       (replace -1)
       (replace -2)
       (expand "connected?" +)
       (flatten)
       (inst 2 "v!1")
       (inst 4 "v!1")
       (("1"
         (prop)
         (("1"
           (replace -2 * rl)
           (hide -2)
           (lemma "deg_del_edge")
           (inst?)
           (inst?)
           (assert))
          ("2"
           (assert)
           (case "del_vert(HH,v!1) = KK")
           (("1" (assert))
            ("2"
             (replace -2 * rl)
             (hide -2)
             (replace -1 * rl)
             (hide -1)
             (hide -3 -4 2 3 4 5)
             (lemma "del_rem_lem")
             (inst?)
             (assert)
             (hide 2)
             (replace -1)
             (hide -1)
             (expand "dbl")
             (propax))))))
        ("2"
         (typepred "v!1")
         (replace -3 * rl)
         (rewrite "vert_del_edge"))))
      ("2"
       (hide -2 2 3 4)
       (expand "deg")
       (lemma "empty_card[doubleton[T]]")
       (inst?)
       (flatten)
       (assert)
       (hide -1)
       (expand "empty?")
       (expand "incident_edges")
       (skosimp*)
       (expand "member")
       (flatten)
       (lemma "other_vert")
       (inst?)
       (inst?)
       (assert)
       (skosimp*)
       (assert)
       (inst + "x!1" "u!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "G" 1 "graph_induction_vert")
   (skosimp*)
   (case "edges(G!1)(e!1)")
   (("1"
     (hide -2)
     (case "(EXISTS (v: T): vert(G!1)(v) AND deg(v,G!1) = 1)")
     (("1"
       (name "H" "del_edge(G!1,e!1)")
       (skosimp*)
       (case "(EXISTS (u: T): vert(G!1)(u) AND e!1 = dbl[T](u,v!1))")
       (("1"
         (skosimp*)
         (lemma "deg_del_edge")
         (inst?)
         (inst?)
         (assert)
         (replace -6)
         (assert)
         (lemma "sub_T")
         (inst?)
         (("1"
           (assert)
           (lemma "   del_vert_empty?")
           (inst -1 "H" "v!1")
           (("1"
             (assert)
             (replace -6)
             (expand "connected?" 1)
             (flatten)
             (lemma "del_edge_singleton")
             (inst?)
             (assert))
            ("2" (replace -5 + rl) (expand "del_edge") (propax))))
          ("2" (expand "del_edge") (propax))))
        ("2"
         (name "GP" "del_vert(G!1,v!1)")
         (name "K" "del_vert(H,v!1)")
         (case "K = del_edge(GP,e!1)")
         (("1"
           (case "connected?(K)")
           (("1"
             (reveal -1)
             (inst -1 "GP")
             (split -1)
             (("1"
               (inst?)
               (assert)
               (expand "connected?" 2)
               (flatten)
               (inst 3 "v!1")
               (assert))
              ("2"
               (expand "size")
               (replace -4 + rl)
               (hide -1 -2 -3 -4 -5 -7 -8 -9 2 3)
               (expand "del_vert")
               (rewrite "card_remove[T]")
               (assert))))
            ("2"
             (lemma "rev_lem2")
             (inst?)
             (("1"
               (assert)
               (replace -4 + rl)
               (lemma "deg_del_edge3")
               (inst?)
               (assert)
               (hide -2 -3 -4 -5 -7 -9 1 2 4)
               (lemma "other_vert")
               (inst?)
               (inst?)
               (assert)
               (skosimp*)
               (inst?)
               (assert))
              ("2" (replace -4 + rl) (expand "del_edge" 1) (propax))))))
          ("2"
           (hide -7 2 3)
           (replace -2 + rl)
           (replace -1 + rl)
           (replace -3 + rl)
           (hide -1 -2 -3)
           (rewrite "del_vert_edge_comm"))))))
      ("2"
       (case "(FORALL (v: T): vert(G!1)(v) IMPLIES deg(v, G!1) > 1)")
       (("1"
         (name "H" "del_edge(G!1,e!1)")
         (case "(EXISTS (u: T): vert(G!1)(u) AND deg(u,H) = 1)")
         (("1"
           (skosimp*)
           (case "(EXISTS (z: T): vert(H)(z) AND e!1 = dbl[T](u!1,z))")
           (("1"
             (skosimp*)
             (name "K" "del_vert(G!1,u!1)")
             (case "K = del_vert(H,u!1)")
             (("1"
               (case "connected?(K)")
               (("1"
                 (expand "connected?" 2)
                 (flatten)
                 (inst 3 "u!1")
                 (assert)
                 (hide -1 -2 -3 -4 -5 -9 -11 1 2)
                 (replace -3 * rl)
                 (hide -3)
                 (lemma "deg_del_edge_ge")
                 (inst?)
                 (assert))
                ("2"
                 (replace -7)
                 (lemma "rev_lem2")
                 (inst?)
                 (("1" (assert))
                  ("2"
                   (hide -1 -2 -3 -4 -6 -8 -9 -10 2 3 4)
                   (replace -2 * rl)
                   (expand "del_edge")
                   (propax))))))
              ("2"
               (lemma "del_vert_edge")
               (inst?)
               (inst -1 "u!1")
               (assert)
               (replace -3)
               (expand "dbl")
               (propax))))
            ("2"
             (inst -4 "u!1")
             (assert)
             (replace -3 * rl)
             (hide -3)
             (case "e!1(u!1)")
             (("1"
               (lemma "edges_vert")
               (inst?)
               (inst?)
               (assert)
               (skosimp*)
               (inst 2 "y!1")
               (lemma "edge_has_2_verts")
               (inst?)
               (assert)
               (expand "del_edge")
               (propax))
              ("2"
               (hide -5 2 3 4)
               (lemma "deg_del_edge3")
               (inst?)
               (assert))))))
          ("2"
           (case "(FORALL (v: T): vert(H)(v) IMPLIES deg(v,H) > 1)")
           (("1"
             (case "(EXISTS (z: T): vert(H)(z) AND deg(z,H) > 0 AND
                                connected?(del_vert(H,z)))")
             (("1"
               (skosimp*)
               (case "(EXISTS (p: T): p /= z!1 AND vert(H)(p) AND e!1 = dbl[T](z!1,p))")
               (("1"
                 (skosimp*)
                 (case "del_vert(H,z!1) = del_vert(G!1,z!1)")
                 (("1"
                   (expand "connected?" 4)
                   (flatten)
                   (replace -1)
                   (inst 5 "z!1")
                   (("1"
                     (assert)
                     (hide -2 -3 -4 -5 -6 -8 -10 2 3 4)
                     (lemma "deg_del_edge_ge")
                     (inst?)
                     (assert)
                     (inst -4 "z!1")
                     (assert)
                     (reveal -5 -8)
                     (hide -3 -5)
                     (replace -2 * rl)
                     (expand "del_edge" -1)
                     (propax))
                    ("2"
                     (hide -1 -2 -4 -5 -6 -7 -9 3 4 5)
                     (replace -1)
                     (hide -1)
                     (typepred "G!1")
                     (inst?)
                     (("1"
                       (assert)
                       (inst -1 "z!1")
                       (expand "dbl")
                       (propax))
                      ("2" (inst?) (assert))))))
                  ("2"
                   (lemma "del_vert_edge")
                   (inst?)
                   (inst -1 "z!1")
                   (assert)
                   (hide -1 -4 -5 -6 -8 -10 2 4 5 6)
                   (replace -1)
                   (hide -1)
                   (expand "dbl")
                   (propax))))
                ("2"
                 (name "K" "del_vert(H,z!1)")
                 (replace -1)
                 (replace -6)
                 (name "GP" "del_vert(G!1,z!1)")
                 (case "K = del_edge(GP,e!1)")
                 (("1"
                   (case "size(GP) < size(G!1)")
                   (("1"
                     (reveal -1)
                     (inst -1 "GP")
                     (assert)
                     (inst -1 "e!1")
                     (assert)
                     (expand "connected?" 4)
                     (flatten)
                     (inst 5 "z!1")
                     (("1"
                       (assert)
                       (hide -1 -2 -3 -4 -5 -8 -9 -11 -12 -13 1 2 3 4)
                       (replace -3 * rl)
                       (hide -3)
                       (expand "del_edge" -1)
                       (lemma "deg_del_edge_ge")
                       (inst?)
                       (assert))
                      ("2"
                       (hide -1 -2 -3 -4 -5 -7 -8 -9 -11 -12 -13 2 3 4 5)
                       (replace -2 * rl)
                       (hide -2)
                       (expand "del_edge")
                       (propax))))
                    ("2"
                     (hide -1 -3 -5 -6 -7 -9 -10 -11 2 3 4 5)
                     (replace -1 * rl)
                     (hide -1)
                     (replace -2 * rl)
                     (hide -2)
                     (expand "del_edge")
                     (expand "size")
                     (expand "del_vert")
                     (rewrite "card_remove")
                     (ground))))
                  ("2"
                   (lemma "del_vert_edge_comm")
                   (replace -3 * rl)
                   (replace -8 * rl)
                   (replace -2 * rl)
                   (hide -2 -3 -5 -6 -7 -8 -9 -11 2 3 4 5)
                   (inst?))))))
              ("2"
               (replace -2)
               (expand "connected?" -5)
               (split -5)
               (("1"
                 (hide -2 -4 1 2 3 4)
                 (replace -2 * rl)
                 (lemma "del_edge_singleton")
                 (inst?)
                 (assert)
                 (hide -2 -3)
                 (lemma "edge_in_card_gt_1")
                 (inst?)
                 (assert)
                 (expand "singleton?")
                 (expand "size")
                 (assert))
                ("2" (skosimp*) (inst 1 "v!1") (assert))))))
            ("2"
             (skosimp*)
             (inst 2 "v!1")
             (inst -3 "v!1")
             (replace -2 * rl)
             (expand "del_edge" -1)
             (assert)
             (lemma "deg_del_edge_le")
             (inst?)
             (assert))))))
        ("2"
         (skosimp*)
         (inst?)
         (assert)
         (case "deg(v!1, G!1) = 0")
         (("1"
           (case "vert(del_edge(G!1, e!1))(v!1)")
           (("1"
             (case "card(vert(del_edge(G!1,e!1))) > 1")
             (("1"
               (case "NOT empty?(vert(del_vert(del_edge(G!1, e!1), v!1)))")
               (("1"
                 (lemma "sub_T")
                 (inst -1 "del_edge(G!1, e!1)" "v!1")
                 (assert)
                 (hide -1 -6 2 3 4 5)
                 (lemma "deg_del_edge3")
                 (inst?)
                 (assert)
                 (expand "deg")
                 (lemma "empty_card[doubleton[T]]")
                 (inst -1 "incident_edges(v!1, G!1)")
                 (assert)
                 (hide -3 -4 -5 1)
                 (expand "incident_edges")
                 (expand "empty?")
                 (inst?)
                 (expand "member")
                 (propax))
                ("2"
                 (hide -4 -7 1 2 3)
                 (lemma "empty_card[T]")
                 (inst?)
                 (assert)
                 (hide -2 -5 -6)
                 (grind)
                 (rewrite "card_remove[T]")
                 (assert))))
              ("2"
               (lemma "edge_in_card_gt_1")
               (inst -1 "G!1" "e!1")
               (assert)
               (hide -2 -3 -4 -5 -6 2 3 4)
               (expand "del_edge")
               (propax))))
            ("2" (expand "del_edge") (propax))))
          ("2" (assert))))))))
    ("2" (hide -1) (lemma "del_edge_lem5") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (expand "connected?")
     (assert)
     (expand "singleton?")
     (skosimp*)
     (expand "isolated?")
     (lemma "deg_edge_exists")
     (inst?)
     (assert)
     (skosimp*)
     (expand "empty?")
     (inst?)
     (expand "member")
     (propax))
    ("2" (skosimp*) (lemma "conn_lem2") (inst?) (assert))
    ("3" (rewrite "conn_lem3")) ("4" (expand "connected?") (assert))
    ("5"
     (skosimp*)
     (expand "connected?" 2)
     (flatten)
     (inst 3 "x!1")
     (assert))
    ("6" (skosimp*) (lemma "conn_lem6") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "conn_eq_compl")
   (inst?)
   (flatten)
   (hide -2)
   (assert)
   (split -1)
   (("1"
     (flatten)
     (expand "connected?")
     (flatten)
     (inst 2 "v!1")
     (assert))
    ("2"
     (flatten)
     (split -1)
     (("1"
       (flatten)
       (skosimp*)
       (expand "connected?")
       (assert)
       (flatten)
       (inst?)
       (assert))
      ("2"
       (flatten)
       (expand "connected?" 3)
       (flatten)
       (inst 4 "v!1")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "empty?")
   (expand "connected?")
   (lemma " card_empty?[T]")
   (inst?)
   (iff)
   (assert)
   (prop)
   (("1" (expand "singleton?") (expand "size") (assert))
    ("2"
     (skosimp*)
     (expand "empty?")
     (inst -4 "v!1")
     (expand "member")
     (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_complected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (lemma "size_prep")
   (inst -1
    "LAMBDA G:(FORALL v:( connected?(G) AND vert(G)(v) AND deg(v, G) = 0 IMPLIES G = singleton_graph(v)))")
   (flatten)
   (bddsimp)
   (("1"
     (hide -2)
     (assert)
     (skosimp*)
     (inst -1 "G!1")
     (inst -1 "v!1")
     (assert))
    ("2"
     (hide 1 3)
     (induct "n" 1 "nat_induction")
     (("1"
       (skosimp*)
       (lemma "empty?_rew")
       (inst -1 "G!1")
       (iff -1)
       (bddsimp)
       (("1"
         (expand "deg" -6)
         (hide -2 -3)
         (expand "empty?" -1)
         (expand "empty?" -1)
         (inst -1 "v!1")
         (expand "member" 1)
         (propax))
        ("2"
         (reveal -1)
         (lemma "connected_not_empty")
         (inst -1 "G!1")
         (bddsimp -1 -4)
         (("1" (hide -1 -3 -4 -5 1 2 4) (grind)) ("2" (propax))))))
      ("2"
       (skosimp*)
       (expand "connected?" -3)
       (split -3)
       (("1"
         (hide -2 -3)
         (grind)
         (apply-extensionality 1)
         (("1"
           (hide 2)
           (lemma "finite_sets[T].card_one")
           (inst -1 "vert(G!1)")
           (bddsimp -1 -2)
           (("1"
             (skosimp*)
             (hide -1 -3)
             (lemma "finite_sets[doubleton[T]].empty_card")
             (inst -1 "incident_edges(v!1, G!1)")
             (bddsimp)
             (hide -2)
             (replace -2 -3)
             (expand "singleton" -3)
             (replace -3 -2 rl)
             (hide -3)
             (expand "empty?" -1)
             (expand "emptyset" 1)
             (apply-extensionality 1)
             (inst -2 "x!2")
             (typepred "G!1")
             (inst -1 "x!2")
             (bddsimp -1 -2)
             (("1"
               (typepred "x!2")
               (skosimp*)
               (hide -3 3)
               (inst-cp -2 "x!3")
               (inst -2 "y!1")
               (grind))
              ("2" (propax))))
            ("2" (propax))))
          ("2"
           (hide -3 2)
           (grind)
           (lemma "finite_sets[T].card_one")
           (inst -1 "vert(G!1)")
           (bddsimp -1 -2)
           (("1" (hide -1 -3) (grind)) ("2" (propax))))))
        ("2"
         (skosimp*)
         (case "v!1=v!2")
         (("1" (replace -1 -7) (hide -3 -4 -5) (assert))
          ("2"
           (inst -3 "del_vert(G!1, v!2)")
           (lemma "graph_ops[T].size_del_vert")
           (inst -1 "G!1" "v!2")
           (replace -5 -1)
           (assert -1)
           (bddsimp (-1 -4))
           (lemma "graph_ops[T].del_vert_still_in")
           (lemma "graph_deg[T].del_vert_not_incident")
           (inst -4 "v!1")
           (inst -2 "G!1" "v!2" "v!1")
           (bddsimp (-2 1))
           (("1"
             (inst -2 "G!1" "v!2" "v!1")
             (bddsimp (-2 1))
             (("1"
               (hide -3 -4 -6 -7 2)
               (grind)
               (expand "incident_edges" -4)
               (lemma "finite_sets[doubleton[T]].empty_card")
               (inst -1 "{e: doubleton[T] | edges(G!1)(e) AND e(v!1)}")
               (("1"
                 (bddsimp (-1 -5))
                 (expand "empty?" -1)
                 (inst -1 "dbl[T](v!1, v!2)")
                 (("1" (expand "member" 1) (hide -1 -2 -3 -4) (grind))
                  ("2" (hide -1 -2 -3 -4) (grind))))
                ("2"
                 (lemma "graph_deg[T].incident_edges_TCC1")
                 (inst -1 "G!1" "v!1")
                 (hide -2 -4 -5 2)
                 (grind))))
              ("2"
               (replace -9 -1)
               (bddsimp (-1 -2 -4 -6))
               (hide -3 -5 -7)
               (expand "deg" -4)
               (lemma "finite_sets[doubleton[T]].nonempty_card")
               (inst -1 "incident_edges(v!2, G!1)")
               (bddsimp (-1 -5))
               (expand "nonempty?" -1)
               (expand "empty?" 1)
               (skosimp*)
               (expand "member" -1)
               (hide -2)
               (expand "incident_edges" -1)
               (lemma "graphs[T].other_vert")
               (inst -1 "G!1" "x!1" "v!2")
               (bddsimp (-1 -2))
               (skosimp*)
               (lemma "graph_ops[T].del_vert_still_in")
               (inst -1 "G!1" "v!2" "u!1")
               (bddsimp (-1 1))
               (("1"
                 (typepred "G!1")
                 (inst -1 "x!1")
                 (bddsimp (-1 -4))
                 (inst -2 "v!2")
                 (bddsimp (-2 -4))
                 (case "deg(u!1,G!1)=0")
                 (("1"
                   (expand "deg" -1)
                   (lemma "finite_sets[doubleton[T]].empty_card")
                   (inst -1 "incident_edges(u!1, G!1)")
                   (bddsimp (-1 -2))
                   (expand "empty?" -1)
                   (inst -1 "x!1")
                   (expand "member" 1)
                   (expand "incident_edges" 1)
                   (hide -1 -3 -5 -8 -9 -10 -12 4)
                   (grind))
                  ("2"
                   (expand "singleton_graph" -9)
                   (replace -9 -8)
                   (beta -8)
                   (replace -9 -4)
                   (beta -4)
                   (hide -9 4)
                   (hide -7)
                   (hide -6)
                   (expand "singleton" -4)
                   (replace -4 -8 rl)
                   (propax))))
                ("2" (assert))))
              ("3" (assert))))
            ("2" (assert))))))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "s!1 = t!1 OR edge?(G!1)(s!1,t!1)")
   (("1" (inst 1 "vert(G!1)") (ground))
    ("2"
     (inst 2 "{t: T | vert(G!1)(t)  AND t /= s!1 AND t /= t!1}")
     (prop)
     (("1"
       (lemma "finite_subset[T]")
       (inst?)
       (inst?)
       (assert)
       (hide 2 3 4)
       (grind))
      ("2"
       (hide 4 5)
       (expand "separates")
       (skosimp*)
       (expand "walk_from?")
       (flatten)
       (case "length(w!1) = 1")
       (("1" (replace -1) (hide -1) (assert))
        ("2"
         (case-replace "length(w!1) = 2")
         (("1"
           (assert)
           (expand "walk?")
           (flatten)
           (inst -5 "0")
           (assert)
           (expand "del_verts")
           (expand "edge?")
           (expand "finseq_appl")
           (assert))
          ("2"
           (case "FORALL (i: below(length(w!1))): seq(w!1)(i) = s!1 OR seq(w!1)(i) = t!1")
           (("1"
             (expand "walk?")
             (flatten)
             (inst -5 "0")
             (assert)
             (expand "finseq_appl")
             (expand "edge?")
             (expand "del_verts")
             (flatten)
             (inst -1 "1")
             (assert))
            ("2"
             (lemma "walk_verts_in")
             (inst?)
             (("1"
               (split -1)
               (("1"
                 (hide -4)
                 (expand "verts_in?")
                 (expand "del_verts")
                 (expand "difference")
                 (expand "member")
                 (skosimp*)
                 (inst?)
                 (flatten)
                 (assert))
                ("2" (propax))))
              ("2"
               (hide -1 -2 -3 2 3 4 5 6)
               (lemma "finite_subset[T]")
               (inst?)
               (inst -1 "vert(G!1)")
               (assert)
               (hide 2)
               (grind))))))))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "separable?")
   (expand "min_sep_set")
   (lemma
    "min_in[seps(G!1, s!1, t!1),
                    (LAMBDA (v: seps(G!1, s!1, t!1)): card(v)),
                    (LAMBDA (v: seps(G!1, s!1, t!1)): TRUE)]")
   (("1"
     (typepred
      "min[seps(G!1, s!1, t!1), (LAMBDA (v: seps(G!1, s!1, t!1)): card(v)),
                 (LAMBDA (v: seps(G!1, s!1, t!1)): TRUE)]")
     (expand "minimal?")
     (assert)
     (flatten)
     (assert))
    ("2" (lemma "sep_set_exists") (inst?))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "min_sep_set")
   (lemma
    "min_is_min[seps(G!1, s!1, t!1),
                    (LAMBDA (v: seps(G!1, s!1, t!1)): card(v)),
                    (LAMBDA (v: seps(G!1, s!1, t!1)): TRUE)]")
   (("1"
     (inst -1 "V!1")
     (("1" (beta) (propax))
      ("2"
       (hide 2)
       (ground)
       (("1"
         (expand "separates")
         (flatten)
         (inst 4 "gen_seq1(G!1,s!1)")
         (expand "walk_from?")
         (expand "gen_seq1")
         (expand "walk?")
         (expand "verts_in?")
         (skosimp*)
         (expand "del_verts")
         (expand "difference")
         (expand "member")
         (propax))
        ("2"
         (expand "separates")
         (flatten)
         (inst 4 "gen_seq2(G!1,s!1,t!1)")
         (expand "walk_from?")
         (expand "gen_seq2")
         (expand "del_verts")
         (expand "walk?")
         (split 4)
         (("1"
           (expand "verts_in?")
           (skosimp*)
           (expand "difference")
           (expand "member")
           (ground))
          ("2"
           (skosimp*)
           (expand "finseq_appl")
           (expand "edge?")
           (flatten)
           (assert)
           (skosimp*)
           (expand "dbl")
           (ground))))))))
    ("2" (lemma "sep_set_exists") (inst?))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "separable?")
   (flatten)
   (lemma
    "min_in[seps(G!1, s!1, t!1),
                    (LAMBDA (v: seps(G!1, s!1, t!1)): card(v)),
                    (LAMBDA (v: seps(G!1, s!1, t!1)): TRUE)]")
   (("1"
     (typepred
      "min[seps(G!1, s!1, t!1), (LAMBDA (v: seps(G!1, s!1, t!1)): card(v)),
                 (LAMBDA (v: seps(G!1, s!1, t!1)): TRUE)]")
     (assert)
     (expand "min_sep_set")
     (propax))
    ("2" (lemma "sep_set_exists") (inst?))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred
    "min[seps(G!1, s!1, t!1), (LAMBDA (v: seps(G!1, s!1, t!1)): card(v)),
                 (LAMBDA (v: seps(G!1, s!1, t!1)): TRUE)]")
   (("1"
     (hide -1 -2 -3)
     (expand "minimal?")
     (inst -1 "remove(v!1,(min_sep_set(G!1, s!1, t!1)))")
     (("1"
       (rewrite "card_remove[T]")
       (assert)
       (expand "min_sep_set" -1)
       (assert))
      ("2"
       (split 1)
       (("1"
         (flatten)
         (lemma "min_sep_set_edge")
         (inst?)
         (split -1)
         (("1" (replace -1) (propax))
          ("2" (hide -1) (expand "separable?") (flatten) (assert))))
        ("2"
         (flatten)
         (ground)
         (lemma "min_sep_set_seps")
         (inst?)
         (assert)
         (expand "separates")
         (flatten)
         (expand "remove")
         (expand "member")
         (assert)
         (skosimp*)
         (inst 3 "w!1")
         (expand "walk_from?")
         (flatten)
         (expand "walk?")
         (flatten)
         (assert)
         (split 3)
         (("1"
           (hide -4)
           (expand "verts_in?")
           (skosimp*)
           (expand "del_verts")
           (expand "difference")
           (expand "member")
           (inst -3 "i!1")
           (flatten)
           (assert))
          ("2"
           (hide -3)
           (skosimp*)
           (inst?)
           (assert)
           (expand "edge?")
           (flatten)
           (expand "finseq_appl")
           (expand "del_verts")
           (flatten)
           (assert)
           (skosimp*)
           (expand "dbl")
           (inst -7 "v!2")
           (assert)
           (split -7)
           (("1" (propax))
            ("2"
             (case-replace "v!1 = v!2")
             (("1"
               (hide -1 -3 -5 -6 -7 -8 -9 1 2 3 4 5)
               (reveal -9)
               (expand "verts_in?")
               (expand "del_verts")
               (expand "difference")
               (expand "member")
               (split -3)
               (("1" (inst?) (flatten) (assert))
                ("2" (inst?) (flatten) (assert))))
              ("2" (assert))))))))))))
    ("2" (lemma "sep_set_exists") (inst?))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (split +)
   (("1"
     (flatten)
     (hide -2)
     (expand "verts_in?")
     (skosimp*)
     (expand "del_verts")
     (expand "intersection")
     (expand "empty?")
     (expand "difference")
     (expand "member")
     (inst?)
     (assert)
     (inst?)
     (assert)
     (expand "verts_of")
     (inst?)
     (expand "finseq_appl")
     (propax))
    ("2"
     (skosimp*)
     (expand "edge?")
     (inst?)
     (assert)
     (flatten)
     (assert)
     (expand "del_verts")
     (expand "empty?")
     (expand "intersection")
     (expand "member")
     (skosimp*)
     (inst?)
     (expand "verts_of")
     (assert)
     (expand "dbl")
     (split -3)
     (("1" (inst?) (assert)) ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (lemma "card_eq_bij[T,Dbl]")
   (expand "deg")
   (inst?)
   (assert)
   (hide 2)
   (inst 1 "(LAMBDA (vv: (adj_verts(G!1, s!1))): dbl[T](s!1,vv))")
   (("1"
     (expand "bijective?")
     (prop)
     (("1"
       (expand "injective?")
       (skosimp*)
       (case "dbl[T](s!1, x1!1)(x1!1) = dbl[T](s!1, x2!1)(x1!1)")
       (("1"
         (case "dbl[T](s!1, x1!1)(x2!1) = dbl[T](s!1, x2!1)(x2!1)")
         (("1" (hide -3) (expand "dbl") (ground)) ("2" (assert))))
        ("2" (assert))))
      ("2"
       (expand "surjective?")
       (skosimp*)
       (typepred "y!1")
       (skosimp*)
       (replace -1)
       (case "s!1 = x!1 OR s!1 = y!2")
       (("1"
         (split -1)
         (("1"
           (replace -1)
           (inst 2 "y!2")
           (expand "adj_verts")
           (inst + "dbl[T](x!1, y!2)")
           (("1" (assert) (expand "dbl") (propax))
            ("2" (inst?) (expand "dbl") (assert))))
          ("2"
           (inst 2 "x!1")
           (("1"
             (apply-extensionality 2 :hide? t)
             (expand "dbl")
             (iff 1)
             (ground))
            ("2"
             (expand "adj_verts")
             (inst?)
             (("1" (assert) (expand "dbl") (propax))
              ("2" (inst?) (assert))))))))
        ("2"
         (hide 3)
         (expand "incident_edges")
         (flatten)
         (hide -1)
         (expand "dbl")
         (assert))))))
    ("2"
     (skosimp*)
     (prop)
     (("1"
       (inst?)
       (typepred "vv!1")
       (expand "adj_verts")
       (skosimp*)
       (assert))
      ("2"
       (typepred "vv!1")
       (expand "adj_verts")
       (skosimp*)
       (expand "incident_edges")
       (flatten)
       (lemma "edge_has_2_verts")
       (inst?)
       (inst?)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "separable?")
   (flatten)
   (lemma "min_sep_set_card")
   (inst -1 "G!1" "_" "s!1" "t!1")
   (copy -1)
   (inst -1 "adj_verts(G!1,s!1)")
   (inst -2 "adj_verts(G!1,t!1)")
   (split -1)
   (("1"
     (split -2)
     (("1"
       (expand "sep_num")
       (lemma "adj_verts_lem")
       (inst?)
       (replace -1)
       (hide -1)
       (lemma "adj_verts_lem")
       (inst?)
       (replace -1)
       (hide -1)
       (expand "min")
       (lift-if)
       (ground))
      ("2"
       (hide -1 4)
       (expand "separates")
       (expand "adj_verts")
       (prop)
       (("1"
         (skosimp*)
         (expand "incident_edges")
         (flatten)
         (expand "edge?")
         (lemma "edge_has_2_verts")
         (inst?)
         (inst?)
         (assert))
        ("2"
         (skosimp*)
         (expand "walk_from?")
         (flatten)
         (expand "walk?")
         (expand "del_verts")
         (expand "edge?")
         (flatten)
         (expand "verts_in?")
         (expand "finseq_appl")
         (assert)
         (inst -4 "length(w!1)-2")
         (assert)
         (flatten)
         (assert)
         (inst -5 "seq(w!1)(length(w!1)-2)")
         (split -5)
         (("1" (expand "dbl") (propax))
          ("2"
           (inst 1
            "dbl[T](seq(w!1)(length(w!1) - 2),seq(w!1)(length(w!1) - 1))")
           (("1"
             (split 1)
             (("1" (expand "incident_edges") (expand "dbl") (propax))
              ("2" (expand "dbl") (propax)) ("3" (assert))))
            ("2" (inst?) (assert))))))))))
    ("2"
     (hide -1 4)
     (expand "separates")
     (expand "adj_verts")
     (prop)
     (("1"
       (expand "incident_edges")
       (skosimp*)
       (expand "edge?")
       (assert)
       (lemma "edge_has_2_verts")
       (inst?)
       (inst -1 "e!1")
       (assert))
      ("2"
       (skosimp*)
       (expand "walk_from?")
       (flatten)
       (expand "walk?")
       (flatten)
       (inst -4 "0")
       (assert)
       (expand "del_verts")
       (expand "edge?")
       (expand "finseq_appl")
       (flatten)
       (inst -5 "seq(w!1)(1)")
       (split -5)
       (("1" (expand "dbl") (propax))
        ("2"
         (inst 1 "dbl[T](seq(w!1)(0),seq(w!1)(1))")
         (("1" (expand "incident_edges") (expand "dbl") (assert))
          ("2" (inst?) (assert))))))))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "difference")
   (expand "member")
   (inst?)
   (assert)
   (typepred "G!1")
   (inst?)
   (assert)
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: sep_sets
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "finite_subset[T]")
   (inst?)
   (inst -1 "vert(G!1)")
   (assert)
   (hide 2)
   (grind)
   (("1"
     (typepred "G!1")
     (inst?)
     (("1" (assert) (inst?)) ("2" (inst 1 "x!2" "y!1"))))
    ("2"
     (typepred "G!1")
     (inst?)
     (("1" (assert) (inst?)) ("2" (inst 1 "x!2" "y!1"))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (flatten)
   (prop)
   (("1" (hide -2) (expand "verts_in?") (skosimp*) (inst?) (grind))
    ("2"
     (hide -1)
     (skosimp*)
     (inst?)
     (assert)
     (lemma "edges_del_vert")
     (expand "edge?")
     (flatten)
     (inst?)
     (("1" (assert)) ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (expand "walk?")
   (flatten)
   (prop)
   (("1"
     (hide -2)
     (expand "verts_in?")
     (skosimp*)
     (expand "verts_of")
     (inst 2 "i!1")
     (expand "finseq_appl")
     (inst?)
     (expand "del_vert")
     (expand "remove")
     (expand "member")
     (assert))
    ("2"
     (skosimp*)
     (inst?)
     (hide -2)
     (expand "del_vert")
     (expand "edge?")
     (assert)
     (flatten)
     (assert)
     (expand "verts_of")
     (expand "dbl")
     (hide -3 1)
     (split)
     (("1" (inst?) (assert)) ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path?")
   (flatten)
   (split +)
   (("1"
     (hide -2)
     (expand "walk?")
     (flatten)
     (split +)
     (("1"
       (hide -2)
       (expand "verts_in?")
       (expand "del_verts")
       (expand "difference")
       (expand "member")
       (skosimp*)
       (inst?)
       (assert))
      ("2"
       (skosimp*)
       (expand "finseq_appl")
       (inst?)
       (assert)
       (expand "edge?")
       (flatten)
       (assert)
       (expand "del_verts")
       (propax))))
    ("2" (propax))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skolem!)
   (case "FORALL (w: prewalk): NOT walk_from?(G!1, w, s!1, t!1)
                           OR (EXISTS (p: prewalk): path?(G!1, p) AND walk_from?(G!1, p, s!1, t!1))")
   (("1" (flatten) (skosimp*) (inst -1 "w!1") (assert))
    ("2"
     (hide 2)
     (induct "w" 1 "graph_induction_walk")
     (skosimp*)
     (case "(EXISTS (i,j: below(length(w!1))): i /= j AND w!1`seq(i) = w!1`seq(j))")
     (("1"
       (skosimp*)
       (case "i!1 < j!1")
       (("1"
         (inst -3 "w!1^(0,i!1) o w!1^(j!1+1,length(w!1)-1)")
         (("1"
           (split -3)
           (("1" (rewrite "walk?_cut")) ("2" (propax))
            ("3"
             (hide -2 -3 3)
             (expand "o ")
             (expand* "^" min empty_seq)
             (lift-if)
             (ground))))
          ("2"
           (expand "o ")
           (expand* "^" min empty_seq)
           (lift-if)
           (assert))))
        ("2"
         (assert)
         (inst -2 "w!1^(0,j!1) o w!1^(i!1+1,length(w!1)-1)")
         (("1"
           (assert)
           (split -2)
           (("1" (hide 4) (rewrite "walk?_cut")) ("2" (propax))
            ("3"
             (expand "o ")
             (expand* "^" min empty_seq)
             (lift-if)
             (assert))))
          ("2"
           (expand "o ")
           (expand* "^" min empty_seq)
           (lift-if)
           (assert))))))
      ("2"
       (hide -1)
       (inst 2 "w!1")
       (assert)
       (expand "path?")
       (expand "walk_from?")
       (expand "finseq_appl")
       (flatten)
       (assert)
       (skosimp*)
       (inst?)
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: underconstr
script:
  (""
   (skolem * ("G!1" "s!1" "t!1" "_"))
   (induct "w" 1 "graph_induction_walk")
   (skosimp*)
   (case "(EXISTS (i,j: below(length(w!1))): i /= j AND seq(w!1)(i) = seq(w!1)(j))")
   (("1"
     (skosimp*)
     (case "i!1 < j!1")
     (("1"
       (inst -3 "w!1^(0,i!1) o w!1^(j!1+1,length(w!1)-1)")
       (("1"
         (split -3)
         (("1"
           (skosimp*)
           (case " length(w!1 ^ (0, i!1) o w!1 ^ (j!1 + 1, length(w!1) - 1)) <= length(w!1)")
           (("1" (inst 2 "p!1") (assert))
            ("2"
             (hide -1 -2 -3 3)
             (install-rewrites "walks[T]")
             (assert)
             (hide -3)
             (grind))))
          ("2"
           (hide 3)
           (install-rewrites "walks[T]")
           (expand "walk_from?")
           (bddsimp)
           (("1"
             (lemma "walk?_cut")
             (inst -1 "G!1" "w!1" "s!1" "t!1" "i!1" "j!1")
             (prop)
             (("1" (expand "walk_from?") (prop))
              ("2" (expand "walk_from?") (prop))))
            ("2"
             (assert)
             (hide -5)
             (lift-if 1)
             (bddsimp)
             (("1"
               (expand* "^" min empty_seq)
               (lift-if 1)
               (bddsimp)
               (("1" (lift-if) (prop) (("1" (assert)) ("2" (assert))))
                ("2" (assert)) ("3" (lift-if -1) (bddsimp) (assert))))
              ("2"
               (assert)
               (expand* "^" min empty_seq)
               (lift-if 2)
               (lift-if 1)
               (bddsimp)
               (("1" (assert)) ("2" (assert))))))
            ("3" (assert))))
          ("3" (hide -3 3) (typepred "j!1") (grind))))
        ("2" (hide -3 3) (install-rewrites "walks[T]") (assert))))
      ("2"
       (inst -2 "w!1^(0,j!1) o w!1^(i!1+1,length(w!1)-1)")
       (("1"
         (assert)
         (split -2)
         (("1"
           (skosimp*)
           (inst 3 "p!1")
           (bddsimp)
           (hide -1 -2 -5)
           (install-rewrites "walks[T]")
           (assert)
           (expand* "^" min empty_seq)
           (lift-if -1)
           (bddsimp)
           (("1" (assert)) ("2" (assert)) ("3" (assert))))
          ("2"
           (hide 4)
           (lemma "walk?_cut")
           (inst -1 "G!1" "w!1" "s!1" "t!1" "j!1" "i!1")
           (assert))
          ("3"
           (hide -2 4)
           (install-rewrites "walks[T]")
           (assert)
           (expand* "^" min empty_seq)
           (lift-if 1)
           (bddsimp)
           (("1" (assert)) ("2" (assert)) ("3" (assert))))))
        ("2" (hide -2 4) (install-rewrites "walks[T]") (assert))))))
    ("2"
     (hide -1)
     (inst 2 "w!1")
     (assert)
     (install-rewrites "paths[T]")
     (expand "path?")
     (expand "walk_from?")
     (bddsimp)
     (skosimp*)
     (expand "finseq_appl")
     (inst 1 "i!1" "j!1")
     (prop))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (lemma "walk_to_path_less")
   (inst?)
   (prop)
   (skosimp*)
   (inst?)
   (expand "path_from?")
   (expand "walk_from?")
   (prop)
   (expand "from?")
   (prop))


proof_type: f_proof
decl_type: formula
library: graphs
theory: path_ops
signature: nil
run_date: Unknown date
run_time: ----
status: proved-incomplete
description: nil
script:
  (""
   (skosimp*)
   (case "walk_from?(G!1, p!1, u!1, yt!1)")
   (("1"
     (case " walk_from?(G!1, q!1, yt!1, v!1)")
     (("1"
       (lemma "walk_concat")
       (lemma "walk?_rev")
       (inst -1 "G!1" "q!1")
       (expand "walk_from?" (-3 -4))
       (inst -2 "G!1" "u!1" "v!1" "yt!1" "p!1" "rev(q!1)")
       (("1"
         (lemma "rev_rev")
         (case "length(p!1)>1")
         (("1"
           (prop)
           (("1"
             (inst -4 "q!1")
             (replace -4 -1 lr)
             (expand "path_from?")
             (prop)
             (("1"
               (expand "path?")
               (expand "finseq_appl")
               (prop)
               (("1"
                 (expand "walk_from?")
                 (prop)
                 (expand "trunc1")
                 (propax))
                ("2"
                 (skosimp*)
                 (hide -2 -3 -5 -11 -12)
                 (hide -10)
                 (expand "o ")
                 (lift-if -1)
                 (prop)
                 (("1"
                   (lift-if -2)
                   (prop)
                   (("1"
                     (hide -5 -6 -11 -13 -14)
                     (inst -8 "i!1" "j!1")
                     (("1"
                       (assert)
                       (hide -5 -9)
                       (expand "trunc1")
                       (expand "^")
                       (assert))
                      ("2"
                       (expand "trunc1")
                       (expand "^")
                       (expand "empty_seq")
                       (assert))
                      ("3"
                       (expand "trunc1")
                       (expand "^")
                       (expand "empty_seq")
                       (assert))))
                    ("2"
                     (expand "empty?")
                     (expand "member")
                     (inst -13 "seq(trunc1(p!1))(i!1)")
                     (expand "intersection")
                     (expand "member")
                     (prop)
                     (("1"
                       (expand "verts_of")
                       (inst 1 "i!1")
                       (expand "finseq_appl")
                       (propax))
                      ("2"
                       (replace -1 1 lr)
                       (expand "verts_of")
                       (expand "finseq_appl")
                       (inst 1 "j!1-length(trunc1(p!1))")
                       (assert))))))
                  ("2"
                   (lift-if -1)
                   (prop)
                   (("1"
                     (hide -4 -5 -6 -7 -8 -9 -10 -11 -12)
                     (expand "empty?")
                     (expand "member")
                     (inst -4 "seq(trunc1(p!1))(j!1)")
                     (expand "intersection")
                     (expand "member")
                     (prop)
                     (("1"
                       (expand "verts_of")
                       (expand "finseq_appl")
                       (inst 1 "j!1"))
                      ("2"
                       (replace -2 1 rl)
                       (expand "verts_of")
                       (expand "finseq_appl")
                       (inst 1 "i!1-length(trunc1(p!1))")
                       (assert))))
                    ("2"
                     (inst -10 "i!1-length(trunc1(p!1))"
                      "j!1-length(trunc1(p!1))")
                     (("1" (assert)) ("2" (assert))
                      ("3" (assert))))))))))
              ("2"
               (hide (-2 -4 -7 -10 -11 -13 -15))
               (install-rewrites "walks[T]")
               (assert)
               (expand* "^" min empty_seq))))
            ("2"
             (hide-all-but (-10 1))
             (expand "path_from?")
             (install-rewrites "paths[T]")
             (expand "walk_from?")
             (prop)
             (("1" (expand "from?") (prop)) ("2" (expand "from?") (prop))
              ("3" (expand "path?") (prop))))
            ("3"
             (hide-all-but (-1 -4 -5 -6 1 2))
             (install-rewrites "paths[T]")
             (expand "walk_from?")
             (prop)
             (("1" (expand "rev") (propax))
              ("2" (expand "rev") (propax))))))
          ("2"
           (case "length(p!1)=1")
           (("1"
             (replace -1 - lr)
             (assert)
             (prop)
             (("1" (assert)) ("2" (assert))))
            ("2" (assert))))))
        ("2" (expand "rev") (typepred "q!1") (propax))))
      ("2"
       (hide-all-but (-3 1))
       (install-rewrites "paths[T]")
       (expand "path_from?")
       (prop)
       (expand "walk_from?")
       (prop)
       (("1" (expand "from?") (prop)) ("2" (expand "from?") (prop))
        ("3" (expand "path?") (prop))))))
    ("2"
     (hide-all-but (-1 1))
     (expand "path_from?")
     (expand "walk_from?")
     (prop)
     (("1" (expand "from?") (prop)) ("2" (expand "from?") (prop))
      ("3" (expand "path?") (prop))))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: max_upto
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (case "FORALL (S): nonempty?[upto[N]]({y: upto[N] | S(N - y)})")
   (("1"
     (inst 1 "(LAMBDA S: N - min({y: upto[N] | S(N-y)}))")
     (skosimp*)
     (inst?)
     (typepred "min[upto[N]]({y: upto[N] | S!1(N - y)})")
     (("1"
       (prop)
       (("1" (assert)) ("2" (assert))
        ("3" (skosimp*) (inst - "N-x!1") (assert))))
      ("2" (propax))))
    ("2"
     (hide 2)
     (skosimp*)
     (typepred "S!1")
     (expand "nonempty?")
     (expand "empty?")
     (skosimp*)
     (expand "member")
     (inst - "N-x!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "nonempty?")
   (expand "empty?")
   (typepred "P!1")
   (skosimp*)
   (inst -3 "size(S!1)")
   (("1" (expand "member") (expand "is_one_of_size") (inst?) (assert))
    ("2" (rewrite "subgraph_smaller"))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "max_subgraph(G!1, P!1)")
   (hide -1 -2)
   (expand "maximal?")
   (flatten))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "max_subgraph(G!1, P!1)")
   (hide -1 -2)
   (expand "maximal?")
   (flatten)
   (hide -1)
   (inst?)
   (assert))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: max_subgraphs
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (inst 1
    "(LAMBDA (G: graph[T], P: Gpred(G)): choose({S: Subgraph(G) | size(S) = max_size(G,P) AND P(S)}))")
   (("1"
     (skosimp*)
     (expand "maximal?")
     (skosimp*)
     (typepred "max_size(G!1,P!1)")
     (hide -1)
     (expand "max_size")
     (typepred "max({n: upto[size(G!1)] | is_one_of_size(G!1,P!1,n)})")
     (("1"
       (hide -1 -2)
       (inst -1 "size(SS!1)")
       (("1"
         (assert)
         (hide -1 2)
         (expand "is_one_of_size")
         (inst?)
         (assert))
        ("2"
         (hide -1 2)
         (typepred "SS!1")
         (hide -2 -2)
         (rewrite "subgraph_smaller"))))
      ("2" (hide -1 2) (lemma "prep") (rewrite "prep0"))))
    ("2" (skosimp*) (lemma "prep") (inst?))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "tree?")
   (prop)
   (hide 2)
   (expand "singleton_graph")
   (rewrite "card_singleton"))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (typepred "G!1")
   (hide -1)
   (expand "nonempty?")
   (expand "empty?")
   (skosimp*)
   (expand "member")
   (case "isolated?(G!1)")
   (("1"
     (inst 1 "singleton_graph(x!1)")
     (("1" (grind)) ("2" (rewrite "sing_is_tree"))))
    ("2"
     (expand "isolated?")
     (expand "empty?")
     (skosimp*)
     (expand "member")
     (typepred "x!2")
     (skosimp*)
     (replace -1)
     (hide -1)
     (typepred "G!1")
     (inst?)
     (("1"
       (assert)
       (inst?)
       (assert)
       (inst 2
        "(# vert := edg[T](x!3,y!1), edges := singleton[doubleton](dbl[T](x!3,y!1)) #)")
       (("1"
         (expand "edg")
         (expand "subgraph?")
         (prop)
         (("1"
           (typepred "G!1")
           (inst?)
           (("1"
             (hide -2)
             (split -1)
             (("1"
               (inst-cp -1 "y!1")
               (inst -1 "x!3")
               (hide -3)
               (expand "dbl")
               (grind))
              ("2" (propax))))
            ("2" (inst?) (assert))))
          ("2"
           (expand "subset?")
           (skosimp*)
           (expand "member")
           (expand "singleton")
           (assert))
          ("3" (inst -1 "x!3") (expand "dbl") (propax))
          ("4"
           (expand "subset?")
           (skosimp*)
           (expand "member")
           (typepred "G!1")
           (inst?)
           (("1" (assert) (inst?) (assert)) ("2" (inst?) (assert))))
          ("5"
           (expand "subset?")
           (skosimp*)
           (expand "member")
           (expand "singleton")
           (assert))
          ("6" (inst -1 "x!3") (expand "dbl") (propax))))
        ("2"
         (split +)
         (("1"
           (skosimp*)
           (expand "singleton")
           (assert)
           (replace -1)
           (hide -1)
           (expand "edg")
           (propax))
          ("2"
           (hide -1)
           (expand "tree?")
           (flatten)
           (inst 2 "x!3")
           (("1"
             (prop)
             (("1"
               (hide -1 -3 2)
               (expand "deg")
               (expand "incident_edges")
               (case-replace
                "{e: doubleton[T] |
                                                         singleton[doubleton](dbl[T](x!3, y!1))(e) AND e(x!3)} =
                                                         singleton[doubleton](dbl[T](x!3, y!1))")
               (("1"
                 (rewrite "card_singleton[doubleton]")
                 (inst + "x!3" "y!1")
                 (assert))
                ("2"
                 (hide 2)
                 (apply-extensionality 1 :hide? t)
                 (("1" (grind)) ("2" (inst?) (assert))
                  ("3" (skosimp*) (inst?) (assert))))
                ("3" (inst?) (assert))
                ("4" (skosimp*) (inst?) (assert))))
              ("2"
               (case-replace
                "del_vert[T]((# vert := edg[T](x!3, y!1),
                                                                           edges :=
                                                                             singleton[doubleton]
                                                                               (dbl[T](x!3,
                                                                                       y!1))
                                                                           #),
                                                                        x!3) = singleton_graph(y!1)")
               (("1" (hide -1) (rewrite "sing_is_tree"))
                ("2"
                 (hide 2 3)
                 (hide -1 -2)
                 (apply-extensionality :hide? t)
                 (("1"
                   (grind)
                   (apply-extensionality :hide? t)
                   (("1" (grind)) ("2" (skosimp*) (inst?))))
                  ("2"
                   (expand "del_vert")
                   (expand "remove")
                   (expand "singleton_graph")
                   (expand "member")
                   (expand "singleton")
                   (expand "edg")
                   (expand "dbl")
                   (apply-extensionality 1 :hide? t)
                   (iff 1)
                   (ground))
                  ("3"
                   (skosimp*)
                   (expand "edg")
                   (expand "singleton")
                   (assert))
                  ("4" (inst?) (assert))))
                ("3"
                 (skosimp*)
                 (expand "singleton")
                 (expand "edg")
                 (assert))
                ("4" (expand "edg") (inst?) (assert))))))
            ("2" (assert) (expand "edg") (expand "dbl") (propax))))))
        ("3" (inst?) (assert))))
      ("2" (inst?) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "max_subtree")
   (lemma "max_subgraph_in")
   (inst?)
   (("1" (expand "extend") (assert))
    ("2"
     (hide 2)
     (lemma "tree_in")
     (inst?)
     (skosimp*)
     (inst?)
     (expand "extend")
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: max_subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "max_subtree")
   (lemma "max_subgraph_is_max")
   (inst?)
   (("1"
     (expand "extend")
     (ground)
     (hide 2)
     (typepred "SS!1")
     (hide -1 -3)
     (lemma "tree_nonempty")
     (inst?)
     (expand "empty?")
     (expand "nonempty?")
     (propax))
    ("2"
     (hide 2)
     (lemma "tree_in")
     (inst?)
     (skosimp*)
     (inst?)
     (assert)
     (expand "extend")
     (propax))))


proof_type: t_proof
decl_type: tcc
library: graphs
theory: max_subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (prop)
   (("1"
     (lemma "max_subgraph_in")
     (inst?)
     (("1" (expand "extend") (assert))
      ("2"
       (hide 2)
       (lemma "tree_in")
       (inst?)
       (skosimp*)
       (inst?)
       (assert)
       (expand "extend")
       (propax))))
    ("2" (expand "extend") (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "add")
   (expand "member")
   (split)
   (("1" (replace -1 * rl) (hide -1) (expand "dbl") (flatten) (ground))
    ("2" (typepred "G!1") (inst?) (assert) (inst - "x!1") (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: subtrees
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality 1 :hide? t)
   (iff 1)
   (prop)
   (("1"
     (hide -2)
     (lemma "max_subtree_subgraph")
     (inst?)
     (expand "subgraph?")
     (flatten)
     (hide -2)
     (expand "subset?")
     (inst?)
     (expand "member")
     (assert))
    ("2"
     (lemma "max_subtree_tree")
     (inst?)
     (name "TR" "max_subtree(G!1)")
     (case "(EXISTS (v: T): vert(TR)(v))")
     (("1"
       (skosimp*)
       (expand "path_connected?")
       (flatten)
       (inst -5 "v!1" "x!1")
       (("1"
         (assert)
         (skosimp*)
         (case "(EXISTS (j: posnat): j < length(w!1) AND vert(TR)(w!1(j-1)) AND
                                          	                               NOT vert(TR)(w!1(j)))")
         (("1"
           (skosimp*)
           (typepred "w!1")
           (expand "walk?")
           (expand "verts_in?")
           (expand "finseq_appl")
           (flatten)
           (inst - "j!1-1")
           (assert)
           (expand "edge?")
           (name "ss" "seq(w!1)(j!1 - 1)")
           (name "tt" "seq(w!1)(j!1)")
           (name "TP"
                 "(# vert := add(tt,vert(TR)),
                                                                       edges := add(dbl[T](ss,tt),edges(TR)) #)")
           (("1"
             (case "tree?(TP)")
             (("1"
               (lemma "max_subtree_max")
               (inst -1 "G!1" "TP")
               (("1"
                 (replace -4)
                 (hide -2 --4 -5 -6 -7 -8 -9 -10 -11 -13 -14 -15 -16 1 3
                  4)
                 (replace -2 * rl)
                 (hide -2)
                 (expand "size")
                 (rewrite "card_add[T]")
                 (assert))
                ("2"
                 (assert)
                 (replace -4)
                 (inst - "j!1")
                 (replace -3)
                 (hide -1 -12 3 4)
                 (replace -1 * rl)
                 (hide -1)
                 (expand "subgraph?")
                 (lemma "max_subtree_subgraph")
                 (inst?)
                 (replace -10)
                 (hide -10)
                 (expand "subgraph?")
                 (flatten)
                 (split 1)
                 (("1"
                   (expand "subset?")
                   (skosimp*)
                   (expand "member")
                   (expand "add")
                   (expand "member")
                   (split -1)
                   (("1"
                     (inst?)
                     (assert)
                     (replace -1)
                     (hide -1)
                     (reveal -10)
                     (inst?)
                     (assert))
                    ("2" (inst?) (assert))))
                  ("2"
                   (expand "subset?")
                   (expand "member")
                   (skosimp*)
                   (expand "add")
                   (expand "member")
                   (split -1)
                   (("1" (reveal -6) (inst - "j!1-1") (assert))
                    ("2" (hide -2) (inst?) (assert))))))))
              ("2"
               (replace -2)
               (replace -3)
               (expand "tree?")
               (flatten)
               (hide 1)
               (inst 1 "tt")
               (("1"
                 (split 1)
                 (("1"
                   (hide -11)
                   (expand "deg")
                   (case-replace
                    "incident_edges(tt, TP) = singleton[Dbl](dbl[T](ss,tt))")
                   (("1"
                     (rewrite "card_singleton[doubletons[T].doubleton]"))
                    ("2"
                     (hide 2)
                     (expand "incident_edges")
                     (expand "singleton")
                     (replace -1 * rl)
                     (hide -1)
                     (apply-extensionality :hide? t)
                     (("1"
                       (expand "add")
                       (expand "member")
                       (iff)
                       (ground)
                       (("1"
                         (typepred "TR")
                         (hide -2 -3)
                         (inst?)
                         (assert)
                         (inst -1 "tt")
                         (assert))
                        ("2"
                         (replace -1)
                         (hide -1)
                         (expand "dbl")
                         (propax))))
                      ("2" (skosimp*) (inst?) (assert))))))
                  ("2"
                   (replace -1 * rl)
                   (case-replace
                    "del_vert[T]((# vert := add(tt, vert(TR)),
                                                                                      edges :=
                                                                                        add(dbl[T](ss, tt),
                                                                                            edges(TR))
                                                                                      #),
                                                                                   tt) = TR")
                   (("1" (assert))
                    ("2"
                     (hide -11 -12 -13 -14 2 5 6)
                     (apply-extensionality 1 :hide? t)
                     (("1"
                       (expand "del_vert")
                       (apply-extensionality 1 :hide? t)
                       (expand "add")
                       (expand "member")
                       (iff 1)
                       (ground)
                       (("1" (replace -1 * rl) (expand "dbl") (propax))
                        ("2"
                         (typepred "TR")
                         (inst - "x!2")
                         (assert)
                         (inst - "tt")
                         (assert))))
                      ("2"
                       (expand "del_vert")
                       (apply-extensionality 1 :hide? t)
                       (expand "remove")
                       (expand "add")
                       (expand "member")
                       (iff)
                       (ground))))))))
                ("2"
                 (replace -1 * rl)
                 (assert)
                 (expand "add")
                 (propax))))
              ("3"
               (assert)
               (skosimp*)
               (replace -3 * rl)
               (hide -3)
               (assert)
               (expand "add")
               (expand "member")
               (flatten)
               (split -1)
               (("1" (replace -1 * rl) (hide -1) (expand "dbl") (assert))
                ("2"
                 (typepred "TR")
                 (inst?)
                 (assert)
                 (inst?)
                 (assert))))))
            ("2" (inst?) (assert))))
          ("2"
           (expand "finseq_appl")
           (lemma "walk_acr")
           (inst -1 "G!1" "TR" "length(w!1)-1" "w!1")
           (assert)
           (skosimp*)
           (inst?)
           (assert))
          ("3" (skosimp*) (assert))))
        ("2"
         (replace -2 * rl)
         (hide -2)
         (lemma "max_subtree_subgraph")
         (inst?)
         (expand "subgraph?")
         (flatten)
         (hide -2)
         (expand "subset?")
         (expand "member")
         (inst -1 "v!1")
         (assert))))
      ("2"
       (hide -4 2)
       (replace -1)
       (hide -1)
       (expand "tree?")
       (prop)
       (("1" (lemma "card_1_has_1[T]") (inst?) (assert))
        ("2"
         (skosimp*)
         (hide -2 -3)
         (inst?)
         (expand "deg")
         (lemma "card_1_has_1[Dbl]")
         (inst?)
         (assert))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_path_conn
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "path_connected?")
   (flatten)
   (expand "isolated?")
   (expand "empty?" -1)
   (expand "member")
   (lemma "not_singleton_2_vert")
   (inst?)
   (assert)
   (skosimp*)
   (inst -4 "x!1" "y!1")
   (assert)
   (skosimp*)
   (typepred "w!1")
   (expand "walk?")
   (flatten)
   (inst - "0")
   (assert)
   (expand "finseq_appl")
   (assert)
   (expand "edge?")
   (flatten)
   (inst -6 "dbl[T](seq(w!1)(0), seq(w!1)(1))")
   (inst?)
   (assert))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_path_conn
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "NOT singleton?(G!1)")
   (("1"
     (expand "singleton?")
     (expand "size")
     (case "NOT empty?(G!1)")
     (("1"
       (expand "empty?")
       (lemma "card_empty?[T]")
       (inst?)
       (iff)
       (assert)
       (hide 2)
       (case "(EXISTS (y: T): vert(G!1)(y) AND y /= v!1)")
       (("1"
         (skosimp*)
         (hide 2 3 4)
         (expand "path_connected?")
         (flatten)
         (inst -4 "v!1" "y!1")
         (assert)
         (skosimp*)
         (typepred "w!1")
         (expand "walk?")
         (flatten)
         (hide -1)
         (inst - "0")
         (assert)
         (expand "finseq_appl")
         (replace -6)
         (expand "deg")
         (expand "edge?")
         (flatten)
         (lemma "card_empty?[Dbl]")
         (inst?)
         (assert)
         (iff)
         (assert)
         (expand "empty?")
         (expand "member")
         (inst?)
         (("1" (expand "incident_edges") (expand "dbl" 1) (propax))
          ("2" (inst?) (assert))))
        ("2"
         (hide -2 -3 4)
         (lemma "card_2_has_2[T]")
         (inst?)
         (assert)
         (skosimp*)
         (case-replace "x!1=v!1")
         (("1" (inst 2 "y!1") (assert)) ("2" (inst 3 "x!1") (assert))))))
      ("2"
       (hide -3 -4 1 2)
       (expand "empty?")
       (expand "empty?")
       (inst?)
       (expand "member")
       (propax))))
    ("2" (expand "connected?") (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_path_conn
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (hide -1)
   (lemma "deg_1_sing")
   (inst?)
   (assert)
   (skosimp*)
   (hide -1)
   (lemma "other_vert")
   (inst?)
   (inst?)
   (assert)
   (skosimp*)
   (case-replace "u!1 = y1!1")
   (("1"
     (case "walk?[T](G!1, gen_seq2[T](G!1, v!1, y1!1))")
     (("1"
       (inst 3 "gen_seq2(G!1,v!1,y1!1)")
       (expand "walk_from?")
       (assert)
       (hide -1)
       (expand "gen_seq2")
       (propax))
      ("2"
       (expand "walk?")
       (expand "finseq_appl")
       (ground)
       (skosimp*)
       (expand "gen_seq2")
       (lift-if)
       (assert)
       (rewrite "dbl_comm")
       (expand "edge?")
       (assert))))
    ("2"
     (case "vert(del_vert(G!1,v!1))(u!1) AND vert(del_vert(G!1,v!1))(y1!1)")
     (("1"
       (flatten)
       (reveal -5)
       (inst -1 "del_vert(G!1,v!1)")
       (split -1)
       (("1"
         (inst -1 "u!1" "y1!1")
         (assert)
         (skosimp*)
         (inst 4 "gen_seq1(G!1,v!1) o w!1")
         (("1"
           (expand "gen_seq1")
           (expand "o ")
           (expand "walk_from?")
           (flatten)
           (assert)
           (expand "walk?")
           (expand "finseq_appl")
           (expand "verts_in?")
           (split)
           (("1"
             (skosimp*)
             (ground)
             (lemma "vert_seq_lem")
             (expand "finseq_appl")
             (inst?)
             (("1" (assert))
              ("2"
               (assert)
               (typepred "w!1")
               (expand "walk?")
               (expand "finseq_appl")
               (flatten)
               (hide -3)
               (expand "verts_in?")
               (hide -11)
               (expand "del_vert")
               (expand "remove")
               (expand "member")
               (skosimp*)
               (inst?)
               (flatten))))
            ("2"
             (typepred "w!1")
             (expand "walk?")
             (expand "finseq_appl")
             (expand "verts_in?")
             (flatten)
             (skosimp*)
             (case-replace "n!1 = 0")
             (("1"
               (assert)
               (expand "edge?")
               (replace -6)
               (rewrite "dbl_comm")
               (assert))
              ("2"
               (lift-if)
               (assert)
               (inst -3 "n!1-1")
               (assert)
               (expand "edge?")
               (flatten)
               (assert)
               (expand "del_vert" -3)
               (propax))))))
          ("2"
           (prop)
           (("1" (expand "o ") (expand "gen_seq1") (assert))
            ("2"
             (hide -8 -9)
             (expand "gen_seq1")
             (expand* "walk?" "finseq_appl")
             (expand "verts_in?")
             (prop)
             (("1"
               (skosimp*)
               (assert)
               (expand "o ")
               (ground)
               (typepred "w!1")
               (expand* "walk?" "finseq_appl")
               (flatten)
               (hide -3 -4 -5 -6)
               (expand "verts_in?")
               (inst?)
               (expand "del_vert")
               (expand "remove")
               (expand "member")
               (propax))
              ("2"
               (assert)
               (expand "o ")
               (assert)
               (skosimp*)
               (case-replace "n!1 = 0")
               (("1"
                 (expand "walk_from?")
                 (flatten)
                 (lift-if)
                 (assert)
                 (replace -3)
                 (expand "edge?")
                 (rewrite "dbl_comm")
                 (assert))
                ("2"
                 (typepred "w!1")
                 (expand* "walk?" "finseq_appl")
                 (expand "verts_in?")
                 (flatten)
                 (inst -3 "n!1-1")
                 (("1"
                   (assert)
                   (expand "edge?")
                   (flatten)
                   (assert)
                   (lemma "edges_del_vert")
                   (inst?)
                   (assert))
                  ("2" (inst?) (("1" (assert)) ("2" (assert))))))))))))))
        ("2" (rewrite "size_del_vert") (assert))))
      ("2"
       (hide -6 -7 5)
       (expand "del_vert")
       (expand "remove")
       (expand "member")
       (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_path_conn
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "TR" 1 "graph_induction_vert")
   (skosimp*)
   (hide -1)
   (expand "tree?")
   (split)
   (("1"
     (rewrite "card_one[T]")
     (skosimp*)
     (replace -1)
     (hide -1)
     (hide 2)
     (grind))
    ("2"
     (skosimp*)
     (case-replace "x!1 =v!1")
     (("1"
       (reveal -1)
       (lemma "thw_A")
       (inst -1 "G!1" "v!1" "y!1")
       (replace -2)
       (hide -2)
       (assert))
      ("2"
       (case-replace "y!1 = v!1")
       (("1"
         (lemma "thw_A")
         (inst -1 "G!1" "v!1" "x!1")
         (reveal -2)
         (replace -1)
         (hide -1)
         (assert)
         (skosimp*)
         (lemma "walk?_reverse")
         (inst?)
         (assert))
        ("2"
         (reveal -1)
         (inst?)
         (split -1)
         (("1"
           (inst -1 "x!1" "y!1")
           (assert)
           (split -1)
           (("1"
             (skosimp*)
             (inst 4 "w!1")
             (("1"
               (expand "walk_from?")
               (flatten)
               (assert)
               (typepred "w!1")
               (lemma "walk?_del_vert")
               (inst?)
               (assert))
              ("2" (lemma "walk?_del_vert") (inst?) (inst?) (assert))))
            ("2"
             (hide -1 -2 5)
             (expand "del_vert")
             (expand "remove")
             (expand "member")
             (propax))
            ("3"
             (hide -1 -2 5)
             (expand "del_vert")
             (expand "remove")
             (expand "member")
             (propax))))
          ("2" (rewrite "size_del_vert") (assert))))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_path_conn
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "G" 1 "graph_induction_vert")
   (skosimp*)
   (case "(FORALL v: vert(G!1)(v) IMPLIES deg(v,G!1) > 0)")
   (("1"
     (hide -2)
     (expand "connected?")
     (flatten)
     (case "nonempty?(vert(G!1))")
     (("1"
       (name "MTR" "max_subtree(G!1)")
       (("1"
         (lemma "max_tree_all_verts")
         (assert)
         (inst?)
         (assert)
         (case "tree?(MTR)")
         (("1"
           (expand "tree?" -1)
           (split)
           (("1" (expand "singleton?") (expand "size") (assert))
            ("2"
             (skosimp*)
             (name "TCd" "del_vert(MTR,v!1)")
             (replace -1)
             (inst 2 "v!1")
             (split 2)
             (("1"
               (hide -4 -7 -8 -9 2)
               (hide -4)
               (expand "deg")
               (case "subset?(incident_edges(v!1, MTR),incident_edges(v!1, G!1))")
               (("1" (lemma "card_subset[Dbl]") (inst?) (assert))
                ("2"
                 (hide -2 2)
                 (expand "subset?")
                 (skosimp*)
                 (expand "member")
                 (expand "incident_edges")
                 (assert)
                 (reveal -2)
                 (lemma "max_subtree_subgraph")
                 (inst?)
                 (replace -2)
                 (hide -2)
                 (expand "subgraph?")
                 (flatten)
                 (hide -1)
                 (expand "subset?")
                 (inst?)
                 (expand "member")
                 (assert))))
              ("2"
               (reveal -2)
               (inst -1 "del_vert(G!1, v!1)")
               (split -1)
               (("1" (propax))
                ("2"
                 (lemma "max_tree_all_verts")
                 (inst?)
                 (assert)
                 (hide -8)
                 (expand "path_connected?")
                 (prop)
                 (("1"
                   (hide 1)
                   (hide -2 -3 -4 -5 -6 -7 -9)
                   (expand "empty?")
                   (lemma "card_empty?[T]")
                   (inst?)
                   (assert)
                   (iff)
                   (assert)
                   (hide -2)
                   (expand "del_vert")
                   (rewrite "card_remove")
                   (expand "singleton?")
                   (expand "size")
                   (assert))
                  ("2"
                   (skosimp*)
                   (lemma "tree_has_walk")
                   (inst -1 "TCd" "x!1" "y!1")
                   (expand "walk_from?")
                   (split -1)
                   (("1"
                     (skosimp*)
                     (lemma "tree_has_walk")
                     (inst -1 "TCd" "x!1" "y!1")
                     (expand "walk_from?")
                     (split -1)
                     (("1"
                       (skosimp*)
                       (inst 1 "w!1")
                       (("1" (assert))
                        ("2"
                         (hide -1 -2)
                         (hide -5 -9 2 3)
                         (typepred "w!1")
                         (replace -5 * rl)
                         (hide -5)
                         (replace -7 * rl)
                         (hide -7)
                         (expand "walk?")
                         (flatten)
                         (split 1)
                         (("1"
                           (hide -3)
                           (expand "verts_in?")
                           (expand "del_vert")
                           (skosimp*)
                           (inst?)
                           (expand "remove")
                           (expand "member")
                           (flatten)
                           (assert))
                          ("2"
                           (skosimp*)
                           (inst?)
                           (assert)
                           (expand "edge?")
                           (flatten)
                           (typepred "max_subtree(G!1)")
                           (hide -1 -2)
                           (expand "subgraph?")
                           (flatten)
                           (hide -1)
                           (expand "subset?")
                           (expand "member")
                           (inst?)
                           (hide -3)
                           (expand "del_vert")
                           (flatten)
                           (assert))))))
                      ("2"
                       (typepred "x!1")
                       (hide -3)
                       (hide 2 3 4)
                       (hide -2 -4)
                       (replace -2 * rl)
                       (expand "del_vert" 1)
                       (expand "remove")
                       (expand "member")
                       (assert)
                       (expand "del_vert" -1)
                       (expand "remove")
                       (expand "member")
                       (flatten)
                       (assert))
                      ("3"
                       (typepred "y!1")
                       (hide -2 -3 -6 -9 -10 2 3 4)
                       (replace -2 * rl)
                       (hide -2)
                       (expand "del_vert")
                       (expand "remove")
                       (expand "member")
                       (flatten)
                       (assert))
                      ("4"
                       (assert)
                       (inst 2 "gen_seq1(del_vert(G!1,v!1),y!1)")
                       (("1" (expand "gen_seq1") (propax))
                        ("2"
                         (lemma "gen_seq1_is_walk")
                         (inst?)
                         (flatten)
                         (assert))))))
                    ("2"
                     (typepred "x!1")
                     (hide -3)
                     (hide 2 3 4)
                     (replace -2 * rl)
                     (expand "del_vert" 1)
                     (expand "remove")
                     (expand "member")
                     (assert)
                     (expand "del_vert" -1)
                     (expand "remove")
                     (expand "member")
                     (flatten)
                     (assert))
                    ("3"
                     (typepred "y!1")
                     (hide -4 -7 -8 2 3 4)
                     (replace -2 * rl)
                     (hide -2)
                     (expand "del_vert")
                     (expand "remove")
                     (expand "member")
                     (flatten)
                     (assert))
                    ("4"
                     (assert)
                     (inst 2 "gen_seq1(del_vert(G!1,v!1),y!1)")
                     (("1" (expand "gen_seq1") (propax))
                      ("2"
                       (lemma "gen_seq1_is_walk")
                       (inst?)
                       (flatten)
                       (assert))))))))
                ("3" (rewrite "size_del_vert") (assert))))))))
          ("2" (assert))))
        ("2" (propax))))
      ("2"
       (expand "nonempty?")
       (expand "path_connected?" -3)
       (flatten)
       (expand "empty?" 1)
       (propax))))
    ("2"
     (skosimp*)
     (lemma "pic_A")
     (inst?)
     (assert)
     (inst 1 "v!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_piece_path
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (apply-extensionality 2 :hide? t)
   (("1"
     (apply-extensionality 1 :hide? t)
     (iff 1)
     (prop)
     (("1"
       (replace -2)
       (hide -2)
       (replace -2)
       (hide -2)
       (expand "union")
       (expand "union")
       (expand "member")
       (expand "subgraph")
       (assert)
       (expand "difference")
       (expand "member")
       (skosimp*)
       (typepred "G!1")
       (inst?)
       (assert)
       (inst-cp -1 "x!2")
       (inst -1 "x!3")
       (assert)
       (case-replace "x!2 = x!3")
       (lemma "edge_has_2_verts")
       (inst -1 "x!1" "x!2" "x!3")
       (assert)
       (inst 3 "x!3" "x!2")
       (ground)
       (expand "edg")
       (assert))
      ("2"
       (expand "union")
       (expand "union")
       (expand "member")
       (prop)
       (("1" (replace -2) (expand "subgraph") (assert))
        ("2" (replace -3) (expand "subgraph") (assert))))))
    ("2"
     (hide 2)
     (replace -1)
     (hide -1)
     (replace -1)
     (hide -1)
     (apply-extensionality 1 :hide? t)
     (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_piece_path
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "empty?(G!1)")
   (("1" (expand "piece_connected?") (flatten))
    ("2"
     (expand "empty?")
     (expand "empty?")
     (expand "member")
     (skosimp*)
     (name "V"
           "{u: T | (EXISTS (w: Walk(G!1)): w(0) = u AND w(length(w)-1) = x!1) OR u = x!1}")
     (ground)
     (expand "finseq_appl")
     (name "H" "subgraph(G!1,V)")
     (name "W" "difference(vert(G!1),V)")
     (name "K" "subgraph(G!1,W)")
     (case "(EXISTS (u,w:T): vert(H)(u) AND vert(K)(w) AND u /= w AND edges(G!1)(edg[T](u,w)))")
     (("1"
       (skosimp*)
       (hide 1)
       (expand "piece_connected?")
       (flatten)
       (inst -9 "K" "H")
       (assert)
       (split -9)
       (("1"
         (expand "intersection")
         (expand "empty?")
         (skosimp*)
         (expand "member")
         (flatten)
         (hide -3 -4 -5 -9 -10 1)
         (replace -3 * rl)
         (hide -3)
         (replace -3 * rl)
         (hide -3)
         (replace -3 * rl)
         (hide -3)
         (grind))
        ("2"
         (hide -8 1 2)
         (case "V(u!1)")
         (("1"
           (case "V(w!1)")
           (("1"
             (hide -5 -8 -9)
             (expand "difference")
             (replace -6 * rl)
             (expand "subgraph")
             (replace -5 * rl)
             (assert)
             (hide -5 -6)
             (expand "member")
             (propax))
            ("2"
             (hide -2 -6 -7)
             (replace -4 * rl)
             (hide -4)
             (expand "subgraph")
             (flatten)
             (replace -5 * rl)
             (hide -5)
             (beta)
             (flatten)
             (split -1)
             (("1"
               (skosimp*)
               (case-replace "u!1 = w!1")
               (("1" (inst 1 "w!2") (assert))
                ("2"
                 (inst + "gen_seq1(G!1,w!1) o w!2")
                 (("1" (expand "o ") (expand "gen_seq1") (propax))
                  ("2"
                   (lemma "walk_concat_edge")
                   (inst - "G!1" "w!1" "u!1" "w!1" "x!1"
                    "gen_seq1[T](G!1, w!1)" "w!2")
                   (expand "walk_from?")
                   (assert)
                   (split +)
                   (("1"
                     (assert)
                     (hide -1)
                     (expand "o ")
                     (expand "gen_seq1")
                     (assert))
                    ("2"
                     (assert)
                     (hide 1)
                     (expand "edg")
                     (expand "edge?")
                     (rewrite "dbl_comm")
                     (assert)
                     (rewrite "gen_seq1_is_walk")
                     (expand "gen_seq1")
                     (propax))))))))
              ("2"
               (replace -1)
               (hide -1)
               (inst + "gen_seq2(G!1,w!1,x!1)")
               (("1" (expand "gen_seq2") (propax))
                ("2"
                 (lemma "edge_to_walk")
                 (inst?)
                 (assert)
                 (expand "edg")
                 (rewrite "dbl_comm"))))))))
          ("2"
           (hide -2 -3 -4 -5 -7)
           (expand "subgraph")
           (replace -2 * rl)
           (hide -2)
           (assert))))
        ("3"
         (expand "empty?")
         (expand "empty?")
         (inst -1 "w!1")
         (expand "member")
         (propax))
        ("4"
         (expand "empty?")
         (expand "empty?")
         (inst -1 "u!1")
         (expand "member")
         (propax))))
      ("2"
       (hide 2)
       (lemma "union_edge_disj")
       (inst -1 "G!1" "subgraph(G!1, V)" "subgraph(G!1, W)" "V")
       (assert)
       (replace -2)
       (replace -4)
       (split -1)
       (("1"
         (hide 1)
         (expand "piece_connected?")
         (prop)
         (inst -7 "H" "K")
         (assert)
         (split -7)
         (("1"
           (hide -1 -6 2)
           (replace -1 * rl)
           (hide -1)
           (replace -1 * rl)
           (hide -1)
           (replace -1 * rl)
           (hide -1)
           (replace -1 * rl)
           (hide -1)
           (grind))
          ("2"
           (replace -5 * rl)
           (expand "empty?")
           (hide -2 -3 -4 -5)
           (replace -2 * rl)
           (hide -2)
           (expand "subgraph")
           (expand "empty?")
           (inst -1 "x!1")
           (expand "member")
           (propax))
          ("3"
           (hide -7)
           (reveal 2)
           (expand "path_connected?")
           (skosimp*)
           (case "vert(K)(x!2) OR vert(K)(y!1)")
           (("1" (hide -3 -4 -5 -6 -7 1 2 3) (grind))
            ("2"
             (case "vert(H)(x!2) AND vert(H)(y!1)")
             (("1"
               (flatten)
               (hide -3 -4 -5 -6 1 2)
               (replace -4 * rl)
               (hide -4)
               (replace -3 * rl)
               (hide -3)
               (expand "subgraph")
               (case-replace "x!2 = x!1")
               (("1"
                 (case-replace "y!1 = x!1")
                 (("1"
                   (inst 1 "gen_seq1(G!1,x!1)")
                   (("1" (expand "gen_seq1") (propax))
                    ("2" (lemma "gen_seq1_is_walk") (inst?) (assert))))
                  ("2"
                   (assert)
                   (skosimp*)
                   (assert)
                   (inst + "rev(w!1)")
                   (("1" (expand "rev") (propax))
                    ("2"
                     (rewrite "walk?_rev")
                     (expand "rev")
                     (ground))))))
                ("2"
                 (ground)
                 (("1"
                   (skosimp*)
                   (case "y!1 = x!2")
                   (("1"
                     (replace -1)
                     (hide -1)
                     (inst + "gen_seq1(G!1,x!2)")
                     (("1" (expand "gen_seq1") (propax))
                      ("2" (rewrite "gen_seq1_is_walk"))))
                    ("2"
                     (lemma "walk_merge")
                     (inst -1 "G!1" "w!1" "w!2" "x!2" "y!1" "x!1")
                     (expand "walk_from?")
                     (assert)
                     (skosimp*)
                     (inst + "p!1")
                     (assert))))
                  ("2" (replace -1) (propax))))))
              ("2"
               (hide 3 4)
               (case "disjoint?(vert(H),vert(K))")
               (("1"
                 (hide -2 -3 -4 -5 -6)
                 (expand "disjoint?")
                 (expand "intersection")
                 (expand "empty?")
                 (expand "member")
                 (inst-cp -1 "x!2")
                 (inst -1 "y!1")
                 (case "vert(G!1) = union(vert(H),vert(K))")
                 (("1"
                   (typepred "y!1")
                   (typepred "x!2")
                   (expand "union")
                   (expand "member")
                   (replace -3)
                   (hide -3)
                   (beta)
                   (flatten)
                   (ground))
                  ("2"
                   (hide -1 2 3 4 5 6)
                   (reveal -4)
                   (replace -1)
                   (hide -1)
                   (grind))))
                ("2"
                 (hide -1 -2 -6 2 3 4)
                 (replace -1 * rl)
                 (hide -1)
                 (replace -1 * rl)
                 (hide -1)
                 (replace -1 * rl)
                 (hide -1)
                 (grind))))))))))
        ("2" (propax))))
      ("3" (skosimp*) (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "piece_connected?")
   (prop)
   (("1"
     (rewrite "empty?_rew")
     (expand "singleton?")
     (expand "size")
     (assert))
    ("2"
     (skosimp*)
     (expand "singleton?")
     (replace -1)
     (hide -1)
     (expand "empty?")
     (expand "empty?")
     (expand "member")
     (skosimp*)
     (expand "intersection")
     (expand "member")
     (inst-cp -3 "x!1")
     (inst -3 "x!2")
     (ground)
     (expand "size")
     (rewrite "card_one[T]")
     (skosimp*)
     (case "vert(union(H1!1, H2!1))(x!1) = singleton(x!3)(x!1)")
     (("1"
       (case "vert(union(H1!1, H2!1))(x!2) = singleton(x!3)(x!2)")
       (("1" (hide -5) (grind)) ("2" (assert))))
      ("2" (assert))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "piece_connected?")
   (prop)
   (skosimp*)
   (rewrite "empty?_rew")
   (rewrite "empty?_rew")
   (rewrite "empty?_rew")
   (expand "empty?")
   (expand "size")
   (case "card(vert(G!1)) >= card(vert(H1!1)) + card(vert(H2!1))")
   (("1" (assert))
    ("2"
     (hide 2 3 4)
     (replace -1)
     (hide -1)
     (expand "union")
     (rewrite "card_union[T]")
     (case "card(intersection(vert(H1!1), vert(H2!1))) = 0")
     (("1" (assert))
      ("2"
       (hide 2)
       (rewrite "card_empty?[T]")
       (expand "empty?")
       (propax))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (expand "union")
   (expand "union")
   (expand "member")
   (assert)
   (typepred "H2!1")
   (inst?)
   (assert)
   (inst -1 "vo!1")
   (assert)
   (hide -2 -4 1)
   (grind))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "NOT vert(H2!1)(vo!1)")
   (("1"
     (hide -2)
     (apply-extensionality 4 :hide? t)
     (("1"
       (hide 3 4)
       (apply-extensionality 1 :hide? t)
       (grind)
       (hide -3)
       (typepred "H2!1")
       (inst?)
       (assert)
       (inst?)
       (assert))
      ("2" (hide 3 4) (apply-extensionality 1 :hide? t) (grind))))
    ("2" (hide 1 2 3) (grind))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (hide -3 3)
   (lemma "deg_edge_exists")
   (inst?)
   (assert)
   (skosimp*)
   (case "edges(H1!1)(e!1)")
   (("1"
     (hide -3)
     (typepred "H1!1")
     (inst?)
     (assert)
     (typepred "e!1")
     (skosimp*)
     (hide -3 -4 -6)
     (replace -1)
     (hide -1)
     (inst-cp -1 "x!1")
     (inst -1 "y!1")
     (expand "dbl")
     (case "vo!1 = x!1")
     (("1"
       (replace -1 * rl)
       (hide -1)
       (hide -4 2 3)
       (expand "empty?")
       (expand "empty?")
       (expand "member")
       (inst -4 "y!1")
       (grind))
      ("2"
       (hide -4 3 4)
       (expand "empty?")
       (expand "empty?")
       (inst -4 "x!1")
       (expand "member")
       (grind))))
    ("2"
     (hide -4 -6 2 3)
     (lemma "edge_not_across")
     (inst?)
     (inst?)
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (name "GP" "del_vert(G!1,vo!1)")
   (name "H1P" "del_vert(H1!1, vo!1)")
   (case "GP = union(H1P,H2!1)")
   (("1"
     (case "NOT piece_connected?(GP)")
     (("1"
       (inst?)
       (assert)
       (hide -1 -2 -5 -6 -8 -9 1 3 4)
       (replace -1 * rl)
       (hide -1)
       (expand "size")
       (expand "del_vert")
       (rewrite "card_remove")
       (lift-if)
       (ground)
       (hide 2)
       (replace -2)
       (hide -2)
       (grind))
      ("2"
       (hide -5 -6 -7 -8)
       (expand "piece_connected?")
       (flatten)
       (inst -1 "H1P" "H2!1")
       (assert)
       (split -1)
       (("1"
         (hide -3 -4 2)
         (hide -1)
         (replace -1 * rl)
         (hide -1)
         (hide -1 2 3)
         (expand "empty?")
         (skosimp*)
         (inst?)
         (grind))
        ("2"
         (reveal -3 -4)
         (lemma "H1P_not_empty")
         (inst?)
         (inst -1 "G!1" "H2!1")
         (assert))))))
    ("2"
     (hide -5 -6 -8)
     (lemma "lem1")
     (inst -1 "H1!1" "H2!1" "vo!1")
     (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (case "vert(H1!1)(vo!1)")
   (("1" (lemma "cip0") (inst -1 "G!1" "H1!1" "H2!1" "vo!1") (assert))
    ("2"
     (lemma "cip0")
     (inst -1 "G!1" "H2!1" "H1!1" "vo!1")
     (rewrite "intersection_commutative")
     (case-replace "union(H2!1, H1!1) = union(H1!1, H2!1)")
     (("1"
       (assert)
       (prop)
       (hide -1 -2 -3 -4 -7)
       (replace -1)
       (hide -1)
       (grind))
      ("2"
       (hide -1 -2 -3 -4 -5 -6 -7 -8 -9 2 3 4)
       (expand "union")
       (prop)
       (("1" (rewrite "union_commutative"))
        ("2" (rewrite "union_commutative"))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_conn_piece
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (induct "G" 1 "graph_induction_vert")
   (skosimp*)
   (hide -1)
   (lemma "not_piece_has_2")
   (inst?)
   (assert)
   (expand "piece_connected?")
   (rewrite "connected_not_empty")
   (assert)
   (skosimp*)
   (case "(FORALL (vo: (vert(G!1))): deg(vo,G!1) > 0 IMPLIES NOT connected?(del_vert(G!1,vo)))")
   (("1"
     (expand "connected?" -3)
     (prop)
     (("1" (use "singleton_piece") (assert))
      ("2" (skosimp*) (inst -3 "v!1") (assert))))
    ("2"
     (skosimp*)
     (assert)
     (reveal -2)
     (case "vert(H1!1)(vo!1)")
     (("1" (lemma "cip3") (inst?) (inst -1 "vo!1") (assert))
      ("2"
       (lemma "cip3")
       (inst -1 "G!1" "H2!1" "H1!1" "vo!1")
       (case-replace "union(H2!1, H1!1) = union(H1!1, H2!1)")
       (("1"
         (case-replace
          "intersection(vert(H2!1), vert(H1!1)) = intersection(vert(H1!1), vert(H2!1))")
         (("1" (hide -1 -2) (assert))
          ("2"
           (prop)
           (("1"
             (hide -1 -2 -3 -4 -5 -7 3 4)
             (typepred "vo!1")
             (hide -2)
             (grind)
             (("1"
               (hide -1 -2 -3 -4 -5 -6 -7 -8 -9 2 3 4)
               (apply-extensionality 1 :hide? t)
               (grind))
              ("2"
               (hide -1 -2 -3 -4 -5 -6 -7 -8 2 3 4)
               (apply-extensionality 1 :hide? t)
               (grind))))
            ("2"
             (hide -1 -2 -3 -4 -5 -6 -7 -8 1 3 4 5)
             (apply-extensionality 1 :hide? t)
             (grind))))))
        ("2"
         (hide -1 -2 -3 -4 -5 -6 -7 -8 2 3 4)
         (apply-extensionality 1 :hide? t)
         (("1" (apply-extensionality 1 :hide? t) (grind))
          ("2" (apply-extensionality 1 :hide? t) (grind))))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_connected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (iff 1)
   (prop)
   (("1"
     (lemma "conn_implies_piece[T]")
     (inst?)
     (lemma "piece_implies_path[T]")
     (inst?)
     (assert))
    ("2" (lemma "path_implies_conn[T]") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_connected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (iff)
   (prop)
   (("1"
     (lemma "path_implies_conn[T]")
     (lemma "conn_implies_piece[T]")
     (inst?)
     (inst?)
     (assert))
    ("2" (lemma "piece_implies_path[T]") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: graph_connected
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (iff)
   (prop)
   (("1"
     (lemma "piece_implies_path[T]")
     (inst?)
     (lemma "path_implies_conn[T]")
     (inst?)
     (assert))
    ("2" (lemma "conn_implies_piece[T]") (inst?) (assert))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: mappings
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: Valid3.2
script:
  (""
   (skosimp*)
   (split)
   (("1"
     (flatten)
     (expand "path_connected?" -1)
     (skosimp*)
     (expand "empty?" 1)
     (expand "empty?" 1)
     (skosimp*)
     (inst 1 "x!1")
     (expand "member" -1)
     (expand "reachable" 1)
     (split)
     (("1" (propax))
      ("2"
       (apply-extensionality 1)
       (hide 2)
       (iff)
       (split)
       (("1" (bddsimp))
        ("2"
         (flatten)
         (split)
         (("1" (propax))
          ("2"
           (inst -3 "x!1" "x!2")
           (skosimp*)
           (inst 1 "w!1")
           (("1" (expand "walk_from?" 1) (assert))
            ("2" (grind) (typepred "w!1") (grind))))))))))
    ("2"
     (flatten)
     (expand "path_connected?")
     (skosimp*)
     (split)
     (("1"
       (expand "empty?")
       (expand "empty?")
       (inst -1 "x!1")
       (expand "member")
       (propax))
      ("2"
       (skosimp*)
       (expand "reachable")
       (typepred "y!1")
       (typepred "x!2")
       (lemma "extensionality_postulate[T,bool]")
       (inst -1
        "({y: T |          vert(G!1)(y) AND           (EXISTS (w: Seq(G!1)):walk_from?(G!1, w, x!1, y))})"
        "vert(G!1)")
       (flatten)
       (bddsimp -2 -6)
       (("1"
         (hide -2)
         (hide -5)
         (inst-cp -1 "x!2")
         (bddsimp -2 -3)
         (("1"
           (skolem! -1)
           (inst -2 "y!1")
           (beta -2)
           (bddsimp)
           (skolem! -2)
           (lemma "walk?_reverse")
           (inst-cp -1 "G!1" "x!1" "y!1" "w!2")
           (inst -1 "G!1" "x!1" "x!2" "w!1")
           (bddsimp)
           (hide -1 -3)
           (skolem!)
           (skolem! -2)
           (lemma "walk_merge")
           (inst -1 "G!1" "w!4" "w!3" "x!2" "y!1" "x!1")
           (bddsimp)
           (hide -1 -2)
           (expand "walk_from?" -1)
           (assert)
           (skolem! -1)
           (expand "walk?" -1)
           (expand "finseq_appl")
           (inst 1 "p!1")
           (("1" (assert) (flatten) (assert))
            ("2" (expand "walk?" 1) (assert) (grind))))
          ("2" (propax))))
        ("2" (propax))))))))


proof_type: f_proof
decl_type: formula
library: graphs
theory: mappings
signature: nil
run_date: Unknown date
run_time: ----
status: proved-complete
description: nil
script:
  (""
   (skosimp*)
   (split)
   (("1"
     (flatten)
     (expand "path_connected?" -1)
     (skosimp*)
     (expand "empty?" 1)
     (expand "empty?" 1)
     (expand "member" 1)
     (skosimp*)
     (expand "reachable" 1)
     (split)
     (("1"
       (skosimp*)
       (apply-extensionality 1)
       (hide 2)
       (iff 1)
       (split)
       (("1" (bddsimp))
        ("2"
         (bddsimp)
         (inst -4 "x!2" "x!3")
         (expand "walk_from?" +)
         (grind)
         (typepred "w!1")
         (expand "walk?" -2)
         (flatten)
         (expand "verts_in?" -2)
         (inst -2 "i!1"))))
      ("2" (grind))))
    ("2"
     (flatten)
     (lemma "path_reach1")
     (inst -1 "G!1")
     (flatten)
     (hide -1)
     (copy 2)
     (expand "path_connected?" 1)
     (split)
     (("1" (propax))
      ("2"
       (expand "empty?" 2)
       (expand "empty?" 2)
       (hide 1)
       (skosimp*)
       (expand "member" -)
       (inst -2 "x!1")
       (bddsimp)
       (inst 1 "x!1")
       (assert))))))


