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


Quelle  circuit_deg.prf

  Sprache: Lisp
 

(circuit_deg
 (cir_deg_G 0
  (cir_deg_G-2 "Did not use e_duo" 3368433600
   ("" (skosimp*)
    (("" (expand "edge?")
      (("" (flatten)
        (("" (expand "deg")
          (("" (case " card(incident_edges(z!1, G!1)) =0")
            (("1" (lemma "finite_sets[doubleton[T]].card_empty?")
              (("1" (inst?)
                (("1" (iff)
                  (("1" (bddsimp)
                    (("1" (expand "empty?")
                      (("1" (inst -2 "dbl[T](a!1, z!1)")
                        (("1" (expand "member")
                          (("1" (hide -1 -4 5)
                            (("1" (install-rewrites "graphs[T]")
                              (("1" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (case " card(incident_edges(z!1, G!1)) =1")
              (("1" (lemma "finite_sets[doubleton[T]].card_one")
                (("1" (inst?)
                  (("1" (bddsimp)
                    (("1" (skosimp*)
                      (("1" (hide -1 1 5)
                        (("1" (install-rewrites "graphs[T]")
                          (("1" (assert)
                            (("1" (grind)
                              (("1"
                                (expand "incident_edges")
                                (("1"
                                  (expand "singleton")
                                  (("1"
                                    (decompose-equality -1)
                                    (("1"
                                      (copy -1)
                                      (("1"
                                        (inst -1 "dbl[T](a!1, z!1)")
                                        (("1"
                                          (inst -2 "dbl[T](b!1, z!1)")
                                          (("1"
                                            (bddsimp)
                                            (("1"
                                              (install-rewrites
                                               "doubletons[T]")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (replace -3 -6 rl)
                                                  (("1"
                                                    (hide -1 -3 -4)
                                                    (("1"
                                                      (grind)
                                                      (("1"
                                                        (lemma
                                                         "doubletons[T].dbl_eq")
                                                        (("1"
                                                          (inst
                                                           -1
                                                           "a!1"
                                                           "b!1"
                                                           "z!1"
                                                           "z!1")
                                                          (("1"
                                                            (prop)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (install-rewrites
                                               "doubletons[T]")
                                              (("2" (assertnil nil))
                                              nil)
                                             ("3" (assertnil nil)
                                             ("4" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assertnil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nil application-judgement "finite_set[T]" circuit_deg nil)
    (edge? const-decl "bool" graphs nil)
    (deg const-decl "nat" graph_deg nil)
    (singleton const-decl "(singleton?)" sets nil)
    (dbl_eq formula-decl nil doubletons nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set" finite_sets nil)
    (card_one formula-decl nil finite_sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (card_empty? formula-decl nil finite_sets nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (T formal-type-decl nil circuit_deg 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)
    (dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets 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)
    (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)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" 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)
    (incident_edges const-decl "finite_set[doubleton[T]]" graph_deg
     nil))
   shostak)
  (cir_deg_G-1 nil 3251049115
   ("" (skosimp*)
    (("" (expand "edge?")
      (("" (flatten)
        (("" (expand "deg")
          ((""
            (case "subset?(e_duo(dbl(a!1,z!1),dbl(b!1,z!1)),
                     incident_edges(z!1, G!1))")
            (("1" (lemma "card_subset[doubleton[T]]")
              (("1" (inst?)
                (("1"
                  (case "card(e_duo(dbl(a!1, z!1), dbl(b!1, z!1))) = 2")
                  (("1" (assertnil)
                   ("2" (hide -1 -2 3)
                    (("2" (expand "e_duo")
                      (("2" (rewrite "card_add[doubleton[T]]")
                        (("2" (rewrite "card_singleton[doubleton[T]]")
                          (("2" (lift-if)
                            (("2" (ground)
                              (("2"
                                (hide 1)
                                (("2"
                                  (expand "singleton")
                                  (("2"
                                    (case
                                     "dbl(a!1, z!1)(a!1) = dbl(b!1, z!1)(a!1)")
                                    (("1"
                                      (case
                                       "dbl(a!1, z!1)(b!1) = dbl(b!1, z!1)(b!1)")
                                      (("1"
                                        (hide -3)
                                        (("1"
                                          (expand "dbl")
                                          (("1" (propax) nil)))))
                                       ("2" (assertnil)))
                                     ("2"
                                      (assert)
                                      nil)))))))))))))))))))))
                 ("2" (hide -1 3)
                  (("2" (assert)
                    (("2" (inst 1 "b!1" "z!1")
                      (("2" (assertnil)))))))
                 ("3" (inst?) (("3" (assertnil)))))))
             ("2" (hide 3)
              (("2" (expand "subset?")
                (("2" (skosimp*)
                  (("2" (expand "member")
                    (("2" (expand "incident_edges")
                      (("2"
                        (case "x!1 = dbl(a!1, z!1) OR x!1 = dbl(b!1, z!1)")
                        (("1" (hide -2)
                          (("1" (split -1)
                            (("1" (replace -1)
                              (("1"
                                (hide -1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "dbl")
                                    (("1" (propax) nil)))))))))
                             ("2" (replace -1)
                              (("2"
                                (hide -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "dbl")
                                    (("2" (propax) nil)))))))))))))
                         ("2" (hide -2 -3 -4 2 3)
                          (("2" (expand "e_duo")
                            (("2" (expand "add")
                              (("2"
                                (expand "member")
                                (("2"
                                  (expand "singleton")
                                  (("2"
                                    (ground)
                                    nil)))))))))))))))))))))))
             ("3" (inst 1 "b!1" "z!1") (("3" (assertnil)))
             ("4" (inst?) (("4" (assertnil))))))))))))
    nil)
   ((edge? const-decl "bool" graphs nil)
    (deg const-decl "nat" graph_deg nil)
    (dbl_eq formula-decl nil doubletons nil)
    (dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (pregraph type-eq-decl nil graphs nil)
    (graph type-eq-decl nil graphs nil)
    (incident_edges const-decl "finite_set[doubleton[T]]" graph_deg
     nil))
   nil))
 (circuit_deg_TCC1 0
  (circuit_deg_TCC1-1 nil 3251049115 ("" (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)
    (walk? const-decl "bool" walks nil)
    (Walk type-eq-decl nil walks 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)
    (below type-eq-decl nil naturalnumbers nil)
    (G!1 skolem-const-decl "graph[T]" circuit_deg nil)
    (edge? const-decl "bool" graphs 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nil application-judgement "finite_set[T]" circuit_deg nil)
    (T formal-type-decl nil circuit_deg nil)
    (verts_in? const-decl "bool" walks nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (circuit_deg 0
  (circuit_deg-2 "Update from cir_deg_G" 3368440612
   ("" (skosimp*)
    (("" (lemma " cir_deg_G")
      (("" (inst -1 "G_from(G!1,w!1)" "w!1`seq(i!1)")
        (("" (expand "finseq_appl")
          (("" (bddsimp)
            (("" (hide 2)
              (("" (typepred "i!1")
                (("" (expand "circuit?")
                  (("" (expand "cyclically_reduced?")
                    (("" (expand "finseq_appl")
                      (("" (flatten)
                        (("" (case "i!1=length(w!1)-1")
                          (("1" (expand "pre_circuit?")
                            (("1" (expand "finseq_appl")
                              (("1"
                                (inst 1 "w!1(1)" "w!1(length(w!1)-2)")
                                (("1"
                                  (expand "finseq_appl")
                                  (("1"
                                    (prop)
                                    (("1"
                                      (hide -4)
                                      (("1"
                                        (install-rewrites "walks[T]")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (inst 1 "i!1")
                                            nil
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (replace -1 1 lr)
                                      (("2"
                                        (replace -5 * rl)
                                        (("2"
                                          (hide -4)
                                          (("2"
                                            (install-rewrites
                                             "walks[T]")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (prop)
                                                (("1"
                                                  (typepred "w!1")
                                                  (("1"
                                                    (expand "walk?")
                                                    (("1"
                                                      (expand
                                                       "finseq_appl")
                                                      (("1"
                                                        (prop)
                                                        (("1"
                                                          (inst -3 "0")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (inst 1 "0")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand "dbl")
                                                      (("2"
                                                        (ground)
                                                        (("2"
                                                          (grind)
                                                          (("2"
                                                            (apply-extensionality
                                                             1
                                                             :hide?
                                                             t)
                                                            (("2"
                                                              (iff)
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("3"
                                      (replace -1 1 lr)
                                      (("3"
                                        (hide -4)
                                        (("3"
                                          (typepred "w!1")
                                          (("3"
                                            (expand "walk?")
                                            (("3"
                                              (expand "finseq_appl")
                                              (("3"
                                                (flatten)
                                                (("3"
                                                  (inst
                                                   -3
                                                   "length(w!1)-2")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (install-rewrites
                                                       "walks[T]")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (bddsimp)
                                                            (("1"
                                                              (inst
                                                               2
                                                               "length(w!1)-2")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "finseq_appl")
                                  (("2"
                                    (assert)
                                    (("2"
                                      (install-rewrites "walks[T]")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (inst 1 "length(w!1)-2")
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3" (assertnil nil)
                                 ("4"
                                  (install-rewrites "walks[T]")
                                  (("4"
                                    (assert)
                                    (("4" (inst 1 "1"nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (case "i!1=0")
                            (("1" (replace -1 + lr)
                              (("1"
                                (inst
                                 2
                                 " w!1`seq(1)"
                                 "w!1`seq(length(w!1) - 2)")
                                (("1"
                                  (prop)
                                  (("1"
                                    (hide -4 -5)
                                    (("1"
                                      (typepred "w!1")
                                      (("1"
                                        (install-rewrites "walks[T]")
                                        (("1"
                                          (assert)
                                          (("1" (inst 1 "0"nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide -4 -5)
                                    (("2"
                                      (typepred "w!1")
                                      (("2"
                                        (install-rewrites "walks[T]")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (prop)
                                            (("1"
                                              (inst -4 "0")
                                              (("1"
                                                (prop)
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (inst 1 "0")
                                              (("2"
                                                (hide -2 -3)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (lemma "dbl_comm")
                                                    (("2"
                                                      (inst?)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (hide -4)
                                    (("3"
                                      (expand "pre_circuit?")
                                      (("3"
                                        (expand "finseq_appl")
                                        (("3"
                                          (replace -4 1 lr)
                                          (("3"
                                            (hide -4)
                                            (("3"
                                              (typepred "w!1")
                                              (("3"
                                                (install-rewrites
                                                 "walks[T]")
                                                (("3"
                                                  (assert)
                                                  (("3"
                                                    (flatten)
                                                    (("3"
                                                      (bddsimp)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (reveal -1)
                                                          (("1"
                                                            (inst
                                                             -4
                                                             "length(w!1)-2")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (inst
                                                         1
                                                         "length(w!1)-2")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide -4 -5)
                                  (("2"
                                    (install-rewrites "walks[T]")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (inst 1 "length(w!1)-2")
                                        nil
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3" (assertnil nil)
                                 ("4"
                                  (hide -4 -5)
                                  (("4"
                                    (install-rewrites "walks[T]")
                                    (("4"
                                      (assert)
                                      (("4" (inst 1 "1"nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2"
                              (inst 3 "seq(w!1)(i!1-1)"
                               "seq(w!1)(i!1+1)")
                              (("1"
                                (hide -4)
                                (("1"
                                  (bddsimp)
                                  (("1"
                                    (hide -3)
                                    (("1"
                                      (install-rewrites "walks[T]")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (prop)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (typepred "w!1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst -3 "i!1")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (inst 1 "i!1")
                                            (("2"
                                              (rewrite "dbl_comm")
                                              nil
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide -3)
                                    (("2"
                                      (typepred "w!1")
                                      (("2"
                                        (install-rewrites "walks[T]")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (bddsimp)
                                            (("1"
                                              (inst -3 "i!1-1")
                                              (("1" (assertnil nil))
                                              nil)
                                             ("2"
                                              (inst 3 "i!1-1")
                                              (("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (prop)
                                    (("3"
                                      (expand "reduced?")
                                      (("3"
                                        (expand "reducible?")
                                        (("3"
                                          (expand "finseq_appl")
                                          (("3"
                                            (inst 3 "i!1")
                                            (("1" (assertnil nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("4"
                                    (typepred "w!1")
                                    (("4"
                                      (install-rewrites "walks[T]")
                                      (("4"
                                        (assert)
                                        (("4" (inst 3 "i!1"nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -3 -4)
                                (("2"
                                  (typepred "w!1")
                                  (("2"
                                    (install-rewrites "walks[T]")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst 1 "i!1+1")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("3" (assertnil nil)
                               ("4"
                                (hide -3 -4)
                                (("4"
                                  (typepred "w!1")
                                  (("4"
                                    (install-rewrites "walks[T]")
                                    (("4"
                                      (assert)
                                      (("4"
                                        (flatten)
                                        (("4"
                                          (inst 1 "i!1-1")
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("5" (assertnil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cir_deg_G formula-decl nil circuit_deg nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (circuit? const-decl "bool" circuits nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (reduced? const-decl "bool" circuits nil)
    (reducible? const-decl "bool" circuits nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nil application-judgement "finite_set[T]" circuit_deg nil)
    (edges_of const-decl "finite_set[doubleton[T]]" walks nil)
    (edge? const-decl "bool" graphs nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (verts_in? const-decl "bool" walks nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (w!1 skolem-const-decl "Walk[T](G!1)" circuit_deg nil)
    (G!1 skolem-const-decl "graph[T]" circuit_deg nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (pre_circuit? const-decl "bool" walks nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (i!1 skolem-const-decl "below(length(w!1))" circuit_deg nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (dbl_comm formula-decl nil doubletons nil)
    (cyclically_reduced? const-decl "bool" circuits nil)
    (NOT const-decl "[bool -> bool]" booleans 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)
    (G_from const-decl "Subgraph(G)" subgraphs_from_walk nil)
    (Subgraph type-eq-decl nil subgraphs nil)
    (subgraph? const-decl "bool" subgraphs nil)
    (Walk type-eq-decl nil walks nil)
    (walk? const-decl "bool" 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)
    (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 circuit_deg nil))
   shostak)
  (circuit_deg-1 nil 3251049115
   ("" (skosimp*)
    (("" (rewrite "cir_deg_G")
      (("" (expand "circuit?")
        (("" (expand "cyclically_reduced?")
          (("" (flatten)
            (("" (case "i!1 = 0")
              (("1" (hide 2)
                (("1" (inst 1 "w!1(length(w!1)-2)" "w!1(i!1+1)")
                  (("1" (prop)
                    (("1" (rewrite "vert_G_from"nil nil)
                     ("2" (replace -2)
                      (("2" (hide -2)
                        (("2" (assert)
                          (("2" (reveal 2) (("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("3" (expand "pre_circuit?")
                      (("3" (lemma "edge?_G_from")
                        (("3" (inst?)
                          (("1" (assertnil nil)
                           ("2" (assertnil nil))
                          nil))
                        nil))
                      nil)
                     ("4" (rewrite "edge?_G_from_rev"nil nil))
                    nil)
                   ("2" (rewrite "vert_G_from"nil nil)
                   ("3" (assertnil nil)
                   ("4" (rewrite "vert_G_from"nil nil)
                   ("5" (assertnil nil))
                  nil))
                nil)
               ("2" (case "i!1 = length(w!1)-1")
                (("1" (inst 2 "w!1(length(w!1)-2)" "w!1(1)")
                  (("1" (prop)
                    (("1" (rewrite "vert_G_from"nil nil)
                     ("2" (assertnil nil)
                     ("3" (replace -1)
                      (("3" (hide -1)
                        (("3" (rewrite "edge?_G_from"nil nil)) nil))
                      nil)
                     ("4" (expand "pre_circuit?")
                      (("4" (replace -1)
                        (("4" (hide -1)
                          (("4" (lemma "edge?_G_from_rev")
                            (("4" (inst -1 "G!1" "w!1" 0)
                              (("1" (assertnil nil)
                               ("2" (assertnil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (rewrite "vert_G_from"nil nil)
                   ("3" (assert)
                    (("3" (rewrite "vert_G_from"nil nil)) nil)
                   ("4" (hide 3 4) (("4" (assertnil nil)) nil))
                  nil)
                 ("2" (inst 3 "w!1(i!1-1)" "w!1(i!1+1)")
                  (("1" (prop)
                    (("1" (expand "G_from")
                      (("1" (expand "verts_of")
                        (("1" (inst 1 "i!1"nil nil)) nil))
                      nil)
                     ("2" (expand "reduced?")
                      (("2" (expand "reducible?")
                        (("2" (inst?)
                          (("1" (assertnil nil)
                           ("2" (assertnil nil))
                          nil))
                        nil))
                      nil)
                     ("3" (rewrite "edge?_G_from"nil nil)
                     ("4" (rewrite "edge?_G_from_rev"nil nil))
                    nil)
                   ("2" (rewrite "vert_G_from"nil nil)
                   ("3" (assertnil nil)
                   ("4" (rewrite "vert_G_from"nil nil)
                   ("5" (assertnil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((dbl const-decl "set[T]" doubletons nil)
    (doubleton type-eq-decl nil doubletons nil)
    (pregraph type-eq-decl nil graphs nil)
    (graph type-eq-decl nil graphs nil)
    (prewalk type-eq-decl nil walks nil)
    (walk? const-decl "bool" walks nil)
    (Walk type-eq-decl nil walks nil)
    (subgraph? const-decl "bool" subgraphs nil)
    (Subgraph type-eq-decl nil subgraphs nil)
    (G_from const-decl "Subgraph(G)" subgraphs_from_walk nil)
    (cyclically_reduced? const-decl "bool" circuits nil)
    (edge?_G_from_rev formula-decl nil subgraphs_from_walk nil)
    (pre_circuit? const-decl "bool" walks nil)
    (edge?_G_from formula-decl nil subgraphs_from_walk nil)
    (vert_G_from formula-decl nil subgraphs_from_walk nil)
    (reduced? const-decl "bool" circuits nil)
    (reducible? const-decl "bool" circuits nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (circuit? const-decl "bool" circuits nil))
   nil))
 (circuit_subgraph_len_1_TCC1 0
  (circuit_subgraph_len_1_TCC1-1 nil 3251049115
   ("" (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)
    (walk? const-decl "bool" walks nil)
    (Walk type-eq-decl nil walks 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)
    (below type-eq-decl nil naturalnumbers nil)
    (G!1 skolem-const-decl "graph[T]" circuit_deg nil)
    (edge? const-decl "bool" graphs 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nil application-judgement "finite_set[T]" circuit_deg nil)
    (T formal-type-decl nil circuit_deg nil)
    (verts_in? const-decl "bool" walks nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (circuit_subgraph_len_1 1
  (circuit_subgraph_len_1-2 "why long" 3368532619
   ("" (skosimp*)
    (("" (lemma "circuit_deg")
      (("" (inst?)
        (("" (typepred "w!1")
          (("" (inst -3 "0")
            (("" (bddsimp)
              (("" (hide -3)
                (("" (lemma "finite_sets[T].card_empty?")
                  (("" (inst?)
                    (("" (iff)
                      (("" (lemma "finite_sets[T].card_one")
                        (("" (inst?)
                          (("" (expand "deg")
                            (("" (expand "incident_edges")
                              ((""
                                (bddsimp -2)
                                (("1"
                                  (expand "empty?")
                                  (("1"
                                    (expand "member")
                                    (("1"
                                      (inst -2 "seq(w!1)(0)")
                                      (("1"
                                        (hide -1 -2 -5 2)
                                        (("1"
                                          (install-rewrites "walks[T]")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst 1 "0")
                                              nil
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (lemma "finite_sets[T].card_empty?")
                                  (("2"
                                    (inst
                                     -1
                                     "({e: doubleton[T] |
                      edges(G_from(G!1, w!1))(e) AND e(seq(w!1)(0))})")
                                    (("1"
                                      (iff)
                                      (("1"
                                        (bddsimp)
                                        (("1"
                                          (hide -2 -3 -4 3)
                                          (("1"
                                            (expand "singleton_elt")
                                            (("1"
                                              (expand "member")
                                              (("1"
                                                (expand "the")
                                                (("1"
                                                  (lemma
                                                   "finite_sets[doubleton[T]].nonempty_card")
                                                  (("1"
                                                    (inst
                                                     -1
                                                     "{e: doubleton[T] |
                              edges(G_from(G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                    (("1"
                                                      (bddsimp)
                                                      (("1"
                                                        (expand
                                                         "nonempty?")
                                                        (("1"
                                                          (expand
                                                           "empty?")
                                                          (("1"
                                                            (skosimp*)
                                                            (("1"
                                                              (expand
                                                               "member")
                                                              (("1"
                                                                (reveal
                                                                 1)
                                                                (("1"
                                                                  (flatten)
                                                                  (("1"
                                                                    (hide
                                                                     -3
                                                                     -8)
                                                                    (("1"
                                                                      (lemma
                                                                       "edge_in_card_gt_1")
                                                                      (("1"
                                                                        (inst
                                                                         -1
                                                                         "G_from(G!1, w!1)"
                                                                         "x!1")
                                                                        (("1"
                                                                          (prop)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide -1 -4 2 3)
                                                      (("2"
                                                        (lemma
                                                         "finite_sets[doubleton[T]].finite_subset")
                                                        (("2"
                                                          (inst
                                                           -1
                                                           "{e: doubleton[T] |
                                  edges(G_from[T](G!1, w!1))(e) }"
                                                           "{e: doubleton[T] |
                                  edges(G_from[T](G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                          (("1"
                                                            (bddsimp)
                                                            (("1"
                                                              (hide 2)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (expand
                                                               "G_from")
                                                              (("2"
                                                                (expand
                                                                 "edges_of")
                                                                (("2"
                                                                  (lemma
                                                                   "finite_sets[doubleton[T]].finite_subset")
                                                                  (("2"
                                                                    (inst
                                                                     -1
                                                                     "{e: doubleton[T] |
                                      edges(G!1)(e) }"
                                                                     "{e: doubleton[T] |EXISTS (i: below(length(w!1) - 1)):
                                        e = dbl(seq(w!1)(i), seq(w!1)(1 + i))
                                     }")
                                                                    (("1"
                                                                      (bddsimp)
                                                                      (("1"
                                                                        (hide
                                                                         2)
                                                                        (("1"
                                                                          (install-rewrites
                                                                           "walks[T]")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (bddsimp)
                                                                              (("1"
                                                                                (skosimp*)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   1
                                                                                   lr)
                                                                                  (("1"
                                                                                    (inst
                                                                                     -4
                                                                                     "i!1")
                                                                                    (("1"
                                                                                      (typepred
                                                                                       "i!1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (install-rewrites
                                                                         "graphs[T]")
                                                                        (("2"
                                                                          (typepred
                                                                           "G!1")
                                                                          (("2"
                                                                            (typepred
                                                                             "edges(G!1)")
                                                                            (("2"
                                                                              (hide
                                                                               -2
                                                                               -4)
                                                                              (("2"
                                                                                (case
                                                                                 "edges(G!1)={e: doubleton[T] | edges(G!1)(e)}")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   -2
                                                                                   lr)
                                                                                  (("1"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (hide
                                                                                   -1
                                                                                   2)
                                                                                  (("2"
                                                                                    (grind)
                                                                                    (("2"
                                                                                      (apply-extensionality
                                                                                       1
                                                                                       :hide?
                                                                                       t)
                                                                                      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" (assertnil nil)
                                         ("3"
                                          (hide -5 1 3 5)
                                          (("3"
                                            (expand "empty?" 1)
                                            (("3"
                                              (skosimp*)
                                              (("3"
                                                (expand "member")
                                                (("3"
                                                  (lemma
                                                   "edge_in_card_gt_1")
                                                  (("3"
                                                    (inst
                                                     -1
                                                     "G_from(G!1,w!1)"
                                                     "x!1")
                                                    (("1"
                                                      (bddsimp)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (expand
                                                         "singleton_elt")
                                                        (("2"
                                                          (expand
                                                           "singleton")
                                                          (("2"
                                                            (expand
                                                             "member")
                                                            (("2"
                                                              (expand
                                                               "the")
                                                              (("2"
                                                                (hide
                                                                 -2
                                                                 -3
                                                                 2)
                                                                (("2"
                                                                  (lemma
                                                                   "epsilons[doubleton[T]].epsilon_ax")
                                                                  (("1"
                                                                    (inst
                                                                     -1
                                                                     "LAMBDA (x: doubleton[T]):
                                            edges(G_from(G!1, w!1))(x) AND x(seq(w!1)(0))")
                                                                    (("1"
                                                                      (bddsimp)
                                                                      (("1"
                                                                        (reveal
                                                                         4)
                                                                        (("1"
                                                                          (lemma
                                                                           "edge_in_card_gt_1")
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "G_from(G!1,w!1)"
                                                                             "epsilon(LAMBDA (x: doubleton[T]):
                                                     edges(G_from(G!1, w!1))(x) AND x(seq(w!1)(0)))")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (lemma
                                                                               "finite_sets[doubleton[T]].nonempty_card")
                                                                              (("2"
                                                                                (inst
                                                                                 -1
                                                                                 "{e: doubleton[T] |
                                                  edges(G_from(G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (bddsimp)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "nonempty?")
                                                                                      (("1"
                                                                                        (expand
                                                                                         "empty?")
                                                                                        (("1"
                                                                                          (skosimp*)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "member")
                                                                                            (("1"
                                                                                              (hide
                                                                                               -2
                                                                                               -3
                                                                                               -4
                                                                                               -5)
                                                                                              (("1"
                                                                                                (inst
                                                                                                 1
                                                                                                 "x!3")
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (reveal
                                                                                         -6)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (lemma
                                                                                   "finite_sets[doubleton[T]].finite_subset")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -1
                                                                                     "{e: doubleton[T] |
                                                      edges(G_from[T](G!1, w!1))(e) }"
                                                                                     "{e: doubleton[T] |
                                                      edges(G_from[T](G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                                                    (("1"
                                                                                      (hide
                                                                                       -2
                                                                                       -3
                                                                                       -4
                                                                                       2)
                                                                                      (("1"
                                                                                        (bddsimp)
                                                                                        (("1"
                                                                                          (hide
                                                                                           2)
                                                                                          (("1"
                                                                                            (grind)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       -2
                                                                                       -3
                                                                                       2
                                                                                       3)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "G_from")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "edges_of")
                                                                                          (("2"
                                                                                            (lemma
                                                                                             "finite_sets[doubleton[T]].finite_subset")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -1
                                                                                               "{e: doubleton[T] |
                                                                      edges(G!1)(e) }"
                                                                                               "{e: doubleton[T] |EXISTS (i: below(length(w!1) - 1)):
                                                                        e = dbl(seq(w!1)(i), seq(w!1)(1 + i))
                                                                     }")
                                                                                              (("1"
                                                                                                (bddsimp)
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   2
                                                                                                   4)
                                                                                                  (("1"
                                                                                                    (install-rewrites
                                                                                                     "walks[T]")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (bddsimp)
                                                                                                        (("1"
                                                                                                          (skosimp*)
                                                                                                          (("1"
                                                                                                            (replace
                                                                                                             -1
                                                                                                             1
                                                                                                             lr)
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -5
                                                                                                               "i!1")
                                                                                                              (("1"
                                                                                                                (typepred
                                                                                                                 "i!1")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide
                                                                                                 2
                                                                                                 4)
                                                                                                (("2"
                                                                                                  (install-rewrites
                                                                                                   "graphs[T]")
                                                                                                  (("2"
                                                                                                    (typepred
                                                                                                     "G!1")
                                                                                                    (("2"
                                                                                                      (typepred
                                                                                                       "edges(G!1)")
                                                                                                      (("2"
                                                                                                        (hide
                                                                                                         -3)
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "edges(G!1)={e: doubleton[T] | edges(G!1)(e)}")
                                                                                                          (("1"
                                                                                                            (replace
                                                                                                             -1
                                                                                                             -2
                                                                                                             lr)
                                                                                                            (("1"
                                                                                                              (propax)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             -1
                                                                                                             -2
                                                                                                             2)
                                                                                                            (("2"
                                                                                                              (apply-extensionality
                                                                                                               1
                                                                                                               :hide?
                                                                                                               t)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "finite_sets[doubleton[T]].nonempty_card")
                                                                        (("2"
                                                                          (inst
                                                                           -1
                                                                           "{e: doubleton[T] |
                                              edges(G_from(G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                                          (("1"
                                                                            (reveal
                                                                             -5)
                                                                            (("1"
                                                                              (bddsimp)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (expand
                                                                                   "nonempty?")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "empty?")
                                                                                    (("1"
                                                                                      (hide
                                                                                       -2
                                                                                       -3)
                                                                                      (("1"
                                                                                        (skosimp*)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "member")
                                                                                          (("1"
                                                                                            (inst
                                                                                             1
                                                                                             "x!3")
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (reveal
                                                                                 -6)
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (lemma
                                                                             "finite_sets[doubleton[T]].finite_subset")
                                                                            (("2"
                                                                              (inst
                                                                               -1
                                                                               "{e: doubleton[T] |
                                                  edges(G_from[T](G!1, w!1))(e) }"
                                                                               "{e: doubleton[T] |
                                                  edges(G_from[T](G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                                              (("1"
                                                                                (bddsimp)
                                                                                (("1"
                                                                                  (hide
                                                                                   2
                                                                                   3)
                                                                                  (("1"
                                                                                    (grind)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2
                                                                                 3)
                                                                                (("2"
                                                                                  (expand
                                                                                   "G_from")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "edges_of")
                                                                                    (("2"
                                                                                      (lemma
                                                                                       "finite_sets[doubleton[T]].finite_subset")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -1
                                                                                         "{e: doubleton[T] |
                                                      edges(G!1)(e) }"
                                                                                         "{e: doubleton[T] |EXISTS (i: below(length(w!1) - 1)):
                                                        e = dbl(seq(w!1)(i), seq(w!1)(1 + i))
                                                     }")
                                                                                        (("1"
                                                                                          (bddsimp)
                                                                                          (("1"
                                                                                            (hide
                                                                                             2)
                                                                                            (("1"
                                                                                              (install-rewrites
                                                                                               "walks[T]")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (skosimp*)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -5
                                                                                                     "i!1")
                                                                                                    (("1"
                                                                                                      (typepred
                                                                                                       "i!1")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide
                                                                                           -1
                                                                                           2
                                                                                           3)
                                                                                          (("2"
                                                                                            (install-rewrites
                                                                                             "graphs[T]")
                                                                                            (("2"
                                                                                              (typepred
                                                                                               "edges(G!1)")
                                                                                              (("2"
                                                                                                (case
                                                                                                 "edges(G!1)={e: doubleton[T] | edges(G!1)(e)}")
                                                                                                (("1"
                                                                                                  (replace
                                                                                                   -1
                                                                                                   -2
                                                                                                   lr)
                                                                                                  (("1"
                                                                                                    (propax)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   -1
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (apply-extensionality
                                                                                                     1
                                                                                                     :hide?
                                                                                                     t)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (lemma
                                                                     "finite_sets[doubleton[T]].nonempty_card")
                                                                    (("2"
                                                                      (reveal
                                                                       -4)
                                                                      (("2"
                                                                        (inst
                                                                         -2
                                                                         "{e: doubleton[T] |
                                          edges(G_from(G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                                        (("1"
                                                                          (expand
                                                                           "nonempty?")
                                                                          (("1"
                                                                            (expand
                                                                             "empty?")
                                                                            (("1"
                                                                              (bddsimp)
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil)
                                                                               ("2"
                                                                                (skosimp*)
                                                                                (("2"
                                                                                  (expand
                                                                                   "member")
                                                                                  (("2"
                                                                                    (inst
                                                                                     1
                                                                                     "x!3")
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (lemma
                                                                           "finite_sets[doubleton[T]].finite_subset")
                                                                          (("2"
                                                                            (inst
                                                                             -1
                                                                             "{e: doubleton[T] |
                                                edges(G_from[T](G!1, w!1))(e) }"
                                                                             "{e: doubleton[T] |
                                                edges(G_from[T](G!1, w!1))(e) AND e(seq(w!1)(0))}")
                                                                            (("1"
                                                                              (bddsimp)
                                                                              (("1"
                                                                                (hide
                                                                                 2
                                                                                 3)
                                                                                (("1"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2
                                                                               3)
                                                                              (("2"
                                                                                (expand
                                                                                 "G_from")
                                                                                (("2"
                                                                                  (expand
                                                                                   "edges_of")
                                                                                  (("2"
                                                                                    (lemma
                                                                                     "finite_sets[doubleton[T]].finite_subset")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -1
                                                                                       "{e: doubleton[T] |
                                                    edges(G!1)(e) }"
                                                                                       "{e: doubleton[T] |EXISTS (i: below(length(w!1) - 1)):
                                                      e = dbl(seq(w!1)(i), seq(w!1)(1 + i))
                                                   }")
                                                                                      (("1"
                                                                                        (bddsimp)
                                                                                        (("1"
                                                                                          (hide
                                                                                           2)
                                                                                          (("1"
                                                                                            (install-rewrites
                                                                                             "walks[T]")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (skosimp*)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -6
                                                                                                   "i!1")
                                                                                                  (("1"
                                                                                                    (typepred
                                                                                                     "i!1")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         -1
                                                                                         2
                                                                                         3)
                                                                                        (("2"
                                                                                          (install-rewrites
                                                                                           "graphs[T]")
                                                                                          (("2"
                                                                                            (typepred
                                                                                             "edges(G!1)")
                                                                                            (("2"
                                                                                              (case
                                                                                               "edges(G!1)={e: doubleton[T] | edges(G!1)(e)}")
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -1
                                                                                                 -2
                                                                                                 lr)
                                                                                                (("1"
                                                                                                  (propax)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide
                                                                                                 -1
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (apply-extensionality
                                                                                                   1
                                                                                                   :hide?
                                                                                                   t)
                                                                                                  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 -2 -3 2)
                                                      (("2"
                                                        (grind)
                                                        (("1"
                                                          (reveal -4)
                                                          (("1"
                                                            (hide -2)
                                                            (("1"
                                                              (expand
                                                               "singleton")
                                                              (("1"
                                                                (expand
                                                                 "G_from")
                                                                (("1"
                                                                  (expand
                                                                   "verts_of")
                                                                  (("1"
                                                                    (copy
                                                                     -1)
                                                                    (("1"
                                                                      (decompose-equality
                                                                       -1)
                                                                      (("1"
                                                                        (inst
                                                                         -1
                                                                         "seq(w!1)(0)")
                                                                        (("1"
                                                                          (iff)
                                                                          (("1"
                                                                            (bddsimp)
                                                                            (("1"
                                                                              (decompose-equality
                                                                               -3)
                                                                              (("1"
                                                                                (inst
                                                                                 -1
                                                                                 "seq(w!1)(1)")
                                                                                (("1"
                                                                                  (iff)
                                                                                  (("1"
                                                                                    (bddsimp)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -2
                                                                                       -4
                                                                                       rl)
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (inst
                                                                                       1
                                                                                       "1")
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (inst
                                                                               1
                                                                               "0")
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide -1)
                                                          (("2"
                                                            (install-rewrites
                                                             "walks[T]")
                                                            (("2"
                                                              (reveal
                                                               -10)
                                                              (("2"
                                                                (expand
                                                                 "circuit?")
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (expand
                                                                     "cyclically_reduced?")
                                                                    (("2"
                                                                      (propax)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("4" (assertnil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (install-rewrites "walks[T]")
                                      (("2"
                                        (reveal -3)
                                        (("2"
                                          (expand "circuit?")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (expand
                                               "cyclically_reduced?")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (hide
                                                   -2
                                                   -3
                                                   -4
                                                   -5
                                                   -6
                                                   -8
                                                   2
                                                   4)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "verts_of")
                                                      (("2"
                                                        (case
                                                         " card({t: T | EXISTS (i: below(length(w!1))): seq(w!1)(i) = t}) =1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide 2 3)
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (lemma
                                                                 "finite_sets[T].card_one")
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (bddsimp)
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (decompose-equality
                                                                           -1)
                                                                          (("1"
                                                                            (copy
                                                                             -1)
                                                                            (("1"
                                                                              (inst
                                                                               -1
                                                                               "seq(w!1)(0)")
                                                                              (("1"
                                                                                (inst
                                                                                 -2
                                                                                 "seq(w!1)(1)")
                                                                                (("1"
                                                                                  (iff)
                                                                                  (("1"
                                                                                    (bddsimp)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -7
                                                                                       "0")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (inst
                                                                                       1
                                                                                       "1")
                                                                                      nil
                                                                                      nil)
                                                                                     ("3"
                                                                                      (inst
                                                                                       1
                                                                                       "0")
                                                                                      nil
                                                                                      nil)
                                                                                     ("4"
                                                                                      (inst
                                                                                       1
                                                                                       "0")
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (case-replace
                                                                     "is_finite({t: T | EXISTS (i: below(length(w!1))): seq(w!1)(i) = t})")
                                                                    (("1"
                                                                      (hide
                                                                       -2
                                                                       -3
                                                                       -4
                                                                       -5)
                                                                      (("1"
                                                                        (grind)
                                                                        nil
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (lemma
                                                                         "finite_sets[T].finite_subset")
                                                                        (("2"
                                                                          (typepred
                                                                           "vert(G!1)")
                                                                          (("2"
                                                                            (inst
                                                                             -2
                                                                             "vert(G!1)"
                                                                             "{t: T | EXISTS (i: below(length(w!1))): seq(w!1)(i) = t}")
                                                                            (("2"
                                                                              (bddsimp)
                                                                              (("2"
                                                                                (hide-all-but
                                                                                 (-4
                                                                                  1))
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("3"
                                                          (case-replace
                                                           "is_finite({t: T | EXISTS (i: below(length(w!1))): seq(w!1)(i) = t})")
                                                          (("1"
                                                            (hide
                                                             -2
                                                             -3
                                                             -4
                                                             -5)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (lemma
                                                               "finite_sets[T].finite_subset")
                                                              (("2"
                                                                (typepred
                                                                 "vert(G!1)")
                                                                (("2"
                                                                  (inst
                                                                   -2
                                                                   "vert(G!1)"
                                                                   "{t: T | EXISTS (i: below(length(w!1))): seq(w!1)(i) = t}")
                                                                  (("2"
                                                                    (bddsimp)
                                                                    (("2"
                                                                      (hide-all-but
                                                                       (-3
                                                                        1))
                                                                      (("2"
                                                                        (grind)
                                                                        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)
   ((incident_edges const-decl "finite_set[doubleton[T]]" graph_deg
     nil)
    (cyclically_reduced? const-decl "bool" circuits nil)
    (circuit? const-decl "bool" circuits nil)
    (edges_of const-decl "finite_set[doubleton[T]]" walks nil)
    (edge_in_card_gt_1 formula-decl nil graphs nil)
    (finite_doubleton formula-decl nil doubletons nil)
    (edge? const-decl "bool" graphs nil)
    (verts_in? const-decl "bool" walks nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (deg const-decl "nat" graph_deg nil)
    (subgraph? const-decl "bool" subgraphs nil)
    (Subgraph type-eq-decl nil subgraphs nil)
    (G_from const-decl "Subgraph(G)" subgraphs_from_walk nil)
    (Walk type-eq-decl nil walks nil)
    (walk? const-decl "bool" walks 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))
   shostak)
  (circuit_subgraph_len_1-1 nil 3251049115
   ("" (skosimp*)
    (("" (expand "circuit?")
      (("" (expand "cyclically_reduced?")
        (("" (expand "pre_circuit?")
          (("" (flatten)
            (("" (typepred "w!1")
              (("" (expand "walk?")
                (("" (flatten)
                  ((""
                    (case "subset?(add[T](finseq_appl(w!1)(0), singleton[T](finseq_appl(w!1)(1))),vert(G_from(G!1, w!1)))")
                    (("1" (lemma "card_subset[T]")
                      (("1" (inst?)
                        (("1" (assert)
                          (("1"
                            (case-replace
                             "card(add[T](finseq_appl(w!1)(0), singleton[T](finseq_appl(w!1)(1)))) = 2")
                            (("1" (assertnil nil)
                             ("2" (hide -1 -2 -3 -4 -5 -6 -7 -8 2 3)
                              (("2"
                                (rewrite "card_add")
                                (("2"
                                  (rewrite "card_singleton")
                                  (("2"
                                    (lift-if)
                                    (("2"
                                      (ground)
                                      (("2"
                                        (hide 1)
                                        (("2"
                                          (expand "singleton")
                                          (("2"
                                            (typepred "w!1")
                                            (("2"
                                              (expand "walk?")
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (expand "edge?")
                                                    (("2"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide -1 -2 -3 -5 -6 3)
                      (("2" (grind) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((circuit? const-decl "bool" circuits nil)
    (pre_circuit? const-decl "bool" walks nil)
    (Walk type-eq-decl nil walks nil)
    (walk? const-decl "bool" walks 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)
    (prewalk type-eq-decl nil walks nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (T formal-type-decl nil circuit_deg nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers 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)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (below type-eq-decl nil naturalnumbers nil)
    (verts_of const-decl "finite_set[T]" walks nil)
    (member const-decl "bool" sets nil)
    (card_subset formula-decl nil finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set" finite_sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (card_singleton formula-decl nil finite_sets nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (edge? const-decl "bool" graphs nil)
    (nil application-judgement "finite_set[T]" circuit_deg nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (card_add formula-decl nil finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (subset? const-decl "bool" sets nil)
    (nonempty? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" 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)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (singleton? const-decl "bool" sets nil)
    (singleton const-decl "(singleton?)" sets nil)
    (subgraph? const-decl "bool" subgraphs nil)
    (Subgraph type-eq-decl nil subgraphs nil)
    (G_from const-decl "Subgraph(G)" subgraphs_from_walk nil)
    (cyclically_reduced? const-decl "bool" circuits nil))
   nil)))


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

¤ Dauer der Verarbeitung: 0.84 Sekunden  (vorverarbeitet am  2026-04-29) ¤

*© 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