Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Quelle  h_menger.prf

  Sprache: Lisp
 

(h_menger
 (path_not_thru 0
  (path_not_thru-1 nil 3251049132
   ("" (skosimp*)
    ((""
      (case "(FORALL (zz: T): NOT separates(G!1,singleton(zz),s!1,t!1))")
      (("1" (inst -1 "z!1")
        (("1" (expand "separates" 1)
          (("1" (expand "singleton")
            (("1" (assert)
              (("1" (skosimp*)
                (("1" (lemma "walk_to_path_from")
                  (("1" (inst?)
                    (("1" (assert)
                      (("1" (hide -2)
                        (("1" (skosimp*)
                          (("1"
                            (case-replace
                             "del_verts(G!1, {y: T | y = z!1}) = del_vert(G!1, z!1)")
                            (("1" (hide -1)
                              (("1" (inst + "p!1"nil nil)) nil)
                             ("2" (hide -1 -2 -3 4)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("1"
                                  (apply-extensionality :hide? t)
                                  (("1"
                                    (iff 1)
                                    (("1"
                                      (expand "del_verts")
                                      (("1"
                                        (expand "del_vert")
                                        (("1"
                                          (ground)
                                          (("1" (inst - "z!1"nil nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (lemma "finite_singleton[T]")
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (expand "singleton")
                                        (("2" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (apply-extensionality :hide? t)
                                  (("1"
                                    (expand "del_verts")
                                    (("1"
                                      (expand "del_vert")
                                      (("1"
                                        (expand "difference")
                                        (("1"
                                          (expand "remove")
                                          (("1"
                                            (expand "member")
                                            (("1"
                                              (iff)
                                              (("1" (ground) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (lemma "finite_singleton[T]")
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (expand "singleton")
                                        (("2" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3"
                                  (lemma "finite_singleton[T]")
                                  (("3"
                                    (inst?)
                                    (("3"
                                      (expand "singleton")
                                      (("3" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("3" (lemma "finite_singleton[T]")
                              (("3"
                                (inst?)
                                (("3"
                                  (expand "singleton")
                                  (("3" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (lemma "finite_singleton[T]")
                      (("2" (inst?)
                        (("2" (expand "singleton")
                          (("2" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (skosimp*)
        (("2" (hide -2)
          (("2" (expand "sep_num")
            (("2" (lemma "min_sep_set_card")
              (("2" (inst?)
                (("2" (assert)
                  (("2" (rewrite "card_singleton")
                    (("2" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((singleton const-decl "(singleton?)" sets nil)
    (singleton? const-decl "bool" sets nil)
    (separates const-decl "bool" sep_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (graph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pregraph type-eq-decl nil graphs nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil h_menger nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set" finite_sets nil)
    (walk_to_path_from formula-decl nil path_ops nil)
    (remove const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (difference const-decl "set" sets nil)
    (finite_singleton judgement-tcc nil finite_sets nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (prewalk type-eq-decl nil walks nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (del_verts const-decl "graph[T]" sep_sets nil)
    (z!1 skolem-const-decl "T" h_menger nil)
    (min_sep_set_card formula-decl nil sep_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (card_singleton formula-decl nil finite_sets nil)
    (t!1 skolem-const-decl "T" h_menger nil)
    (s!1 skolem-const-decl "T" h_menger nil)
    (G!1 skolem-const-decl "graph[T]" h_menger nil)
    (sep_num const-decl "nat" sep_sets nil))
   nil))
 (adjacent_fact 0
  (adjacent_fact-2 nil 3559572389
   ("" (skosimp*)
    (("" (auto-rewrite finseq_appl)
      (("" (expand "in?")
        (("" (flatten)
          (("" (lemma "path_not_thru")
            (("" (inst?)
              (("" (assert)
                (("" (inst -1 "w1!1")
                  (("" (expand "disjoint?")
                    (("" (flatten)
                      (("" (assert)
                        (("" (skosimp*)
                          ((""
                            (name "path2"
                                  "add1(gen_seq2(G!1,s!1,w1!1),t!1)")
                            (("" (case "independent?(pn!1,path2)")
                              (("1"
                                (lemma "path_from_l")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "path_from?")
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (lemma "path?_del_vert")
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (case
                                                 "path?[T](G!1, path2) AND from?[T](path2, s!1, t!1)")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst
                                                     +
                                                     "pn!1"
                                                     "path2")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide
                                                   -1
                                                   -2
                                                   -3
                                                   -5
                                                   -6
                                                   -7
                                                   -8
                                                   -9
                                                   8)
                                                  (("2"
                                                    (replace -1 * rl)
                                                    (("2"
                                                      (hide -1)
                                                      (("2"
                                                        (split +)
                                                        (("1"
                                                          (expand
                                                           "path?")
                                                          (("1"
                                                            (split +)
                                                            (("1"
                                                              (lemma
                                                               "walk?_add1")
                                                              (("1"
                                                                (inst?)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "gen_seq2")
                                                                    (("1"
                                                                      (hide
                                                                       2)
                                                                      (("1"
                                                                        (expand
                                                                         "walk?")
                                                                        (("1"
                                                                          (expand
                                                                           "verts_in?")
                                                                          (("1"
                                                                            (skosimp*)
                                                                            (("1"
                                                                              (expand
                                                                               "edge?")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (rewrite
                                                                                   "dbl_comm")
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (expand
                                                                 "add1")
                                                                (("2"
                                                                  (expand
                                                                   "gen_seq2")
                                                                  (("2"
                                                                    (typepred
                                                                     "i!1")
                                                                    (("2"
                                                                      (typepred
                                                                       "j!1")
                                                                      (("2"
                                                                        (expand
                                                                         "add1")
                                                                        (("2"
                                                                          (expand
                                                                           "gen_seq2")
                                                                          (("2"
                                                                            (ground)
                                                                            (("2"
                                                                              (lift-if)
                                                                              (("2"
                                                                                (ground)
                                                                                (("1"
                                                                                  (lift-if)
                                                                                  (("1"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (lift-if)
                                                                                  (("2"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (lift-if)
                                                                                  (("3"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "add1")
                                                          (("2"
                                                            (expand
                                                             "from?")
                                                            (("2"
                                                              (expand
                                                               "gen_seq2")
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -3 -4 -5 8)
                                (("2"
                                  (expand "independent?")
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (replace -6 * rl)
                                      (("2"
                                        (hide -6)
                                        (("2"
                                          (expand "add1")
                                          (("2"
                                            (expand "gen_seq2")
                                            (("2"
                                              (lift-if)
                                              (("2"
                                                (ground)
                                                (("2"
                                                  (expand "path_from?")
                                                  (("2"
                                                    (expand "path?")
                                                    (("2"
                                                      (expand "walk?")
                                                      (("2"
                                                        (flatten)
                                                        (("2"
                                                          (hide -8 -9)
                                                          (("2"
                                                            (expand
                                                             "verts_in?")
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (expand
                                                                 "del_vert")
                                                                (("2"
                                                                  (expand
                                                                   "remove")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((T formal-type-decl nil h_menger nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (pregraph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (graph type-eq-decl nil graphs nil)
    (independent? const-decl "bool" ind_paths nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (path_from? const-decl "bool" paths nil)
    (path?_del_vert formula-decl nil path_ops nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (< const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (walk?_add1 formula-decl nil walks nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (edge? const-decl "bool" graphs nil)
    (dbl_comm formula-decl nil doubletons nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (walk? const-decl "bool" walks nil)
    (from? const-decl "bool" walks nil)
    (path? const-decl "bool" paths nil)
    (path_from_l formula-decl nil paths nil)
    (remove const-decl "set" sets nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (prewalk type-eq-decl nil walks nil)
    (add1 const-decl "prewalk" walks nil)
    (verts_in? const-decl "bool" walks nil)
    (Seq type-eq-decl nil walks nil)
    (gen_seq2 const-decl "Seq(G)" walks nil)
    (disjoint? const-decl "bool" meng_scaff_defs nil)
    (nil application-judgement "finite_set[T]" h_menger nil)
    (path_not_thru formula-decl nil h_menger nil)
    (in? const-decl "bool" meng_scaff_defs nil))
   nil)
  (adjacent_fact-1 nil 3251049132
   ("" (skosimp*)
    (("" (expand "in?")
      (("" (flatten)
        (("" (lemma "path_not_thru")
          (("" (inst?)
            (("" (assert)
              (("" (inst -1 "w1!1")
                (("" (expand "disjoint?")
                  (("" (flatten)
                    (("" (assert)
                      (("" (skosimp*)
                        ((""
                          (name "path2"
                                "add1(gen_seq2(G!1,s!1,w1!1),t!1)")
                          (("" (case "independent?(pn!1,path2)")
                            (("1" (lemma "path_from_l")
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "path_from?")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (lemma "path?_del_vert")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (case
                                               "path?[T](G!1, path2) AND from?[T](path2, s!1, t!1)")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (inst
                                                   +
                                                   "pn!1"
                                                   "path2")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide
                                                 -1
                                                 -2
                                                 -3
                                                 -5
                                                 -6
                                                 -7
                                                 -8
                                                 -9
                                                 8)
                                                (("2"
                                                  (replace -1 * rl)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (split +)
                                                      (("1"
                                                        (expand
                                                         "path?")
                                                        (("1"
                                                          (split +)
                                                          (("1"
                                                            (lemma
                                                             "walk?_add1")
                                                            (("1"
                                                              (inst?)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "gen_seq2")
                                                                  (("1"
                                                                    (hide
                                                                     2)
                                                                    (("1"
                                                                      (expand
                                                                       "walk?")
                                                                      (("1"
                                                                        (expand
                                                                         "verts_in?")
                                                                        (("1"
                                                                          (skosimp*)
                                                                          (("1"
                                                                            (expand
                                                                             "edge?")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (rewrite
                                                                                 "dbl_comm")
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (skosimp*)
                                                            (("2"
                                                              (expand
                                                               "add1")
                                                              (("2"
                                                                (expand
                                                                 "gen_seq2")
                                                                (("2"
                                                                  (lift-if)
                                                                  (("2"
                                                                    (lift-if)
                                                                    (("2"
                                                                      (typepred
                                                                       "i!1")
                                                                      (("2"
                                                                        (typepred
                                                                         "j!1")
                                                                        (("2"
                                                                          (expand
                                                                           "add1")
                                                                          (("2"
                                                                            (expand
                                                                             "gen_seq2")
                                                                            (("2"
                                                                              (ground)
                                                                              (("1"
                                                                                (lift-if)
                                                                                (("1"
                                                                                  (ground)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (lift-if)
                                                                                (("2"
                                                                                  (ground)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (expand "add1")
                                                        (("2"
                                                          (expand
                                                           "from?")
                                                          (("2"
                                                            (expand
                                                             "gen_seq2")
                                                            (("2"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide -3 -4 -5 8)
                              (("2"
                                (expand "independent?")
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (replace -6 * rl)
                                    (("2"
                                      (hide -6)
                                      (("2"
                                        (expand "add1")
                                        (("2"
                                          (expand "gen_seq2")
                                          (("2"
                                            (lift-if)
                                            (("2"
                                              (ground)
                                              (("2"
                                                (expand "path_from?")
                                                (("2"
                                                  (expand "path?")
                                                  (("2"
                                                    (expand "walk?")
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (hide -8 -9)
                                                        (("2"
                                                          (expand
                                                           "verts_in?")
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (expand
                                                               "del_vert")
                                                              (("2"
                                                                (expand
                                                                 "remove")
                                                                (("2"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((in? const-decl "bool" meng_scaff_defs nil)
    (disjoint? const-decl "bool" meng_scaff_defs nil)
    (gen_seq2 const-decl "Seq(G)" walks nil)
    (Seq type-eq-decl nil walks nil)
    (verts_in? const-decl "bool" walks nil)
    (add1 const-decl "prewalk" walks nil)
    (prewalk type-eq-decl nil walks nil)
    (path_from_l formula-decl nil paths nil)
    (path? const-decl "bool" paths nil)
    (from? const-decl "bool" walks nil)
    (walk? const-decl "bool" walks nil)
    (dbl_comm formula-decl nil doubletons nil)
    (edge? const-decl "bool" graphs nil)
    (walk?_add1 formula-decl nil walks nil)
    (path?_del_vert formula-decl nil path_ops nil)
    (path_from? const-decl "bool" paths nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (independent? const-decl "bool" ind_paths nil)
    (graph type-eq-decl nil graphs nil)
    (pregraph type-eq-decl nil graphs nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil))
   nil))
 (sep_num_del 0
  (sep_num_del-1 nil 3251049132
   ("" (skosimp*)
    (("" (lemma "min_sep_set_seps")
      (("" (inst?)
        (("" (assert)
          (("" (expand "sep_num")
            (("" (lemma "min_sep_set_card")
              (("" (inst?)
                (("1" (assert)
                  (("1" (hide -2 2)
                    (("1" (expand "separates")
                      (("1" (skosimp*)
                        (("1" (split 1)
                          (("1" (propax) nil nil)
                           ("2" (propax) nil nil)
                           ("3" (skosimp*)
                            (("3" (inst?)
                              (("3"
                                (expand "walk_from?")
                                (("3"
                                  (flatten)
                                  (("3"
                                    (assert)
                                    (("3"
                                      (expand "walk?")
                                      (("3"
                                        (split +)
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (expand "verts_in?")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (hide -4)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (ground)
                                                    (("1"
                                                      (expand
                                                       "del_verts")
                                                      (("1"
                                                        (expand
                                                         "difference")
                                                        (("1"
                                                          (expand
                                                           "member")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (expand
                                                               "del_vert")
                                                              (("1"
                                                                (expand
                                                                 "remove")
                                                                (("1"
                                                                  (expand
                                                                   "member")
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "finseq_appl")
                                            (("2"
                                              (expand "edge?")
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (hide -4)
                                                        (("2"
                                                          (expand
                                                           "del_verts")
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (split +)
                                                              (("1"
                                                                (lemma
                                                                 "edges_del_vert")
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide -1 2)
                  (("2" (expand "del_vert")
                    (("2" (expand "remove")
                      (("2" (expand "member") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("3" (hide -1 4)
                  (("3" (expand "del_vert")
                    (("3" (expand "remove")
                      (("3" (expand "member") (("3" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((T formal-type-decl nil h_menger nil)
    (min_sep_set_seps formula-decl nil sep_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (min_sep_set_card formula-decl nil sep_sets nil)
    (separates const-decl "bool" sep_sets nil)
    (prewalk type-eq-decl nil walks nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (walk? const-decl "bool" walks nil)
    (nil application-judgement "finite_set[T]" h_menger nil)
    (edge? const-decl "bool" graphs nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (edges_del_vert formula-decl nil graph_ops nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (del_verts const-decl "graph[T]" sep_sets nil)
    (member const-decl "bool" sets nil)
    (remove const-decl "set" sets nil)
    (difference const-decl "set" sets nil)
    (verts_in? const-decl "bool" walks nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (walk_from? const-decl "bool" walks nil)
    (is_finite const-decl "bool" finite_sets nil)
    (min_sep_set const-decl "finite_set[T]" sep_sets nil)
    (t!1 skolem-const-decl "T" h_menger nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (G!1 skolem-const-decl "graph[T]" h_menger nil)
    (v!1 skolem-const-decl "T" h_menger nil)
    (s!1 skolem-const-decl "T" h_menger nil)
    (sep_num const-decl "nat" sep_sets nil)
    (graph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pregraph type-eq-decl nil graphs nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (separates_del 0
  (separates_del-1 nil 3251049132
   ("" (skosimp*)
    (("" (expand "del_vert")
      (("" (expand "separates")
        (("" (expand "singleton")
          (("" (expand "dbl")
            (("" (flatten)
              (("" (assert)
                (("" (skosimp*)
                  (("" (inst?)
                    (("" (expand "walk_from?")
                      (("" (flatten)
                        (("" (assert)
                          (("" (expand "walk?")
                            (("" (flatten)
                              ((""
                                (split +)
                                (("1"
                                  (expand "verts_in?")
                                  (("1"
                                    (hide -7)
                                    (("1"
                                      (skosimp*)
                                      (("1"
                                        (expand "del_verts")
                                        (("1"
                                          (expand "difference")
                                          (("1"
                                            (expand "remove")
                                            (("1"
                                              (expand "member")
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (skosimp*)
                                  (("2"
                                    (expand "edge?")
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (expand "del_verts")
                                              (("2"
                                                (hide -7)
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (split +)
                                                      (("1"
                                                        (expand "dbl")
                                                        (("1"
                                                          (inst-cp
                                                           -
                                                           "ajm!1")
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "z!1")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((del_vert const-decl "graph[T]" graph_ops nil)
    (singleton const-decl "(singleton?)" sets nil)
    (walk_from? const-decl "bool" walks nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (edge? const-decl "bool" graphs nil)
    (nil application-judgement "finite_set[T]" h_menger nil)
    (verts_in? const-decl "bool" walks nil)
    (difference const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (remove const-decl "set" sets nil)
    (del_verts const-decl "graph[T]" sep_sets nil)
    (walk? const-decl "bool" walks nil)
    (prewalk type-eq-decl nil walks nil)
    (> const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (T formal-type-decl nil h_menger nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (dbl const-decl "set[T]" doubletons nil)
    (separates const-decl "bool" sep_sets nil))
   nil))
 (induction_step_comm 0
  (induction_step_comm-1 nil 3251049132
   ("" (skosimp*)
    (("" (expand "induction_step") (("" (propax) nil nil)) nil)) nil)
   ((induction_step const-decl "bool" meng_scaff_prelude nil)) nil))
 (separable?_del 0
  (separable?_del-1 nil 3251049132
   ("" (skosimp*)
    (("" (expand "separable?")
      (("" (flatten)
        (("" (assert)
          (("" (expand "edge?")
            (("" (expand "del_vert")
              (("" (assert)
                (("" (expand "remove")
                  (("" (expand "member") (("" (propax) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((separable? const-decl "bool" sep_sets nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (remove const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (edge? const-decl "bool" graphs nil)
    (nil application-judgement "finite_set[T]" h_menger nil))
   nil))
 (seq_j_TCC1 0
  (seq_j_TCC1-1 nil 3251049132 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (T formal-type-decl nil h_menger nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (prewalk type-eq-decl nil walks nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (seq_j_TCC2 0
  (seq_j_TCC2-1 nil 3251049132 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)
    (T formal-type-decl nil h_menger nil)
    (edge? const-decl "bool" graphs nil)
    (nil application-judgement "finite_set[T]" h_menger nil))
   nil))
 (seq_j_TCC3 0
  (seq_j_TCC3-1 nil 3251049132 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (pregraph type-eq-decl nil graphs nil)
    (graph type-eq-decl nil graphs nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (prewalk type-eq-decl nil walks nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (/= const-decl "boolean" notequal nil)
    (T formal-type-decl nil h_menger nil)
    (edge? const-decl "bool" graphs nil)
    (nil application-judgement "finite_set[T]" h_menger nil))
   nil))
 (seq_j 0
  (seq_j-1 nil 3251049132
   ("" (induct "p" 1 "graph_induction_walk")
    (("1" (skosimp*)
      (("1" (inst -1 "trunc1(w!1)")
        (("1" (rewrite "l_trunc1")
          (("1" (assert)
            (("1"
              (case "NOT edge?(G!1)(seq(w!1)(length(w!1) - 3), t!1)
                 AND edge?(G!1)(seq(w!1)(length(w!1)-2), t!1)")
              (("1" (inst + "length(w!1)-2")
                (("1" (flatten) (("1" (assertnil nil)) nil)) nil)
               ("2" (inst -1 "G!1" "t!1")
                (("2" (case "length(w!1) = 4")
                  (("1" (hide -2)
                    (("1" (replace -1)
                      (("1" (hide -1)
                        (("1" (assert)
                          (("1" (inst + "1") (("1" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assert)
                    (("2" (expand "trunc1")
                      (("2" (expand"^" min empty_seq)
                        (("2" (skosimp*)
                          (("2" (inst + "j!1") (("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assertnil nil))
        nil))
      nil)
     ("2" (skosimp*) (("2" (assertnil nil)) nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil))
    nil)
   ((l_trunc1 formula-decl nil walks nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (^ const-decl "finseq" finite_sequences nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (Longprewalk type-eq-decl nil walks nil)
    (trunc1 const-decl "prewalk" walks nil)
    (w!1 skolem-const-decl "prewalk[T]" h_menger nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (graph_induction_walk formula-decl nil walk_inductions nil)
    (T formal-type-decl nil h_menger nil)
    (pred type-eq-decl nil defined_types nil)
    (edge? const-decl "bool" graphs nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (> const-decl "bool" reals nil)
    (prewalk type-eq-decl nil walks nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (pregraph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (graph type-eq-decl nil graphs nil)
    (>= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (short_path_case 0
  (short_path_case-1 nil 3251049132
   ("" (skosimp*)
    (("" (lemma "path_not_thru")
      (("" (inst?)
        (("" (assert)
          (("" (inst?)
            (("" (expand "edge?")
              (("" (flatten)
                (("" (assert)
                  (("" (skosimp*)
                    ((""
                      (name "path2" "add1(gen_seq2(G!1,s!1,x!1),t!1)")
                      (("" (inst + "path2" "pn!1")
                        (("" (expand "path_from?")
                          (("" (flatten)
                            (("" (expand "from?")
                              ((""
                                (flatten)
                                ((""
                                  (assert)
                                  ((""
                                    (lemma "path?_del_vert")
                                    ((""
                                      (inst?)
                                      ((""
                                        (assert)
                                        ((""
                                          (replace -2 * rl)
                                          ((""
                                            (hide -2)
                                            ((""
                                              (split +)
                                              (("1"
                                                (rewrite "path?_add1")
                                                (("1"
                                                  (hide 2)
                                                  (("1"
                                                    (rewrite
                                                     "path?_gen_seq2")
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "gen_seq2")
                                                  (("2"
                                                    (expand "edge?")
                                                    (("2"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (expand
                                                   "verts_of"
                                                   -1)
                                                  (("3"
                                                    (expand
                                                     "finseq_appl")
                                                    (("3"
                                                      (expand
                                                       "gen_seq2"
                                                       -1)
                                                      (("3"
                                                        (skosimp*)
                                                        (("3"
                                                          (lift-if)
                                                          (("3"
                                                            (ground)
                                                            (("3"
                                                              (expand
                                                               "separable?")
                                                              (("3"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "add1")
                                                (("2"
                                                  (expand "gen_seq2")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (expand "add1")
                                                (("3"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil)
                                               ("4"
                                                (expand "independent?")
                                                (("4"
                                                  (skosimp*)
                                                  (("4"
                                                    (expand "add1")
                                                    (("4"
                                                      (expand
                                                       "gen_seq2")
                                                      (("4"
                                                        (lift-if)
                                                        (("4"
                                                          (expand
                                                           "path?")
                                                          (("4"
                                                            (expand
                                                             "walk?")
                                                            (("4"
                                                              (flatten)
                                                              (("4"
                                                                (hide
                                                                 -6
                                                                 -7
                                                                 -10
                                                                 -11)
                                                                (("4"
                                                                  (expand
                                                                   "verts_in?")
                                                                  (("4"
                                                                    (expand
                                                                     "finseq_appl")
                                                                    (("4"
                                                                      (inst-cp
                                                                       -
                                                                       "i!1"
                                                                       "j!1")
                                                                      (("1"
                                                                        (ground)
                                                                        (("1"
                                                                          (expand
                                                                           "del_vert")
                                                                          (("1"
                                                                            (expand
                                                                             "remove")
                                                                            (("1"
                                                                              (expand
                                                                               "member")
                                                                              (("1"
                                                                                (hide
                                                                                 -7)
                                                                                (("1"
                                                                                  (inst
                                                                                   -7
                                                                                   "j!1")
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (inst
                                                                           -9
                                                                           "j!1")
                                                                          (("2"
                                                                            (expand
                                                                             "del_vert")
                                                                            (("2"
                                                                              (expand
                                                                               "remove")
                                                                              (("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil)
                                                                       ("3"
                                                                        (typepred
                                                                         "i!1")
                                                                        (("3"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((path_not_thru formula-decl nil h_menger nil)
    (nil application-judgement "finite_set[T]" h_menger nil)
    (edge? const-decl "bool" graphs nil)
    (gen_seq2 const-decl "Seq(G)" walks nil)
    (Seq type-eq-decl nil walks nil)
    (verts_in? const-decl "bool" walks nil)
    (add1 const-decl "prewalk" walks nil)
    (prewalk type-eq-decl nil walks nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (path_from? const-decl "bool" paths nil)
    (from? const-decl "bool" walks nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (separable? const-decl "bool" sep_sets nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (path?_gen_seq2 formula-decl nil paths nil)
    (path?_add1 formula-decl nil paths nil)
    (path? const-decl "bool" paths nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (i!1 skolem-const-decl "nat" h_menger nil)
    (pn!1 skolem-const-decl "prewalk[T]" h_menger nil)
    (j!1 skolem-const-decl "nat" h_menger nil)
    (below type-eq-decl nil naturalnumbers nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (member const-decl "bool" sets nil)
    (remove const-decl "set" sets nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (walk? const-decl "bool" walks nil)
    (independent? const-decl "bool" ind_paths nil)
    (path?_del_vert formula-decl nil path_ops nil)
    (graph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pregraph type-eq-decl nil graphs nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil h_menger nil))
   nil))
 (finale 0
  (finale-2 nil 3559573458
   ("" (skosimp*)
    (("" (auto-rewrite finseq_appl)
      (("" (lemma "sep_num_gt_0")
        (("" (inst?)
          (("" (assert)
            (("" (skosimp*)
              (("" (lemma "walk_to_path_from")
                (("" (inst?)
                  (("" (assert)
                    (("" (skosimp*)
                      (("" (hide -2)
                        (("" (case "length(p!1) <= 3")
                          (("1" (lemma "path_from_l")
                            (("1" (inst?)
                              (("1"
                                (assert)
                                (("1"
                                  (expand "separable?")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (expand "path_from?" -)
                                        (("1"
                                          (expand "path?")
                                          (("1"
                                            (expand "walk?")
                                            (("1"
                                              (expand "verts_in?")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (inst - "1")
                                                  (("1"
                                                    (inst-cp - "0")
                                                    (("1"
                                                      (inst - "1")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "from?")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (case-replace
                                                               "length(p!1) = 3")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lemma
                                                                   "short_path_case")
                                                                  (("1"
                                                                    (inst?)
                                                                    (("1"
                                                                      (inst?)
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2"
                            (case "  (EXISTS (j: nat): j > 1 AND j < length(p!1)-1  AND
                    NOT edge?(G!1)(seq(p!1)(j - 1), t!1)
                        AND edge?(G!1)(seq(p!1)(j), t!1))")
                            (("1" (skosimp*)
                              (("1"
                                (case
                                 "vert(G!1)(seq(p!1)(j!1 - 1)) AND vert(G!1)(seq(p!1)(j!1)) AND
                         disjoint?(s!1,t!1,seq(p!1)(j!1-1),seq(p!1)(j!1))")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (case
                                     "separates(G!1,dbl(seq(p!1)(j!1-1),seq(p!1)(j!1)),s!1,t!1)")
                                    (("1"
                                      (lemma "prelude")
                                      (("1"
                                        (inst
                                         -
                                         "G!1"
                                         "s!1"
                                         "t!1"
                                         "_"
                                         "_")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (expand "in?")
                                              (("1"
                                                (split -1)
                                                (("1" (propax) nil nil)
                                                 ("2"
                                                  (flatten)
                                                  (("2"
                                                    (lemma
                                                     "adjacent_fact")
                                                    (("2"
                                                      (inst
                                                       -
                                                       "G!1"
                                                       "s!1"
                                                       "t!1"
                                                       "seq(p!1)(j!1)"
                                                       "seq(p!1)(j!1-1)")
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (expand
                                                           "in?")
                                                          (("2"
                                                            (expand
                                                             "disjoint?")
                                                            (("2"
                                                              (flatten)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (rewrite
                                                                   "dbl_comm")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "separates")
                                      (("2"
                                        (expand "disjoint?")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (expand "dbl" 1 (1 2))
                                            (("2"
                                              (assert)
                                              (("2"
                                                (skosimp*)
                                                (("2"
                                                  (lemma
                                                   "walk_to_path_from")
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (hide -2)
                                                          (("2"
                                                            (case
                                                             "edge?(G!1)(s!1,seq(p!1)(j!1-1))")
                                                            (("1"
                                                              (name
                                                               "Pscat"
                                                               "add1(add1(gen_seq2(G!1,s!1,seq(p!1)(j!1-1)),seq(p!1)(j!1)),t!1)")
                                                              (("1"
                                                                (case
                                                                 "independent?(p!2,Pscat)")
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "p!2"
                                                                   "Pscat")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (expand
                                                                       "path_from?")
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (lemma
                                                                             "path?_del_verts")
                                                                            (("1"
                                                                              (inst?)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide
                                                                                   -1
                                                                                   -2
                                                                                   -5
                                                                                   -6)
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1
                                                                                     *
                                                                                     rl)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (split)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "path?"
                                                                                           -)
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "walk?")
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -8
                                                                                                   "j!1-1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (rewrite
                                                                                                       "path?_add1")
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         2)
                                                                                                        (("1"
                                                                                                          (rewrite
                                                                                                           "path?_add1")
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("1"
                                                                                                              (rewrite
                                                                                                               "path?_gen_seq2")
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (expand
                                                                                                             "gen_seq2")
                                                                                                            (("2"
                                                                                                              (propax)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("3"
                                                                                                            (expand
                                                                                                             "verts_of"
                                                                                                             -1)
                                                                                                            (("3"
                                                                                                              (expand
                                                                                                               "gen_seq2"
                                                                                                               -1)
                                                                                                              (("3"
                                                                                                                (skosimp*)
                                                                                                                (("3"
                                                                                                                  (ground)
                                                                                                                  (("3"
                                                                                                                    (lift-if)
                                                                                                                    (("3"
                                                                                                                      (ground)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (expand
                                                                                                         "add1")
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("3"
                                                                                                        (hide
                                                                                                         1)
                                                                                                        (("3"
                                                                                                          (expand
                                                                                                           "verts_of"
                                                                                                           -1)
                                                                                                          (("3"
                                                                                                            (expand
                                                                                                             "add1"
                                                                                                             -1)
                                                                                                            (("3"
                                                                                                              (expand
                                                                                                               "gen_seq2"
                                                                                                               -1)
                                                                                                              (("3"
                                                                                                                (skosimp*)
                                                                                                                (("3"
                                                                                                                  (ground)
                                                                                                                  (("3"
                                                                                                                    (lift-if)
                                                                                                                    (("3"
                                                                                                                      (ground)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (expand
                                                                                           "from?")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "add1")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "gen_seq2")
                                                                                              (("2"
                                                                                                (propax)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (replace
                                                                   -1
                                                                   *
                                                                   rl)
                                                                  (("2"
                                                                    (hide
                                                                     -1)
                                                                    (("2"
                                                                      (hide
                                                                       -1
                                                                       -7
                                                                       -9
                                                                       -10
                                                                       -13
                                                                       8
                                                                       10)
                                                                      (("2"
                                                                        (expand
                                                                         "path_from?")
                                                                        (("2"
                                                                          (expand
                                                                           "path?")
                                                                          (("2"
                                                                            (expand
                                                                             "walk?")
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (hide
                                                                                 -2)
                                                                                (("2"
                                                                                  (expand
                                                                                   "independent?")
                                                                                  (("2"
                                                                                    (skosimp*)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "add1")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "gen_seq2")
                                                                                        (("2"
                                                                                          (lift-if)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "verts_in?")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "del_verts")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "difference")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "member")
                                                                                                  (("2"
                                                                                                    (inst?)
                                                                                                    (("1"
                                                                                                      (flatten)
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "dbl")
                                                                                                        (("1"
                                                                                                          (ground)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (case
                                                               "(FORALL (v:T): vert(G!1)(v) AND v /= s!1 AND v /= t!1
                                                IMPLIES sep_num(del_vert(G!1,v),s!1,t!1) <= 1)")
                                                              (("1"
                                                                (inst
                                                                 -1
                                                                 "seq(p!1)(j!1-1)")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (lemma
                                                                     "sep_num_le1")
                                                                    (("1"
                                                                      (inst
                                                                       -1
                                                                       "del_vert(G!1, seq(p!1)(j!1 - 1))"
                                                                       "seq(p!1)(j!1)"
                                                                       "s!1"
                                                                       "t!1")
                                                                      (("1"
                                                                        (expand
                                                                         "separable?")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (lemma
                                                                             "separable?_del")
                                                                            (("1"
                                                                              (inst
                                                                               -1
                                                                               "G!1"
                                                                               "s!1"
                                                                               "t!1"
                                                                               "seq(p!1)(j!1 - 1)")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (split
                                                                                       -4)
                                                                                      (("1"
                                                                                        (skosimp*)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "del_vert"
                                                                                           -1)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "remove")
                                                                                            (("1"
                                                                                              (flatten)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "member")
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "separates_del")
                                                                                                  (("1"
                                                                                                    (inst?)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "prelude")
                                                                                                        (("1"
                                                                                                          (inst?)
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "in?")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "disjoint?")
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "edge?")
                                                                                                                  (("1"
                                                                                                                    (rewrite
                                                                                                                     "dbl_comm")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (expand
                                                                                         "del_vert"
                                                                                         1)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "remove")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "member")
                                                                                            (("2"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("3"
                                                                                        (expand
                                                                                         "edge?")
                                                                                        (("3"
                                                                                          (expand
                                                                                           "del_vert"
                                                                                           -1)
                                                                                          (("3"
                                                                                            (flatten)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (hide
                                                                   -2)
                                                                  (("2"
                                                                    (expand
                                                                     "induction_step")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "del_vert(G!1,v!1)")
                                                                      (("2"
                                                                        (rewrite
                                                                         "size_del_vert")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "s!1"
                                                                             "t!1")
                                                                            (("2"
                                                                              (lemma
                                                                               "sep_num_del")
                                                                              (("2"
                                                                                (inst?)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (lemma
                                                                                     "separable?_del")
                                                                                    (("2"
                                                                                      (inst?)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (skosimp*)
                                                                                              (("2"
                                                                                                (inst
                                                                                                 +
                                                                                                 "p1!1"
                                                                                                 "p2!1")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "path_from?")
                                                                                                    (("2"
                                                                                                      (flatten)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (lemma
                                                                                                           "path?_del_vert")
                                                                                                          (("2"
                                                                                                            (inst?)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "path?_del_vert")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -1
                                                                                                                   "G!1"
                                                                                                                   "v!1"
                                                                                                                   "p2!1")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 4)
                                  (("2"
                                    (expand "path_from?")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (expand "from?")
                                        (("2"
                                          (hide 2 3)
                                          (("2"
                                            (expand "path?")
                                            (("2"
                                              (expand "walk?")
                                              (("2"
                                                (expand "verts_in?")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst-cp -4 "j!1")
                                                    (("2"
                                                      (inst -4 "j!1-1")
                                                      (("1"
                                                        (inst-cp
                                                         -6
                                                         "j!1-1")
                                                        (("1"
                                                          (inst
                                                           -6
                                                           "j!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (expand
                                                               "disjoint?")
                                                              (("1"
                                                                (inst-cp
                                                                 -
                                                                 "j!1-1"
                                                                 "j!1")
                                                                (("1"
                                                                  (inst-cp
                                                                   -
                                                                   "j!1-1"
                                                                   "0")
                                                                  (("1"
                                                                    (inst-cp
                                                                     -
                                                                     "j!1-1"
                                                                     "length(p!1)-1")
                                                                    (("1"
                                                                      (inst-cp
                                                                       -
                                                                       "j!1"
                                                                       "0")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "j!1"
                                                                         "length(p!1)-1")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "separable?")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3" (assertnil nil)
                                 ("4" (assertnil nil))
                                nil))
                              nil)
                             ("2" (lemma "seq_j")
                              (("2"
                                (ground)
                                (("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (expand "path_from?")
                                      (("2"
                                        (expand "from?")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (inst -1 "p!1" "t!1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "separable?")
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split -1)
                                                        (("1"
                                                          (skosimp*)
                                                          (("1"
                                                            (inst
                                                             2
                                                             "j!1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (case
                                                                 "j!1 = 1")
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (lemma
                                                                         "short_path_case")
                                                                        (("1"
                                                                          (inst
                                                                           -1
                                                                           "G!1"
                                                                           "s!1"
                                                                           "t!1"
                                                                           "seq(p!1)(1)")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (expand
                                                                               "path?"
                                                                               -5)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (expand
                                                                                   "walk?")
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "verts_in?")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "1")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "0")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (case
                                                                     "j!1 = length(p!1) - 1")
                                                                    (("1"
                                                                      (replace
                                                                       -1)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "path?"
                                                                             -4)
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (expand
                                                                                 "walk?")
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "length(p!1)-2")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "path?"
                                                           -1)
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (expand
                                                               "walk?")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "length(p!1)-2")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("3" (skosimp*) (("3" (assertnil nil))
                              nil)
                             ("4" (skosimp*) (("4" (assertnil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (pregraph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (graph type-eq-decl nil graphs nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (prewalk type-eq-decl nil walks nil)
    (<= const-decl "bool" reals nil)
    (separable? const-decl "bool" sep_sets nil)
    (path? const-decl "bool" paths nil)
    (verts_in? const-decl "bool" walks nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (from? const-decl "bool" walks nil)
    (short_path_case formula-decl nil h_menger nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (walk? const-decl "bool" walks nil)
    (path_from? const-decl "bool" paths nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (path_from_l formula-decl nil paths nil)
    (seq_j formula-decl nil h_menger nil)
    (p!1 skolem-const-decl "prewalk[T]" h_menger nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (sep_num const-decl "nat" sep_sets nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (separates_del formula-decl nil h_menger nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set" finite_sets nil)
    (remove const-decl "set" sets nil)
    (separable?_del formula-decl nil h_menger nil)
    (sep_num_le1 formula-decl nil sep_set_lems nil)
    (sep_num_del formula-decl nil h_menger nil)
    (path?_del_vert formula-decl nil path_ops nil)
    (size_del_vert formula-decl nil graph_ops nil)
    (induction_step const-decl "bool" meng_scaff_prelude nil)
    (add1 const-decl "prewalk" walks nil)
    (Seq type-eq-decl nil walks nil)
    (gen_seq2 const-decl "Seq(G)" walks nil)
    (member const-decl "bool" sets nil)
    (p!2 skolem-const-decl "prewalk[T]" h_menger nil)
    (i!1 skolem-const-decl "nat" h_menger nil)
    (difference const-decl "set" sets nil)
    (path?_add1 formula-decl nil paths nil)
    (path?_gen_seq2 formula-decl nil paths nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (path?_del_verts formula-decl nil path_ops nil)
    (independent? const-decl "bool" ind_paths nil)
    (del_verts const-decl "graph[T]" sep_sets nil)
    (prelude formula-decl nil meng_scaff_prelude nil)
    (j!1 skolem-const-decl "nat" h_menger nil)
    (in? const-decl "bool" meng_scaff_defs nil)
    (dbl_comm formula-decl nil doubletons nil)
    (adjacent_fact formula-decl nil h_menger nil)
    (separates const-decl "bool" sep_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (nil application-judgement "finite_set[T]" h_menger nil)
    (disjoint? const-decl "bool" meng_scaff_defs nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (edge? const-decl "bool" graphs nil)
    (walk_to_path_from formula-decl nil path_ops nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sep_num_gt_0 formula-decl nil sep_set_lems nil)
    (T formal-type-decl nil h_menger nil))
   nil)
  (finale-1 nil 3251049132
   ("" (skosimp*)
    (("" (lemma "sep_num_gt_0")
      (("" (inst?)
        (("" (assert)
          (("" (skosimp*)
            (("" (lemma "walk_to_path_from")
              (("" (inst?)
                (("" (assert)
                  (("" (skosimp*)
                    (("" (hide -2)
                      (("" (case "length(p!1) <= 3")
                        (("1" (lemma "path_from_l")
                          (("1" (inst?)
                            (("1" (assert)
                              (("1"
                                (expand "separable?")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "path_from?" -)
                                      (("1"
                                        (expand "path?")
                                        (("1"
                                          (expand "walk?")
                                          (("1"
                                            (expand "verts_in?")
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (inst - "1")
                                                (("1"
                                                  (inst-cp - "0")
                                                  (("1"
                                                    (inst - "1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "from?")
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (case-replace
                                                             "length(p!1) = 3")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (lemma
                                                                 "short_path_case")
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (inst?)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2"
                          (case "  (EXISTS (j: nat): j > 1 AND j < length(p!1)-1  AND
           NOT edge?(G!1)(seq(p!1)(j - 1), t!1)
               AND edge?(G!1)(seq(p!1)(j), t!1))")
                          (("1" (skosimp*)
                            (("1"
                              (case "vert(G!1)(seq(p!1)(j!1 - 1)) AND vert(G!1)(seq(p!1)(j!1)) AND 
              disjoint?(s!1,t!1,seq(p!1)(j!1-1),seq(p!1)(j!1))")
                              (("1"
                                (flatten)
                                (("1"
                                  (case
                                   "separates(G!1,dbl(seq(p!1)(j!1-1),seq(p!1)(j!1)),s!1,t!1)")
                                  (("1"
                                    (lemma "prelude")
                                    (("1"
                                      (inst
                                       -
                                       "G!1"
                                       "s!1"
                                       "t!1"
                                       "_"
                                       "_")
                                      (("1"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "in?")
                                            (("1"
                                              (split -1)
                                              (("1" (propax) nil nil)
                                               ("2"
                                                (flatten)
                                                (("2"
                                                  (lemma
                                                   "adjacent_fact")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "G!1"
                                                     "s!1"
                                                     "t!1"
                                                     "seq(p!1)(j!1)"
                                                     "seq(p!1)(j!1-1)")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand "in?")
                                                        (("2"
                                                          (expand
                                                           "disjoint?")
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (rewrite
                                                                 "dbl_comm")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2" (assertnil nil)
                                         ("3" (assertnil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "separates")
                                    (("2"
                                      (expand "disjoint?")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (expand "dbl" 1 (1 2))
                                          (("2"
                                            (assert)
                                            (("2"
                                              (skosimp*)
                                              (("2"
                                                (lemma
                                                 "walk_to_path_from")
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (hide -2)
                                                        (("2"
                                                          (case
                                                           "edge?(G!1)(s!1,seq(p!1)(j!1-1))")
                                                          (("1"
                                                            (name
                                                             "Pscat"
                                                             "add1(add1(gen_seq2(G!1,s!1,seq(p!1)(j!1-1)),seq(p!1)(j!1)),t!1)")
                                                            (("1"
                                                              (case
                                                               "independent?(p!2,Pscat)")
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "p!2"
                                                                 "Pscat")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "path_from?")
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (lemma
                                                                           "path?_del_verts")
                                                                          (("1"
                                                                            (inst?)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide
                                                                                 -1
                                                                                 -2
                                                                                 -5
                                                                                 -6)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   *
                                                                                   rl)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -1)
                                                                                    (("1"
                                                                                      (split)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "path?"
                                                                                         -)
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "walk?")
                                                                                            (("1"
                                                                                              (flatten)
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -8
                                                                                                 "j!1-1")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (rewrite
                                                                                                     "path?_add1")
                                                                                                    (("1"
                                                                                                      (hide
                                                                                                       2)
                                                                                                      (("1"
                                                                                                        (rewrite
                                                                                                         "path?_add1")
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           2)
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "path?_gen_seq2")
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (expand
                                                                                                           "gen_seq2")
                                                                                                          (("2"
                                                                                                            (propax)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("3"
                                                                                                          (expand
                                                                                                           "verts_of"
                                                                                                           -1)
                                                                                                          (("3"
                                                                                                            (expand
                                                                                                             "gen_seq2"
                                                                                                             -1)
                                                                                                            (("3"
                                                                                                              (skosimp*)
                                                                                                              (("3"
                                                                                                                (lift-if)
                                                                                                                (("3"
                                                                                                                  (ground)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (expand
                                                                                                       "add1")
                                                                                                      (("2"
                                                                                                        (propax)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (hide
                                                                                                       1)
                                                                                                      (("3"
                                                                                                        (expand
                                                                                                         "verts_of"
                                                                                                         -1)
                                                                                                        (("3"
                                                                                                          (expand
                                                                                                           "add1"
                                                                                                           -1)
                                                                                                          (("3"
                                                                                                            (expand
                                                                                                             "gen_seq2"
                                                                                                             -1)
                                                                                                            (("3"
                                                                                                              (skosimp*)
                                                                                                              (("3"
                                                                                                                (lift-if)
                                                                                                                (("3"
                                                                                                                  (ground)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (expand
                                                                                         "from?")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "add1")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "gen_seq2")
                                                                                            (("2"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (replace
                                                                 -1
                                                                 *
                                                                 rl)
                                                                (("2"
                                                                  (hide
                                                                   -1)
                                                                  (("2"
                                                                    (hide
                                                                     -1
                                                                     -7
                                                                     -9
                                                                     -10
                                                                     -13
                                                                     8
                                                                     10)
                                                                    (("2"
                                                                      (expand
                                                                       "path_from?")
                                                                      (("2"
                                                                        (expand
                                                                         "path?")
                                                                        (("2"
                                                                          (expand
                                                                           "walk?")
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (hide
                                                                               -2)
                                                                              (("2"
                                                                                (expand
                                                                                 "independent?")
                                                                                (("2"
                                                                                  (skosimp*)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "add1")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "gen_seq2")
                                                                                      (("2"
                                                                                        (lift-if)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "verts_in?")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "del_verts")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "difference")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "member")
                                                                                                (("2"
                                                                                                  (inst?)
                                                                                                  (("1"
                                                                                                    (flatten)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "dbl")
                                                                                                      (("1"
                                                                                                        (ground)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (case
                                                             "(FORALL (v:T): vert(G!1)(v) AND v /= s!1 AND v /= t!1 
                               IMPLIES sep_num(del_vert(G!1,v),s!1,t!1) <= 1)")
                                                            (("1"
                                                              (inst
                                                               -1
                                                               "seq(p!1)(j!1-1)")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lemma
                                                                   "sep_num_le1")
                                                                  (("1"
                                                                    (inst
                                                                     -1
                                                                     "del_vert(G!1, seq(p!1)(j!1 - 1))"
                                                                     "seq(p!1)(j!1)"
                                                                     "s!1"
                                                                     "t!1")
                                                                    (("1"
                                                                      (expand
                                                                       "separable?")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (lemma
                                                                           "separable?_del")
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "G!1"
                                                                             "s!1"
                                                                             "t!1"
                                                                             "seq(p!1)(j!1 - 1)")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (split
                                                                                     -4)
                                                                                    (("1"
                                                                                      (skosimp*)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "del_vert"
                                                                                         -1)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "remove")
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "member")
                                                                                              (("1"
                                                                                                (lemma
                                                                                                 "separates_del")
                                                                                                (("1"
                                                                                                  (inst?)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (lemma
                                                                                                       "prelude")
                                                                                                      (("1"
                                                                                                        (inst?)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "in?")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "disjoint?")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "edge?")
                                                                                                                (("1"
                                                                                                                  (rewrite
                                                                                                                   "dbl_comm")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "del_vert"
                                                                                       1)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "remove")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "member")
                                                                                          (("2"
                                                                                            (propax)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (expand
                                                                                       "edge?")
                                                                                      (("3"
                                                                                        (expand
                                                                                         "del_vert"
                                                                                         -1)
                                                                                        (("3"
                                                                                          (flatten)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (hide
                                                                 -2)
                                                                (("2"
                                                                  (expand
                                                                   "induction_step")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "del_vert(G!1,v!1)")
                                                                    (("2"
                                                                      (rewrite
                                                                       "size_del_vert")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "s!1"
                                                                           "t!1")
                                                                          (("2"
                                                                            (lemma
                                                                             "sep_num_del")
                                                                            (("2"
                                                                              (inst?)
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (lemma
                                                                                   "separable?_del")
                                                                                  (("2"
                                                                                    (inst?)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (flatten)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (skosimp*)
                                                                                            (("2"
                                                                                              (inst
                                                                                               +
                                                                                               "p1!1"
                                                                                               "p2!1")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "path_from?")
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (lemma
                                                                                                         "path?_del_vert")
                                                                                                        (("2"
                                                                                                          (inst?)
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (lemma
                                                                                                               "path?_del_vert")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -1
                                                                                                                 "G!1"
                                                                                                                 "v!1"
                                                                                                                 "p2!1")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (typepred "j!1")
                                    (("3" (assertnil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 4)
                                (("2"
                                  (expand "path_from?")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "from?")
                                      (("2"
                                        (hide 2 3)
                                        (("2"
                                          (expand "path?")
                                          (("2"
                                            (expand "walk?")
                                            (("2"
                                              (expand "verts_in?")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (inst-cp -4 "j!1")
                                                  (("1"
                                                    (inst -4 "j!1-1")
                                                    (("1"
                                                      (inst-cp
                                                       -6
                                                       "j!1-1")
                                                      (("1"
                                                        (inst -6 "j!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (expand
                                                             "disjoint?")
                                                            (("1"
                                                              (inst-cp
                                                               -
                                                               "j!1-1"
                                                               "j!1")
                                                              (("1"
                                                                (inst-cp
                                                                 -
                                                                 "j!1-1"
                                                                 "0")
                                                                (("1"
                                                                  (inst-cp
                                                                   -
                                                                   "j!1-1"
                                                                   "length(p!1)-1")
                                                                  (("1"
                                                                    (inst-cp
                                                                     -
                                                                     "j!1"
                                                                     "0")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "j!1"
                                                                       "length(p!1)-1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "separable?")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("3" (assertnil nil)
                               ("4" (assertnil nil)
                               ("5" (assertnil nil)
                               ("6" (assertnil nil))
                              nil))
                            nil)
                           ("2" (lemma "seq_j")
                            (("2" (ground)
                              (("2"
                                (inst?)
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "path_from?")
                                    (("2"
                                      (expand "from?")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (inst -1 "p!1" "t!1")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "separable?")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (split -1)
                                                      (("1"
                                                        (skosimp*)
                                                        (("1"
                                                          (inst
                                                           2
                                                           "j!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (case
                                                               "j!1 = 1")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (lemma
                                                                       "short_path_case")
                                                                      (("1"
                                                                        (inst
                                                                         -1
                                                                         "G!1"
                                                                         "s!1"
                                                                         "t!1"
                                                                         "seq(p!1)(1)")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "path?"
                                                                             -5)
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (expand
                                                                                 "walk?")
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "verts_in?")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "0")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                (("2"
                                                                  (case
                                                                   "j!1 = length(p!1) - 1")
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "path?"
                                                                           -4)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (expand
                                                                               "walk?")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "length(p!1)-2")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (expand
                                                         "path?"
                                                         -1)
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (expand
                                                             "walk?")
                                                            (("2"
                                                              (flatten)
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "length(p!1)-2")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sep_num_gt_0 formula-decl nil sep_set_lems nil)
    (walk_to_path_from formula-decl nil path_ops nil)
    (edge? const-decl "bool" graphs nil)
    (disjoint? const-decl "bool" meng_scaff_defs nil)
    (separates const-decl "bool" sep_sets nil)
    (dbl_comm formula-decl nil doubletons nil)
    (in? const-decl "bool" meng_scaff_defs nil)
    (prelude formula-decl nil meng_scaff_prelude nil)
    (del_verts const-decl "graph[T]" sep_sets nil)
    (independent? const-decl "bool" ind_paths nil)
    (path?_del_verts formula-decl nil path_ops nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (path?_gen_seq2 formula-decl nil paths nil)
    (path?_add1 formula-decl nil paths nil)
    (gen_seq2 const-decl "Seq(G)" walks nil)
    (Seq type-eq-decl nil walks nil)
    (add1 const-decl "prewalk" walks nil)
    (induction_step const-decl "bool" meng_scaff_prelude nil)
    (size_del_vert formula-decl nil graph_ops nil)
    (path?_del_vert formula-decl nil path_ops nil)
    (sep_num_le1 formula-decl nil sep_set_lems nil)
    (del_vert const-decl "graph[T]" graph_ops nil)
    (sep_num const-decl "nat" sep_sets nil)
    (path_from_l formula-decl nil paths nil)
    (path_from? const-decl "bool" paths nil)
    (walk? const-decl "bool" walks nil)
    (from? const-decl "bool" walks nil)
    (verts_in? const-decl "bool" walks nil)
    (path? const-decl "bool" paths nil)
    (separable? const-decl "bool" sep_sets nil)
    (prewalk type-eq-decl nil walks nil)
    (graph type-eq-decl nil graphs nil)
    (pregraph type-eq-decl nil graphs nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil))
   nil))
 (h_menger 0
  (h_menger-1 nil 3251049132
   ("" (induct "G" 1 "graph_induction_vert")
    (("" (skosimp*)
      (("" (lemma "finale")
        (("" (inst?)
          (("" (assert)
            (("" (split -1)
              (("1" (propax) nil nil)
               ("2" (hide 2)
                (("2" (expand "induction_step")
                  (("2" (propax) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((induction_step const-decl "bool" meng_scaff_prelude nil)
    (finale formula-decl nil h_menger nil)
    (graph_induction_vert formula-decl nil graph_inductions nil)
    (T formal-type-decl nil h_menger nil)
    (independent? const-decl "bool" ind_paths nil)
    (path_from? const-decl "bool" paths nil)
    (prewalk type-eq-decl nil walks nil)
    (> const-decl "bool" reals nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (below type-eq-decl nil nat_types nil)
    (sep_num const-decl "nat" sep_sets nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (separable? const-decl "bool" sep_sets nil)
    (pred type-eq-decl nil defined_types nil)
    (graph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pregraph type-eq-decl nil graphs nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (hard_menger 0
  (hard_menger-1 nil 3251049132
   ("" (skosimp*)
    (("" (lemma "h_menger")
      (("" (inst?)
        (("" (assert)
          (("" (skosimp*)
            ((""
              (inst +
               "add(p1!1,singleton[Path_from(G!1,s!1,t!1)](p2!1))")
              (("" (rewrite "card_add[Path_from(G!1, s!1, t!1)]")
                ((""
                  (rewrite "card_singleton[Path_from(G!1, s!1, t!1)]")
                  (("" (assert)
                    (("" (split +)
                      (("1" (lift-if)
                        (("1" (ground)
                          (("1" (expand "singleton")
                            (("1" (replace -1)
                              (("1"
                                (hide -1)
                                (("1"
                                  (case "length(p2!1) = 2")
                                  (("1"
                                    (expand "path_from?")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (hide -4 -5)
                                        (("1"
                                          (expand "path?")
                                          (("1"
                                            (expand "walk?")
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (hide -2 -4)
                                                (("1"
                                                  (inst - "0")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand
                                                       "finseq_appl")
                                                      (("1"
                                                        (expand
                                                         "separable?")
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (expand
                                                             "from?")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "independent?")
                                    (("2"
                                      (expand "path_from?")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst -5 "1" "1")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (case "length(p2!1) = 1")
                                              (("1"
                                                (expand "from?")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand
                                                       "separable?")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "ind_path_set?")
                        (("2" (skosimp*)
                          (("2" (expand "add")
                            (("2" (expand "member")
                              (("2"
                                (expand "singleton")
                                (("2"
                                  (lemma "independent?_comm")
                                  (("2"
                                    (inst -1 "p1!1" "p2!1")
                                    (("2"
                                      (assert)
                                      (("2" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((h_menger formula-decl nil h_menger nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set" finite_sets nil)
    (t!1 skolem-const-decl "T" h_menger nil)
    (s!1 skolem-const-decl "T" h_menger nil)
    (p1!1 skolem-const-decl "prewalk[T]" h_menger nil)
    (G!1 skolem-const-decl "graph[T]" h_menger nil)
    (path_from? const-decl "bool" paths nil)
    (prewalk type-eq-decl nil walks nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (p2!1 skolem-const-decl "prewalk[T]" h_menger nil)
    (Path_from type-eq-decl nil paths nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set_of_paths type-eq-decl nil ind_paths nil)
    (nonempty? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (singleton? const-decl "bool" sets nil)
    (singleton const-decl "(singleton?)" sets nil)
    (card_singleton formula-decl nil finite_sets nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (path? const-decl "bool" paths nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (from? const-decl "bool" walks nil)
    (separable? const-decl "bool" sep_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (walk? const-decl "bool" walks nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (independent? const-decl "bool" ind_paths nil)
    (member const-decl "bool" sets nil)
    (independent?_comm formula-decl nil ind_paths nil)
    (ind_path_set? const-decl "bool" ind_paths nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (card_add formula-decl nil finite_sets nil)
    (graph type-eq-decl nil graphs nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pregraph type-eq-decl nil graphs nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (doubleton type-eq-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil h_menger nil))
   nil)))


Messung V0.5 in Prozent
C=100 H=100 G=100

¤ Dauer der Verarbeitung: 0.270 Sekunden  (vorverarbeitet am  2026-05-06) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge