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


Quellcode-Bibliothek

© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: Syntax.v   Sprache: PVS

Original von: PVS©

(results_commutation
 (Local_Comu_and_Noeth 0
  (Local_Comu_and_Noeth-1 nil 3374068475
   ("" (skeep)
    (("" (lemma "noetherian_induction")
      (("" (inst? -1 ("R" "union(R1, R2)"))
        (("1"
          (inst -1
           "(LAMBDA (a: T): (FORALL (b, c: T): RTC(R1)(a, b) AND RTC(R2)(a, c) IMPLIES (EXISTS (d: T): RTC(R2)(b, d) AND RTC(R1)(c, d))))")
          (("1" (split)
            (("1" (expand "commute?")
              (("1" (skeep)
                (("1" (inst -1 "x")
                  (("1" (inst -1 "y" "z") (("1" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (skeep)
                (("2" (skeep)
                  (("2" (expand "RTC" (-2 -3))
                    (("2" (expand "IUnion" (-2 -3))
                      (("2" (skolem * "i")
                        (("2" (skolem * "j")
                          (("2" (case-replace "i = 0" :hide? t)
                            (("1" (hide-all-but (-2 -3 1))
                              (("1"
                                (inst 1 "c")
                                (("1"
                                  (expand"RTC" "IUnion")
                                  (("1"
                                    (split)
                                    (("1"
                                      (expand "iterate" -1)
                                      (("1"
                                        (replaces -1)
                                        (("1" (inst 1 "j"nil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (inst 1 "0")
                                      (("2"
                                        (expand "iterate" 1)
                                        (("2" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (case-replace "j = 0" :hide? t)
                              (("1"
                                (hide-all-but (-2 -3 2))
                                (("1"
                                  (inst 1 "b")
                                  (("1"
                                    (expand"RTC" "IUnion")
                                    (("1"
                                      (split)
                                      (("1"
                                        (inst 1 "0")
                                        (("1"
                                          (expand "iterate" 1)
                                          (("1" (propax) nil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "iterate" -2)
                                        (("2"
                                          (replaces -2)
                                          (("2" (inst 1 "i"nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (lemma iterate_add_one)
                                (("2"
                                  (copy -1)
                                  (("2"
                                    (inst? -1 ("R" "R1" "n" "i - 1"))
                                    (("1"
                                      (inst? -2 ("R" "R2" "n" "j - 1"))
                                      (("1"
                                        (decompose-equality)
                                        (("1"
                                          (decompose-equality)
                                          (("1"
                                            (inst -2 "(x, b)")
                                            (("1"
                                              (inst -1 "(x, c)")
                                              (("1"
                                                (replaces -1)
                                                (("1"
                                                  (replaces -1)
                                                  (("1"
                                                    (expand "o")
                                                    (("1"
                                                      (skolem * "x1")
                                                      (("1"
                                                        (skolem * "x2")
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (lemma
                                                             "iterate_RTC")
                                                            (("1"
                                                              (copy -1)
                                                              (("1"
                                                                (inst
                                                                 -1
                                                                 "R1"
                                                                 "i - 1")
                                                                (("1"
                                                                  (inst
                                                                   -2
                                                                   "R2"
                                                                   "j - 1")
                                                                  (("1"
                                                                    (expand*
                                                                     "subset?"
                                                                     "member")
                                                                    (("1"
                                                                      (inst
                                                                       -1
                                                                       "(x1, b)")
                                                                      (("1"
                                                                        (inst
                                                                         -2
                                                                         "(x2, c)")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "locally_commute?")
                                                                            (("1"
                                                                              (inst
                                                                               -8
                                                                               "x"
                                                                               "x1"
                                                                               "x2")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (skolem
                                                                                   *
                                                                                   "u")
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (hide
                                                                                       (-5
                                                                                        -7))
                                                                                      (("1"
                                                                                        (copy
                                                                                         -3)
                                                                                        (("1"
                                                                                          (inst
                                                                                           -4
                                                                                           "x1")
                                                                                          (("1"
                                                                                            (split)
                                                                                            (("1"
                                                                                              (inst
                                                                                               -1
                                                                                               "b"
                                                                                               "u")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (skolem
                                                                                                   *
                                                                                                   "v")
                                                                                                  (("1"
                                                                                                    (flatten)
                                                                                                    (("1"
                                                                                                      (typepred
                                                                                                       "RTC(R1)")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "reflexive_transitive?")
                                                                                                        (("1"
                                                                                                          (flatten)
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "transitive?")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -1
                                                                                                                 "x2"
                                                                                                                 "u"
                                                                                                                 "v")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (hide
                                                                                                                     (-10
                                                                                                                      -3))
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -3
                                                                                                                       "x2")
                                                                                                                      (("1"
                                                                                                                        (split)
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           -1
                                                                                                                           "v"
                                                                                                                           "c")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (hide-all-but
                                                                                                                               (-1
                                                                                                                                -3
                                                                                                                                3))
                                                                                                                              (("1"
                                                                                                                                (skolem
                                                                                                                                 *
                                                                                                                                 "w")
                                                                                                                                (("1"
                                                                                                                                  (flatten)
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     1
                                                                                                                                     "w")
                                                                                                                                    (("1"
                                                                                                                                      (typepred
                                                                                                                                       "RTC(R2)")
                                                                                                                                      (("1"
                                                                                                                                        (expand
                                                                                                                                         "reflexive_transitive?")
                                                                                                                                        (("1"
                                                                                                                                          (flatten)
                                                                                                                                          (("1"
                                                                                                                                            (hide
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (expand
                                                                                                                                               "transitive?")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -1
                                                                                                                                                 "b"
                                                                                                                                                 "v"
                                                                                                                                                 "w")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (hide-all-but
                                                                                                                           (-6
                                                                                                                            1))
                                                                                                                          (("2"
                                                                                                                            (case
                                                                                                                             "subset?(R2, union(R1, R2))")
                                                                                                                            (("1"
                                                                                                                              (lemma
                                                                                                                               "R_subset_TC")
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 -1
                                                                                                                                 "union(R1, R2)")
                                                                                                                                (("1"
                                                                                                                                  (expand*
                                                                                                                                   "subset?"
                                                                                                                                   "member")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -1
                                                                                                                                     "(x, x2)")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -1
                                                                                                                                         "(x, x2)")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (hide-all-but
                                                                                                                               1)
                                                                                                                              (("2"
                                                                                                                                (expand*
                                                                                                                                 "subset?"
                                                                                                                                 "member")
                                                                                                                                (("2"
                                                                                                                                  (skolem
                                                                                                                                   *
                                                                                                                                   "a")
                                                                                                                                  (("2"
                                                                                                                                    (flatten)
                                                                                                                                    (("2"
                                                                                                                                      (expand*
                                                                                                                                       "union"
                                                                                                                                       "member")
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide-all-but
                                                                                               (-4
                                                                                                1))
                                                                                              (("2"
                                                                                                (case
                                                                                                 "subset?(R1, union(R1, R2))")
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "R_subset_TC")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -1
                                                                                                     "union(R1, R2)")
                                                                                                    (("1"
                                                                                                      (expand*
                                                                                                       "subset?"
                                                                                                       "member")
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -1
                                                                                                         "(x, x1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -1
                                                                                                             "(x, x1)")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide-all-but
                                                                                                   1)
                                                                                                  (("2"
                                                                                                    (expand*
                                                                                                     "subset?"
                                                                                                     "member")
                                                                                                    (("2"
                                                                                                      (skolem
                                                                                                       *
                                                                                                       "a")
                                                                                                      (("2"
                                                                                                        (flatten)
                                                                                                        (("2"
                                                                                                          (expand*
                                                                                                           "union"
                                                                                                           "member")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide-all-but
                                                                     (1
                                                                      2))
                                                                    (("2"
                                                                      (typepred
                                                                       "j")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide-all-but
                                                                   (1
                                                                    3))
                                                                  (("2"
                                                                    (typepred
                                                                     "i")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide-all-but (1 2))
                                        (("2"
                                          (typepred "j")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil)
                                       ("3"
                                        (hide-all-but (1 2))
                                        (("3"
                                          (typepred "j")
                                          (("3" (assertnil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but (1 3))
                                      (("2"
                                        (typepred "i")
                                        (("2" (assertnil nil))
                                        nil))
                                      nil)
                                     ("3"
                                      (hide-all-but (1 3))
                                      (("3"
                                        (typepred "i")
                                        (("3" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (propax) nil nil))
        nil))
      nil))
    nil)
   ((T formal-type-decl nil results_commutation nil)
    (noetherian_induction formula-decl nil noetherian nil)
    (RTC const-decl "reflexive_transitive" relations_closure nil)
    (reflexive_transitive type-eq-decl nil relations_closure nil)
    (reflexive_transitive? const-decl "bool" relations_closure nil)
    (pred type-eq-decl nil defined_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (IUnion const-decl "set[T]" indexed_sets nil)
    (j skolem-const-decl "nat" results_commutation nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (transitive? const-decl "bool" relations nil)
    (R_subset_TC formula-decl nil relations_closure nil)
    (locally_commute? const-decl "bool" ars_terminology nil)
    (subset? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (iterate_RTC formula-decl nil relations_closure nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (O const-decl "bool" relation_props nil)
    (i skolem-const-decl "nat" results_commutation nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iterate_add_one formula-decl nil relation_iterate "orders/")
    (iterate def-decl "pred[[T, T]]" relation_iterate "orders/")
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (commute? const-decl "bool" ars_terminology nil)
    (noetherian type-eq-decl nil noetherian nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (PRED type-eq-decl nil defined_types nil)
    (noetherian? const-decl "bool" noetherian nil)
    (set type-eq-decl nil sets nil) (union const-decl "set" sets nil)
    (R1 skolem-const-decl "PRED[[T, T]]" results_commutation nil)
    (R2 skolem-const-decl "PRED[[T, T]]" results_commutation nil))
   shostak))
 (commute_and_iterate_one 0
  (commute_and_iterate_one-1 nil 3374066489
   ("" (induct "n")
    (("1" (skeep)
      (("1" (inst 1 "z")
        (("1" (split)
          (("1" (expand"RTC" "IUnion")
            (("1" (inst 1 "0")
              (("1" (expand "iterate") (("1" (propax) nil nil)) nil))
              nil))
            nil)
           ("2" (expand "iterate")
            (("2" (expand"RC" "union" "member")
              (("2" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skeep)
      (("2" (skeep)
        (("2" (rewrite "iterate_add")
          (("2" (expand "o")
            (("2" (skolem * "y1")
              (("2" (flatten)
                (("2" (rewrite "iterate_1")
                  (("2" (inst -1 "R1" "R2" "x" "y1" "z")
                    (("2" (assert)
                      (("2" (skolem * "z1")
                        (("2" (flatten)
                          (("2" (hide -4)
                            (("2" (expand "RC" -2)
                              (("2"
                                (expand"union" "member")
                                (("2"
                                  (split)
                                  (("1"
                                    (expand "strong_commute?")
                                    (("1"
                                      (inst -3 "y1" "y" "z1")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (skolem * "z2")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (inst 1 "z2")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (hide-all-but
                                                   (-2 -4 1))
                                                  (("1"
                                                    (typepred
                                                     "RTC(R1)")
                                                    (("1"
                                                      (expand
                                                       "reflexive_transitive?")
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (expand
                                                             "transitive?")
                                                            (("1"
                                                              (inst
                                                               -1
                                                               "z"
                                                               "z1"
                                                               "z2")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (inst 1 "y")
                                    (("2"
                                      (split)
                                      (("1"
                                        (replaces -1)
                                        (("1"
                                          (hide (-2 -4))
                                          (("1"
                                            (lemma "R_subset_RTC")
                                            (("1"
                                              (inst?)
                                              (("1"
                                                (expand*
                                                 "subset?"
                                                 "member")
                                                (("1"
                                                  (inst -1 "(z1, y)")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (hide -3)
                                                      (("1"
                                                        (typepred
                                                         "RTC(R1)")
                                                        (("1"
                                                          (expand
                                                           "reflexive_transitive?")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (hide -1)
                                                              (("1"
                                                                (expand
                                                                 "transitive?")
                                                                (("1"
                                                                  (inst
                                                                   -1
                                                                   "z"
                                                                   "z1"
                                                                   "y")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide-all-but 1)
                                        (("2"
                                          (expand*
                                           "RC"
                                           "union"
                                           "member")
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iterate_add formula-decl nil relation_iterate "orders/")
    (iterate_1 formula-decl nil relation_iterate "orders/")
    (transitive? const-decl "bool" relations nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (subset? const-decl "bool" sets nil)
    (R_subset_RTC formula-decl nil relations_closure nil)
    (O const-decl "bool" relation_props nil)
    (IUnion const-decl "set[T]" indexed_sets nil)
    (union const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (RC const-decl "reflexive" relations_closure nil)
    (reflexive type-eq-decl nil relations_closure nil)
    (reflexive? const-decl "bool" relations nil)
    (RTC const-decl "reflexive_transitive" relations_closure nil)
    (reflexive_transitive type-eq-decl nil relations_closure nil)
    (reflexive_transitive? const-decl "bool" relations_closure nil)
    (iterate def-decl "pred[[T, T]]" relation_iterate "orders/")
    (strong_commute? const-decl "bool" ars_terminology nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (PRED type-eq-decl nil defined_types nil)
    (T formal-type-decl nil results_commutation nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (commute_and_iterate_two 0
  (commute_and_iterate_two-1 nil 3374066577
   ("" (induct "m")
    (("1" (skeep)
      (("1" (inst 1 "y")
        (("1" (split)
          (("1" (expand"RTC" "IUnion")
            (("1" (inst 1 "0")
              (("1" (expand "iterate") (("1" (propax) nil nil)) nil))
              nil))
            nil)
           ("2" (expand "iterate" -3)
            (("2" (expand"RTC" "IUnion")
              (("2" (inst 1 "n") (("2" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skeep)
      (("2" (skeep)
        (("2" (rewrite "iterate_add")
          (("2" (expand "o")
            (("2" (skolem * "z1")
              (("2" (flatten)
                (("2" (inst -1 "R1" "R2" "x" "y" "z1" "n")
                  (("2" (assert)
                    (("2" (skolem * "r1")
                      (("2" (flatten)
                        (("2" (rewrite "iterate_1")
                          (("2" (expand "RTC" -2)
                            (("2" (expand "IUnion" -2)
                              (("2"
                                (skolem * "i")
                                (("2"
                                  (lemma "commute_and_iterate_one")
                                  (("2"
                                    (inst
                                     -1
                                     "R1"
                                     "R2"
                                     "z1"
                                     "r1"
                                     "z"
                                     "i")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (skolem * "r2")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst 1 "r2")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide-all-but
                                                 (-2 -3 1))
                                                (("2"
                                                  (case
                                                   "subset?(RC(R2), RTC(R2))")
                                                  (("1"
                                                    (expand*
                                                     "subset?"
                                                     "member")
                                                    (("1"
                                                      (inst
                                                       -1
                                                       "(r1, r2)")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (typepred
                                                           "RTC(R2)")
                                                          (("1"
                                                            (expand
                                                             "reflexive_transitive?")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (hide
                                                                 (-1
                                                                  -3))
                                                                (("1"
                                                                  (expand
                                                                   "transitive?")
                                                                  (("1"
                                                                    (inst
                                                                     -1
                                                                     "y"
--> --------------------

--> maximum size reached

--> --------------------

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.123Angebot  Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können  ¤





Druckansicht
unsichere Verbindung
Druckansicht
Hier finden Sie eine Liste der Produkte des Unternehmens

Mittel




Lebenszyklus

Die hierunter aufgelisteten Ziele sind für diese Firma wichtig


Ziele

Entwicklung einer Software für die statische Quellcodeanalyse


Bot Zugriff



                                                                                                                                                                                                                                                                                                                                                                                                     


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