products/Sources/formale Sprachen/PVS/analysis/  image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: arrays_examples.prf   Sprache: Lisp

Original von: PVS©
(bounded_variation
 (IMP_rs_partition_TCC1 0
  (IMP_rs_partition_TCC1-2 nil 3511196898
   ("" (lemma "connected_domain") (("" (propax) nil nil)) nil)
   ((connected_domain formula-decl nil bounded_variation nil)) nil)
  (IMP_rs_partition_TCC1-1 nil 3511191467 ("" (assuming-tcc) nil nil)
   nil nil))
 (IMP_rs_partition_TCC2 0
  (IMP_rs_partition_TCC2-1 nil 3511191467
   ("" (lemma "not_one_element") (("" (propax) nil nil)) nil)
   ((not_one_element formula-decl nil bounded_variation nil)) nil))
 (variation_on_TCC1 0
  (variation_on_TCC1-1 nil 3491555814 ("" (subtype-tcc) nil nil) nil
   nil))
 (variation_on_TCC2 0
  (variation_on_TCC2-1 nil 3491555814 ("" (subtype-tcc) nil nil) nil
   nil))
 (variation_on_TCC3 0
  (variation_on_TCC3-1 nil 3491555814 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" bounded_variation nil)
    (T formal-nonempty-subtype-decl nil bounded_variation nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (restrict const-decl "R" restrict nil)
    (<= const-decl "bool" reals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (partition type-eq-decl nil rs_partition nil)
    (integer nonempty-type-from-decl nil integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (variation_on_strictly_sort_TCC1 0
  (variation_on_strictly_sort_TCC1-1 nil 3493026057
   ("" (lemma "partition_strictly_sort")
    (("" (beta) (("" (propax) nil nil)) nil)) nil)
   ((partition_strictly_sort formula-decl nil rs_partition nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" bounded_variation nil)
    (T formal-nonempty-subtype-decl nil bounded_variation nil))
   nil))
 (variation_on_strictly_sort 0
  (variation_on_strictly_sort-2 nil 3493039771
   ("" (skeep)
    (("" (skeep)
      (("" (lemma "partition_union_is_strictly_sort")
        (("" (inst - "a" "b")
          (("" (assert)
            (("" (inst - "P")
              ((""
                (case "FORALL (ff:[T->real]): variation_on(a, b, P)(ff) = variation_on(a, b, strictly_sort(P))(ff)")
                (("1" (decompose-equality +) nil nil)
                 ("2" (hide 2)
                  (("2" (skeep)
                    (("2" (name "ssm" "strictly_sort_map(P)")
                      (("2" (label "ssmname" -1)
                        (("2" (label "ssunion" -2)
                          (("2" (label "altb" -3)
                            (("2" (name "SSP" "strictly_sort(P)")
                              (("2"
                                (replace -1)
                                (("2"
                                  (label "SSPname" -1)
                                  (("2"
                                    (expand "variation_on")
                                    (("2"
                                      (case
                                       "FORALL (nn:below(SSP`length-1)): sigma[below(P`length - 1)]
                                              (0, ssm(nn),
                                               LAMBDA (n: below(P`length - 1)):
                                                 abs(ff(P`seq(1 + n)) - ff(P`seq(n))))
                                           =
                                           sigma[below(SSP`length - 1)]
                                               (0, nn,
                                                LAMBDA (n: below(SSP`length - 1)):
                                                  abs(ff(SSP`seq(1 + n)) - ff(SSP`seq(n))))")
                                      (("1"
                                        (inst - "SSP`length-2")
                                        (("1"
                                          (lemma
                                           "sigma_split[below(P`length-1)]")
                                          (("1"
                                            (inst
                                             -
                                             "LAMBDA (n: below(P`length - 1)):
                                                     abs(ff(P`seq(1 + n)) - ff(P`seq(n)))"
                                             "P`length-2"
                                             "0"
                                             "ssm(SSP`length - 2)")
                                            (("1"
                                              (case
                                               "sigma(ssm(SSP`length - 2) + 1, P`length - 2,
                                                                                   LAMBDA (n: below(P`length - 1)):
                                                                                     abs(ff(P`seq(1 + n)) - ff(P`seq(n)))) = 0")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "ssm(SSP`length-2) = P`length-1")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (lemma
                                                       "strictly_sort_map_increasing")
                                                      (("1"
                                                        (inst - "P")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "SSP`length-2"
                                                             "SSP`length-1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (replace
                                                                 "ssmname")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (case
                                                   "SSP`length >= 2")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (expand "SSP")
                                                      (("2"
                                                        (lemma
                                                         "partition_strictly_sort")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "a"
                                                           "b")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "P")
                                                              (("2"
                                                                (ground)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (rewrite
                                                   "sigma_restrict_eq_0")
                                                  (("1"
                                                    (hide 2)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (skosimp*)
                                                          (("1"
                                                            (typepred
                                                             "i!1")
                                                            (("1"
                                                              (typepred
                                                               "ssm")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "SSP`length-2")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (lemma
                                                                         "partition_strictly_sort")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "a"
                                                                           "b")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "P")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (typepred
                                                                                     "P")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "increasing?")
                                                                                      (("1"
                                                                                        (inst-cp
                                                                                         -
                                                                                         "i!1"
                                                                                         "1+i!1")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "1 + ssm(SSP`length - 2)"
                                                                                             "i!1")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (inst-cp
                                                                                                 -
                                                                                                 "i!1+1")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "i!1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (flatten)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "abs")
                                                                                                          (("1"
                                                                                                            (lift-if)
                                                                                                            (("1"
                                                                                                              (ground)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (case
                                                       "strictly_sort(P)`length >= 2")
                                                      (("1"
                                                        (expand "SSP")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (lemma
                                                           "partition_strictly_sort")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "a"
                                                             "b")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "P")
                                                                (("2"
                                                                  (ground)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (assert)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst + "0")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide-all-but 1)
                                                  (("2"
                                                    (case
                                                     "strictly_sort(P)`length>=2")
                                                    (("1"
                                                      (expand "SSP")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (lemma
                                                         "partition_strictly_sort")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "a"
                                                           "b")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "P")
                                                              (("2"
                                                                (ground)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("4"
                                                (hide-all-but 1)
                                                (("4"
                                                  (expand "SSP")
                                                  (("4"
                                                    (lemma
                                                     "partition_strictly_sort")
                                                    (("4"
                                                      (inst - "a" "b")
                                                      (("4"
                                                        (assert)
                                                        (("4"
                                                          (inst - "P")
                                                          (("4"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide-all-but 1)
                                              (("2"
                                                (expand "SSP")
                                                (("2"
                                                  (lemma
                                                   "partition_strictly_sort")
                                                  (("2"
                                                    (inst - "a" "b")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (inst - "P")
                                                        (("2"
                                                          (ground)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide-all-but 1)
                                          (("2"
                                            (expand "SSP")
                                            (("2"
                                              (lemma
                                               "partition_strictly_sort")
                                              (("2"
                                                (inst - "a" "b")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (inst - "P")
                                                    (("2"
                                                      (ground)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide 2)
                                        (("2"
                                          (induct "nn")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (expand "sigma" +)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (case
                                                       "sigma(0, ssm(0) - 1,
                                                                         LAMBDA (n: below(P`length - 1)):
                                                                           abs(ff(P`seq(1 + n)) - ff(P`seq(n)))) = 0")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (typepred
                                                           "ssm")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "0")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (flatten)
                                                                  (("1"
                                                                    (replace
                                                                     "SSPname")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (rewrite
                                                           "sigma_restrict_eq_0")
                                                          (("2"
                                                            (hide 2)
                                                            (("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (typepred
                                                                 "i!1")
                                                                (("2"
                                                                  (case
                                                                   "P`seq(1+i!1) = a")
                                                                  (("1"
                                                                    (typepred
                                                                     "P")
                                                                    (("1"
                                                                      (expand
                                                                       "increasing?")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "i!1"
                                                                         "1+i!1")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "i!1")
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (expand
                                                                                   "abs")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (typepred
                                                                       "ssm")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "0")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (replace
                                                                               "SSPname")
                                                                              (("2"
                                                                                (typepred
                                                                                 "P")
                                                                                (("2"
                                                                                  (expand
                                                                                   "increasing?")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "i!1+1"
                                                                                     "ssm(0)")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "1+i!1")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (hide 2)
                                                        (("3"
                                                          (skosimp*)
                                                          (("3"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide-all-but 1)
                                                  (("2"
                                                    (case
                                                     "strictly_sort(P)`length>=2")
                                                    (("1"
                                                      (expand "SSP")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (lemma
                                                         "partition_strictly_sort")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "a"
                                                           "b")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "P")
                                                              (("2"
                                                                (ground)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skolem 1 "mm")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (expand "sigma" +)
                                                  (("2"
                                                    (lift-if)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (typepred
                                                         "ssm(1+mm)")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (replace
                                                             -3
                                                             :dir
                                                             rl)
                                                            (("2"
                                                              (lemma
                                                               "sigma_split[below(P`length-1)]")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "LAMBDA (n: below(P`length - 1)):
                                                       abs(ff(P`seq(1 + n)) - ff(P`seq(n)))"
                                                                 "ssm(1+mm)-1"
                                                                 "0"
                                                                 "ssm(mm)")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case
                                                                     "ssm(mm)<=ssm(1+mm)-1")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (case
                                                                           "ff(P`seq(1 + ssm(1 + mm))) - ff(P`seq(ssm(1 + mm))) = ff(SSP`seq(2 + mm)) - ff(SSP`seq(1 + mm))")
                                                                          (("1"
                                                                            (case
                                                                             "sigma(1 + ssm(mm), ssm(1 + mm) - 1,
                                                                                          LAMBDA (n: below(P`length - 1)):
                                                                                            abs(ff(P`seq(1 + n)) - ff(P`seq(n)))) = 0")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (hide
                                                                                 -2)
                                                                                (("2"
                                                                                  (hide
                                                                                   -4)
                                                                                  (("2"
                                                                                    (rewrite
                                                                                     "sigma_restrict_eq_0")
                                                                                    (("2"
                                                                                      (hide
                                                                                       2)
                                                                                      (("2"
                                                                                        (skosimp*)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           "i!1")
                                                                                          (("2"
                                                                                            (case
                                                                                             "P`seq(i!1) = P`seq(1+i!1)")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "abs"
                                                                                               +)
                                                                                              (("1"
                                                                                                (lift-if)
                                                                                                (("1"
                                                                                                  (ground)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide
                                                                                               2)
                                                                                              (("2"
                                                                                                (lemma
                                                                                                 "strictly_sort_map_between")
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "P")
                                                                                                  (("2"
                                                                                                    (replace
                                                                                                     "SSPname")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         "ssmname")
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "mm")
                                                                                                          (("2"
                                                                                                            (inst-cp
                                                                                                             -
                                                                                                             "i!1")
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "i!1+1")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (case
                                                                               "P`seq(1+ssm(1+mm)) = SSP`seq(2+mm)")
                                                                              (("1"
                                                                                (typepred
                                                                                 "ssm")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "1+mm")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (hide
                                                                                   -1)
                                                                                  (("2"
                                                                                    (hide
                                                                                     -3)
                                                                                    (("2"
                                                                                      (typepred
                                                                                       "ssm")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "1+mm")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.93 Sekunden  (vorverarbeitet)  ¤



Druckansicht
unsichere Verbindung
Druckansicht
sprechenden Kalenders

Eigene Datei ansehen




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 ist noch experimentell.


Bot Zugriff