products/sources/formale sprachen/PVS/lebesgue image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: fundamental_algebra.prf   Sprache: Lisp

Original von: PVS©

(real_lebesgue_scaf
 (limit_TCC1 0
  (limit_TCC1-1 nil 3396062613
   ("" (skosimp*)
    (("" (expand "convergent")
      (("" (expand "convergent?")
        (("" (expand "convergence")
          (("" (split)
            (("1" (skosimp*)
              (("1" (inst + "l!1")
                (("1" (rewrite "metric_convergence_def" *)
                  (("1" (expand "metric_converges_to")
                    (("1" (skosimp)
                      (("1" (inst - "r!1")
                        (("1" (skosimp)
                          (("1" (inst + "n!1")
                            (("1" (skosimp)
                              (("1"
                                (inst - "i!1")
                                (("1"
                                  (expand "ball")
                                  (("1" (grind) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (skosimp*)
              (("2" (inst + "l!1")
                (("2" (skosimp)
                  (("2" (rewrite "metric_convergence_def" *)
                    (("2" (expand "metric_converges_to")
                      (("2" (inst - "epsilon!1")
                        (("2" (skosimp)
                          (("2" (inst + "n!1")
                            (("2" (skosimp)
                              (("2"
                                (inst - "i!1")
                                (("2"
                                  (expand "ball")
                                  (("2" (grind) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((convergent? const-decl "bool" topological_convergence "topology/")
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (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)
    (metric_converges_to const-decl "bool" metric_space_def
     "metric_space/")
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (member const-decl "bool" sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ball const-decl "set[T]" metric_space_def "metric_space/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (sequence type-eq-decl nil sequences nil)
    (nat nonempty-type-eq-decl nil naturalnumbers 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)
    (metric_convergence_def formula-decl nil metric_space
     "metric_space/")
    (convergence const-decl "bool" convergence_sequences "analysis/")
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil))
 (lebesgue_outer_measure_TCC1 0
  (lebesgue_outer_measure_TCC1-1 nil 3397030001
   ("" (skosimp)
    (("" (skolem + ("n!1"))
      (("" (typepred "I!1(n!1)")
        (("" (expand "bounded_open_interval?")
          (("" (expand "bounded_interval?") (("" (flatten) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bounded_interval? const-decl "bool" real_topology "metric_space/")
    (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)
    (set type-eq-decl nil sets nil)
    (bounded_open_interval? const-decl "bool" real_topology
     "metric_space/")
    (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)
    (bounded_open_interval nonempty-type-eq-decl nil real_topology
     "metric_space/")
    (sequence type-eq-decl nil sequences nil))
   nil))
 (lebesgue_outer_measure_TCC2 0
  (lebesgue_outer_measure_TCC2-1 nil 3407841244
   (""
    (name-replace "L" "(LAMBDA A:
             x_inf({z |
                      EXISTS I:
                        x_le(x_sum(o[nat, interval, extended_nnreal]
                                       (x_length, I)),
                             z)
                         AND subset?[real](A, IUnion[nat, real](I))}))")
    (("1" (expand "outer_measure?")
      (("1" (case-replace "om_empty?(L)")
        (("1" (case-replace "om_increasing?(L)")
          (("1" (expand "om_countably_subadditive?")
            (("1" (skosimp)
              (("1" (expand "x_le")
                (("1" (flatten)
                  (("1" (assert)
                    (("1" (case "forall (n:nat): L(X!1(n))`1")
                      (("1"
                        (case "forall (n:nat,r:posreal): exists I: subset?[real](X!1(n),IUnion[nat,real](I)) & x_lt(x_sum(LAMBDA (n: nat):x_length(I(n))),x_add((TRUE,r/2^n),L(X!1(n))))")
                        (("1"
                          (case "forall (r:posreal): EXISTS I:
          subset?[real](IUnion(X!1), IUnion[nat, real](I)) &
           x_lt(L(IUnion(X!1)),
                x_add((TRUE, r),x_sum(L o X!1)))")
                          (("1" (hide -2)
                            (("1" (inst-cp - "1")
                              (("1"
                                (skosimp)
                                (("1"
                                  (expand "x_add" -3)
                                  (("1"
                                    (expand "x_lt" -3)
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case
                                           "x_sum(L o X!1)`2)
                                          (("1"
                                            (hide -3 -5 1)
                                            (("1"
                                              (inst
                                               -
                                               "L(IUnion(X!1))`2-x_sum(L o X!1)`2")
                                              (("1"
                                                (skosimp)
                                                (("1"
                                                  (expand "x_add")
                                                  (("1"
                                                    (expand "x_lt")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 2)
                            (("2" (skosimp)
                              (("2"
                                (case
                                 "EXISTS I:
        subset?[real](IUnion(X!1), IUnion[nat, real](I)) &
         x_lt(L(IUnion(X!1)),x_sum(LAMBDA n: x_add((TRUE, (r!1/2) / 2 ^ n), L(X!1(n)))))")
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (inst + "I!1")
                                    (("1"
                                      (hide -3)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case
                                           "x_eq(x_sum(LAMBDA n: x_add((TRUE, (r!1 / 2) / 2 ^ n), L(X!1(n)))),x_add((TRUE, r!1), x_sum(L o X!1)))")
                                          (("1"
                                            (name-replace
                                             "LHS"
                                             "L(IUnion(X!1))")
                                            (("1"
                                              (name-replace
                                               "MID"
                                               "x_sum(LAMBDA n: x_add((TRUE, (r!1 / 2) / 2 ^ n), L(X!1(n))))")
                                              (("1"
                                                (name-replace
                                                 "RHS"
                                                 "x_add((TRUE, r!1), x_sum(L o X!1))")
                                                (("1"
                                                  (hide-all-but
                                                   (-1 -3 1))
                                                  (("1"
                                                    (expand "x_lt")
                                                    (("1"
                                                      (expand "x_eq")
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide -1 -2 2)
                                            (("2"
                                              (expand "x_add")
                                              (("2"
                                                (expand "x_eq")
                                                (("2"
                                                  (expand "o ")
                                                  (("2"
                                                    (case-replace
                                                     "x_sum(LAMBDA n:
              IF L(X!1(n))`1 THEN (TRUE, (r!1 / 2) / 2 ^ n + L(X!1(n))`2)
              ELSE (FALSE, 0)
              ENDIF)`1")
                                                    (("1"
                                                      (expand "x_sum")
                                                      (("1"
                                                        (prop)
                                                        (("1"
                                                          (replace -3)
                                                          (("1"
                                                            (replace
                                                             -5)
                                                            (("1"
                                                              (replace
                                                               -3)
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (lemma
                                                                   "const_geometric_series"
                                                                   ("x"
                                                                    "1/2"
                                                                    "c"
                                                                    "r!1/2"))
                                                                  (("1"
                                                                    (case-replace
                                                                     "r!1 / 2 / (1 - 1 / 2)=r!1")
                                                                    (("1"
                                                                      (expand
                                                                       "abs"
                                                                       -2)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (expand
                                                                           "convergent?")
                                                                          (("1"
                                                                            (skosimp*)
                                                                            (("1"
                                                                              (lemma
                                                                               "convergence_sequences.limit_def"
                                                                               ("v"
                                                                                "series(LAMBDA (i:nat):
                    IF L(X!1(i))`1 THEN (r!1 / 2) / 2 ^ i + L(X!1(i))`2
                    ELSE 0
                    ENDIF)"
                                                                                "l"
                                                                                "l!2"))
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -1
                                                                                     -4
                                                                                     -7
                                                                                     -8)
                                                                                    (("1"
                                                                                      (lemma
                                                                                       "convergence_sequences.limit_def"
                                                                                       ("v"
                                                                                        "series(LAMBDA (i:nat):
                    L(X!1(i))`2)"
                                                                                        "l"
                                                                                        "l!1"))
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("1"
                                                                                            (hide
                                                                                             -1)
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "cnv_seq_sum"
                                                                                               ("s1"
                                                                                                "series(LAMBDA (i:nat): L(X!1(i))`2)"
                                                                                                "l1"
                                                                                                "l!1"
                                                                                                "s2"
                                                                                                "series(r!1 / 2 * geometric(1 / 2))"
                                                                                                "l2"
                                                                                                "r!1"))
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (rewrite
                                                                                                   "series_sum")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "+"
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (case-replace
                                                                                                       "(LAMBDA (i:nat):
                           IF L(X!1(i))`1
                             THEN (r!1 / 2) / 2 ^ i + L(X!1(i))`2
                           ELSE 0
                           ENDIF)=(LAMBDA (x: nat):
                           (r!1 / 2 * geometric(1 / 2))(x) + L(X!1(x))`2)")
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -1
                                                                                                         -6)
                                                                                                        (("1"
                                                                                                          (lemma
                                                                                                           "convergence_sequences.unique_limit"
                                                                                                           ("u"
                                                                                                            "series(LAMBDA (x: nat):
                           (r!1 / 2 * geometric(1 / 2))(x) + L(X!1(x))`2)"
                                                                                                            "l1"
                                                                                                            "l!2"
                                                                                                            "l2"
                                                                                                            "l!1+r!1"))
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (apply-extensionality
                                                                                                         :hide?
                                                                                                         t)
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -5
                                                                                                           "x!1")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "geometric")
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "*")
                                                                                                                (("2"
                                                                                                                  (rewrite
                                                                                                                   "inv_expt")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (expand
                                                         "x_sum")
                                                        (("2"
                                                          (prop)
                                                          (("1"
                                                            (skosimp)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "i!1")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (lemma
                                                             "geometric_conv"
                                                             ("x"
                                                              "1/2"))
                                                            (("2"
                                                              (expand
                                                               "abs")
                                                              (("2"
                                                                (lemma
                                                                 "series_scal"
                                                                 ("c"
                                                                  "r!1/2"
                                                                  "a"
                                                                  "geometric(1 / 2)"))
                                                                (("2"
                                                                  (lemma
                                                                   "convergent_scal"
                                                                   ("s1"
                                                                    "series(geometric(1 / 2))"
                                                                    "a"
                                                                    "r!1/2"))
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (replace
                                                                       -2)
                                                                      (("2"
                                                                        (hide
                                                                         -2
                                                                         -3)
                                                                        (("2"
                                                                          (lemma
                                                                           "convergent_sum"
                                                                           ("s1"
                                                                            "series(LAMBDA n: r!1 / 2 * geometric(1 / 2)(n))"
                                                                            "s2"
                                                                            "series(LAMBDA n: L(X!1(n))`2)"))
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (hide
                                                                               -2
                                                                               -3)
                                                                              (("2"
                                                                                (rewrite
                                                                                 "series_sum")
                                                                                (("2"
                                                                                  (expand
                                                                                   "+"
                                                                                   -1)
                                                                                  (("2"
                                                                                    (case-replace
                                                                                     "(LAMBDA (x: nat):
                          r!1 / 2 * geometric(1 / 2)(x) + L(X!1(x))`2)=(LAMBDA n:
                          IF L(X!1(n))`1
                            THEN (r!1 / 2) / 2 ^ n + L(X!1(n))`2
                          ELSE 0
                          ENDIF)")
                                                                                    (("2"
                                                                                      (apply-extensionality
                                                                                       :hide?
                                                                                       t)
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "x!1")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "geometric")
                                                                                            (("2"
                                                                                              (rewrite
                                                                                               "inv_expt"
                                                                                               1)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (lemma
                                     "posreal_div_posreal_is_posreal"
                                     ("px" "r!1" "py" "2"))
                                    (("2"
                                      (inst - "_" "r!1/2")
                                      (("2"
                                        (name-replace "R" "r!1/2")
                                        (("2"
                                          (name
                                           "I_n"
                                           "lambda n: choose({I | subset?[real](X!1(n), IUnion[nat, real](I)) &
           x_lt(x_sum(LAMBDA (n: nat): x_length(I(n))),
                x_add((TRUE, R / 2 ^ n), L(X!1(n))))})")
                                          (("1"
                                            (case
                                             "forall n: subset?[real](X!1(n), IUnion[nat, real](I_n(n))) &
           x_lt(x_sum(LAMBDA (m: nat): x_length(I_n(n)(m))),
                x_add((TRUE, R / 2 ^ n), L(X!1(n))))")
                                            (("1"
                                              (lemma
                                               "double_index_n_ij")
                                              (("1"
                                                (lemma
                                                 "double_index_ij_n")
                                                (("1"
                                                  (name-replace
                                                   "NN"
                                                   "double_index_n")
                                                  (("1"
                                                    (name-replace
                                                     "II"
                                                     "double_index_i")
                                                    (("1"
                                                      (name-replace
                                                       "JJ"
                                                       "double_index_j")
                                                      (("1"
                                                        (inst
                                                         +
                                                         "lambda (n:nat): I_n(II(n))(JJ(n))")
                                                        (("1"
                                                          (case-replace
                                                           "subset?[real]
          (IUnion(X!1),
           IUnion[nat, real](LAMBDA (n: nat): I_n(II(n))(JJ(n))))")
                                                          (("1"
                                                            (hide -5)
                                                            (("1"
                                                              (case
                                                               "x_lt(x_sum(LAMBDA n:x_sum(LAMBDA (m: nat): x_length(I_n(n)(m)))),x_sum(LAMBDA n: x_add((TRUE, R/2^n), L(X!1(n)))))")
                                                              (("1"
                                                                (case
                                                                 "x_le(L(IUnion(X!1)),x_sum(LAMBDA n: x_sum(LAMBDA (m: nat): x_length(I_n(n)(m)))))")
                                                                (("1"
                                                                  (name-replace
                                                                   "LHS"
                                                                   "L(IUnion(X!1))")
                                                                  (("1"
                                                                    (name-replace
                                                                     "RHS"
                                                                     "x_sum(LAMBDA n: x_add((TRUE, R / 2 ^ n), L(X!1(n))))")
                                                                    (("1"
                                                                      (name-replace
                                                                       "MID"
                                                                       "x_sum(LAMBDA n: x_sum(LAMBDA (m: nat): x_length(I_n(n)(m))))")
                                                                      (("1"
                                                                        (hide-all-but
                                                                         (-1
                                                                          -2
                                                                          1))
                                                                        (("1"
                                                                          (expand
                                                                           "x_le")
                                                                          (("1"
                                                                            (expand
                                                                             "x_lt")
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   -1
                                                                   2)
                                                                  (("2"
                                                                    (lemma
                                                                     "double_x_sum"
                                                                     ("U"
                                                                      "lambda (i,j:nat): x_length(I_n(i)(j))"))
                                                                    (("2"
                                                                      (case
                                                                       "x_le(L(IUnion(X!1)),x_sum(single_index(LAMBDA (i, j: nat): x_length(I_n(i)(j)))))")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (name-replace
                                                                           "LHS"
                                                                           "L(IUnion(X!1))")
                                                                          (("1"
                                                                            (name-replace
                                                                             "RHS"
                                                                             "x_sum(LAMBDA n: x_sum(LAMBDA (m: nat): x_length(I_n(n)(m))))")
                                                                            (("1"
                                                                              (name-replace
                                                                               "MID"
                                                                               "x_sum(single_index(LAMBDA (i, j: nat): x_length(I_n(i)(j))))")
                                                                              (("1"
                                                                                (hide-all-but
                                                                                 (-1
                                                                                  -2
                                                                                  1))
                                                                                (("1"
                                                                                  (expand
                                                                                   "x_eq")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "x_le")
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         -1
                                                                         2)
                                                                        (("2"
                                                                          (case
                                                                           "forall A,I: subset?(A,IUnion(I)) => x_le(L(A),x_sum(x_length o I))")
                                                                          (("1"
                                                                            (expand
                                                                             "single_index")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "IUnion(X!1)"
                                                                               "lambda n: I_n(II(n))(JJ(n))")
                                                                              (("1"
                                                                                (replace
                                                                                 -2)
                                                                                (("1"
                                                                                  (expand
                                                                                   "o"
                                                                                   -1)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "JJ")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "II")
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (skosimp)
                                                                              (("2"
                                                                                (expand
                                                                                 "x_le")
                                                                                (("2"
                                                                                  (expand
                                                                                   "o ")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "L")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "o ")
                                                                                      (("2"
                                                                                        (case-replace
                                                                                         "x_sum(LAMBDA (x: nat): x_length(I!1(x)))`1")
                                                                                        (("1"
                                                                                          (case-replace
                                                                                           "x_inf({z |
                EXISTS I:
                  x_le(x_sum(LAMBDA (x: nat): x_length(I(x))), z) AND
                   subset?[real](A!1, IUnion[nat, real](I))})`1")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "x_inf")
                                                                                            (("1"
                                                                                              (case-replace
                                                                                               "FORALL (x_1:
                   ({z |
                       EXISTS I:
                         x_le(x_sum(LAMBDA (x: nat): x_length(I(x))), z)
                          AND subset?[real](A!1, IUnion[nat, real](I))})):
           NOT x_1`1")
                                                                                              (("1"
                                                                                                (replace
                                                                                                 1
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (skosimp)
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     -2)
                                                                                                    (("1"
                                                                                                      (typepred
                                                                                                       "x!1")
                                                                                                      (("1"
                                                                                                        (skosimp)
                                                                                                        (("1"
                                                                                                          (typepred
                                                                                                           "glb({z_1: real |
             EXISTS (x_1: extended_nnreal):
               (EXISTS I:
                  x_le(x_sum(LAMBDA (x: nat): x_length(I(x))), x_1) AND
                   subset?[real](A!1, IUnion[nat, real](I)))
                AND x_1`1 AND x_1`2 = z_1})")
                                                                                                          (("1"
                                                                                                            (name-replace
                                                                                                             "GLB"
                                                                                                             "glb({z_1: real |
             EXISTS (x_1: extended_nnreal):
               (EXISTS I:
                  x_le(x_sum(LAMBDA (x: nat): x_length(I(x))), x_1) AND
                   subset?[real](A!1, IUnion[nat, real](I)))
                AND x_1`1 AND x_1`2 = z_1})")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "greatest_lower_bound?")
                                                                                                              (("1"
                                                                                                                (flatten)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "lower_bound?")
                                                                                                                  (("1"
                                                                                                                    (hide
                                                                                                                     -2)
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "x_sum(LAMBDA (x: nat): x_length(I!1(x)))`2")
                                                                                                                      (("1"
                                                                                                                        (hide
                                                                                                                         2)
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           +
                                                                                                                           "x_sum(LAMBDA (x: nat): x_length(I!1(x)))")
                                                                                                                          (("1"
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.72 Sekunden  (vorverarbeitet)  ¤





Druckansicht
unsichere Verbindung
Druckansicht
sprechenden Kalenders

in der Quellcodebibliothek suchen




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