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


Quelle  holder_scaf.prf

  Sprache: Lisp
 

(holder_scaf
 (mu_TCC1 0
  (mu_TCC1-1 nil 3477456171
   ("" (typepred "S")
    (("" (expand "sigma_algebra?")
      (("" (flatten)
        (("" (expand "subset_algebra_empty?") (("" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((subset_algebra_empty? const-decl "bool" subset_algebra_def
     "measure_integration/")
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set[T]" countable_setofsets
     "sets_aux/")
    (member const-decl "bool" sets nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (T formal-type-decl nil holder_scaf nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def
     "measure_integration/")
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def
     "measure_integration/")
    (S formal-const-decl "sigma_algebra[T]" holder_scaf nil))
   nil))
 (q_TCC1 0 (q_TCC1-1 nil 3477456171 ("" (assertnil nilnil nil))
 (f_TCC1 0
  (f_TCC1-1 nil 3477456171 ("" (assertnil nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (g_TCC1 0
  (g_TCC1-1 nil 3477456171
   ("" (typepred "q")
    (("" (typepred "p")
      (("" (lemma "div_cancel3" ("x" "1" "n0z" "q" "y" "1-1/p"))
        (("" (assert)
          (("" (flatten)
            (("" (hide -2)
              (("" (split)
                (("1" (replace -1 1)
                  (("1"
                    (lemma "both_sides_times_pos_ge1"
                     ("pz" "q" "x" "1" "y" "1-1/p"))
                    (("1" (assert)
                      (("1" (hide 2)
                        (("1"
                          (lemma "posreal_div_posreal_is_posreal"
                           ("px" "1" "py" "p"))
                          (("1" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assertnil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nzreal_times_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (posreal_div_posreal_is_posreal judgement-tcc nil real_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (both_sides_times_pos_ge1 formula-decl nil real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (div_cancel3 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types 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)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (p formal-const-decl "{a: real | a > 1}" holder_scaf nil)
    (q formal-const-decl "{a: posreal | 1 / p + 1 / a = 1}" holder_scaf
     nil))
   nil))
 (holder_aux 0
  (holder_aux-1 nil 3477461478
   ("" (skosimp)
    (("" (typepred "f!1")
      (("" (typepred "g!1")
        (("" (case "p>1")
          (("1" (case "q>1")
            (("1" (typepred "norm[T, S, mu, q](g!1)")
              (("1" (typepred "norm[T, S, mu, p](f!1)")
                (("1" (expand ">=")
                  (("1" (expand "<=" -1)
                    (("1" (split)
                      (("1" (expand "<=" -2)
                        (("1" (split)
                          (("1" (expand "p_integrable?")
                            (("1" (flatten)
                              (("1"
                                (rewrite
                                 "prod_complex_measurable[T,S]")
                                (("1"
                                  (name
                                   "ALPHA"
                                   "norm[T, S, mu, p](f!1)")
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (name
                                       "BETA"
                                       "norm[T, S, mu, q](g!1)")
                                      (("1"
                                        (replace -1)
                                        (("1"
                                          (lemma
                                           "posreal_times_posreal_is_posreal"
                                           ("px" "ALPHA" "py" "BETA"))
                                          (("1"
                                            (lemma
                                             "real_expt_pos"
                                             ("px" "ALPHA" "a" "p"))
                                            (("1"
                                              (lemma
                                               "real_expt_pos"
                                               ("px" "BETA" "a" "q"))
                                              (("1"
                                                (case
                                                 "FORALL (x: T):
        abs(f!1(x) * g!1(x)) / (ALPHA * BETA) <=
         (1 / p) * (abs(f!1(x)) ^ p / (ALPHA ^ p)) +
          (1 / q) * (abs(g!1(x)) ^ q / (BETA ^ q))")
                                                (("1"
                                                  (case-replace
                                                   "abs(f!1 * g!1) ^ 1=abs(f!1 * g!1)")
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (expand "norm")
                                                      (("1"
                                                        (case-replace
                                                         "abs(f!1 * g!1) ^ 1=abs(f!1 * g!1)")
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (hide
                                                             -11
                                                             -13)
                                                            (("1"
                                                              (lemma
                                                               "both_sides_real_expt"
                                                               ("x"
                                                                "integral.integral(abs(g!1) ^ q) ^ (1 / q)"
                                                                "y"
                                                                "BETA"
                                                                "pa"
                                                                "q"))
                                                              (("1"
                                                                (rewrite
                                                                 "real_expt_times"
                                                                 -1
                                                                 :dir
                                                                 rl)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (lemma
                                                                     "both_sides_real_expt"
                                                                     ("x"
                                                                      "integral.integral(abs(f!1)^p)^(1/p)"
                                                                      "y"
                                                                      "ALPHA"
                                                                      "pa"
                                                                      "p"))
                                                                    (("1"
                                                                      (rewrite
                                                                       "real_expt_times"
                                                                       -1
                                                                       :dir
                                                                       rl)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (rewrite
                                                                           "real_expt_x1"
                                                                           -1)
                                                                          (("1"
                                                                            (rewrite
                                                                             "real_expt_x1"
                                                                             -2)
                                                                            (("1"
                                                                              (lemma
                                                                               "integral.integrable_is_measurable")
                                                                              (("1"
                                                                                (inst-cp
                                                                                 -
                                                                                 "abs(f!1) ^ p")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "abs(g!1) ^ q")
                                                                                  (("1"
                                                                                    (lemma
                                                                                     "expt_measurable"
                                                                                     ("g"
                                                                                      "abs(f!1) ^ p"
                                                                                      "a"
                                                                                      "1/p"))
                                                                                    (("1"
                                                                                      (lemma
                                                                                       "expt_measurable"
                                                                                       ("g"
                                                                                        "abs(g!1) ^ q"
                                                                                        "a"
                                                                                        "1/q"))
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "(^[T](abs(g!1) ^ q, 1 / q))=abs(g!1)")
                                                                                        (("1"
                                                                                          (case-replace
                                                                                           "(^[T](abs(f!1)^p, 1 / p))=abs(f!1)")
                                                                                          (("1"
                                                                                            (hide
                                                                                             -1
                                                                                             -2
                                                                                             -5
                                                                                             -6)
                                                                                            (("1"
                                                                                              (case
                                                                                               "measurable_function?[T,S](abs(f!1*g!1))")
                                                                                              (("1"
                                                                                                (lemma
                                                                                                 "scal_measurable"
                                                                                                 ("c"
                                                                                                  "1/(ALPHA * BETA)"
                                                                                                  "g"
                                                                                                  "abs(f!1 * g!1)"))
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -2
                                                                                                   -3
                                                                                                   -4)
                                                                                                  (("1"
                                                                                                    (lemma
                                                                                                     "integral.integrable_scal"
                                                                                                     ("c"
                                                                                                      "(1/p)*(1/ALPHA ^ p)"
                                                                                                      "f"
                                                                                                      "abs(f!1) ^ p"))
                                                                                                    (("1"
                                                                                                      (lemma
                                                                                                       "integral.integrable_scal"
                                                                                                       ("c"
                                                                                                        "(1/q)*(1/BETA ^ q)"
                                                                                                        "f"
                                                                                                        "abs(g!1) ^ q"))
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "integral.integrable_add"
                                                                                                         ("f1"
                                                                                                          "*[T]((1 / p) * (1 / ALPHA ^ p), abs(f!1) ^ p)"
                                                                                                          "f2"
                                                                                                          "*[T]((1 / q) * (1 / BETA ^ q), abs(g!1) ^ q)"))
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           -2
                                                                                                           -3)
                                                                                                          (("1"
                                                                                                            (lemma
                                                                                                             "integral_ae_abs"
                                                                                                             ("h"
                                                                                                              "*[T](1 / (ALPHA * BETA), abs(f!1 * g!1))"
                                                                                                              "f"
                                                                                                              "(+[T])
                      (*[T]((1 / p) * (1 / ALPHA ^ p), abs(f!1) ^ p),
                       *[T]((1 / q) * (1 / BETA ^ q), abs(g!1) ^ q))"))
                                                                                                            (("1"
                                                                                                              (split
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (flatten
                                                                                                                 -1)
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "integral.integrable_scal"
                                                                                                                   ("c"
                                                                                                                    "ALPHA*BETA"
                                                                                                                    "f"
                                                                                                                    "*[T](1 / (ALPHA * BETA), abs(f!1 * g!1))"))
                                                                                                                  (("1"
                                                                                                                    (case-replace
                                                                                                                     "(*[T]
                      (ALPHA * BETA,
                       *[T](1 / (ALPHA * BETA), abs(f!1 * g!1))))=abs(f!1 * g!1)")
                                                                                                                    (("1"
                                                                                                                      (rewrite
                                                                                                                       "real_expt_x1")
                                                                                                                      (("1"
                                                                                                                        (lemma
                                                                                                                         "integral.integral_scal"
                                                                                                                         ("c"
                                                                                                                          "1/(ALPHA*BETA)"
                                                                                                                          "f"
                                                                                                                          "abs(f!1*g!1)"))
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (lemma
                                                                                                                             "integral_nonneg"
                                                                                                                             ("f"
                                                                                                                              "abs(f!1*g!1)"))
                                                                                                                            (("1"
                                                                                                                              (split
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (rewrite
                                                                                                                                 "real_props.abs_mult"
                                                                                                                                 -6)
                                                                                                                                (("1"
                                                                                                                                  (lemma
                                                                                                                                   "posreal_div_posreal_is_posreal"
                                                                                                                                   ("px"
                                                                                                                                    "1"
                                                                                                                                    "py"
                                                                                                                                    "ALPHA*BETA"))
                                                                                                                                  (("1"
                                                                                                                                    (expand
                                                                                                                                     "abs"
                                                                                                                                     -7
                                                                                                                                     1)
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (expand
                                                                                                                                         "abs"
                                                                                                                                         -7
                                                                                                                                         1)
                                                                                                                                        (("1"
                                                                                                                                          (case
                                                                                                                                           "integral(abs((+[T])
                        (*[T]((1 / p) * (1 / ALPHA ^ p), abs(f!1) ^ p),
                         *[T]((1 / q) * (1 / BETA ^ q), abs(g!1) ^ q)))) <=1")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (lemma
                                                                                                                                               "div_mult_pos_le1"
                                                                                                                                               ("z"
                                                                                                                                                "integral.integral(abs(f!1 * g!1))"
                                                                                                                                                "py"
                                                                                                                                                "ALPHA * BETA"
                                                                                                                                                "x"
                                                                                                                                                "1"))
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil)
                                                                                                                                           ("2"
                                                                                                                                            (hide
                                                                                                                                             2
                                                                                                                                             -1
                                                                                                                                             -2
                                                                                                                                             -3
                                                                                                                                             -4
                                                                                                                                             -5
                                                                                                                                             -6
                                                                                                                                             -7)
                                                                                                                                            (("2"
                                                                                                                                              (case-replace
                                                                                                                                               "abs((+[T])
                       (*[T]((1 / p) * (1 / ALPHA ^ p), abs(f!1) ^ p),
                        *[T]((1 / q) * (1 / BETA ^ q), abs(g!1) ^ q)))= ((1/p)*1/(ALPHA^p))* abs(f!1)^p + ((1/q)*1/(BETA^q))* abs(g!1)^q")
                                                                                                                                              (("1"
                                                                                                                                                (hide
                                                                                                                                                 -1)
                                                                                                                                                (("1"
                                                                                                                                                  (lemma
                                                                                                                                                   "posreal_times_posreal_is_posreal"
                                                                                                                                                   ("px"
                                                                                                                                                    "1/p"
                                                                                                                                                    "py"
                                                                                                                                                    "1/(ALPHA^p)"))
                                                                                                                                                  (("1"
                                                                                                                                                    (lemma
                                                                                                                                                     "posreal_times_posreal_is_posreal"
                                                                                                                                                     ("px"
                                                                                                                                                      "1/q"
                                                                                                                                                      "py"
                                                                                                                                                      "1/(BETA^q)"))
                                                                                                                                                    (("1"
                                                                                                                                                      (name-replace
                                                                                                                                                       "AA"
                                                                                                                                                       "1 / p * (1 / (ALPHA ^ p))")
                                                                                                                                                      (("1"
                                                                                                                                                        (name-replace
                                                                                                                                                         "BB"
                                                                                                                                                         "1 / q * (1 / (BETA ^ q))")
                                                                                                                                                        (("1"
                                                                                                                                                          (lemma
                                                                                                                                                           "integral.integral_scal"
                                                                                                                                                           ("c"
                                                                                                                                                            "AA"
                                                                                                                                                            "f"
                                                                                                                                                            "abs(f!1)^p"))
                                                                                                                                                          (("1"
                                                                                                                                                            (lemma
                                                                                                                                                             "integral.integral_scal"
                                                                                                                                                             ("c"
                                                                                                                                                              "BB"
                                                                                                                                                              "f"
                                                                                                                                                              "abs(g!1)^q"))
                                                                                                                                                            (("1"
                                                                                                                                                              (replace
                                                                                                                                                               -7)
                                                                                                                                                              (("1"
                                                                                                                                                                (replace
                                                                                                                                                                 -8)
                                                                                                                                                                (("1"
                                                                                                                                                                  (lemma
                                                                                                                                                                   "integral.integral_add"
                                                                                                                                                                   ("f1"
                                                                                                                                                                    "AA * abs(f!1) ^ p"
                                                                                                                                                                    "f2"
                                                                                                                                                                    "BB * abs(g!1) ^ q"))
                                                                                                                                                                  (("1"
                                                                                                                                                                    (replace
                                                                                                                                                                     -2)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (replace
                                                                                                                                                                       -3)
                                                                                                                                                                      (("1"
                                                                                                                                                                        (replace
                                                                                                                                                                         -1)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (hide
                                                                                                                                                                           -1
                                                                                                                                                                           -2
                                                                                                                                                                           -3
                                                                                                                                                                           -20
                                                                                                                                                                           -21
                                                                                                                                                                           -8
                                                                                                                                                                           -9
                                                                                                                                                                           -6
                                                                                                                                                                           -7
                                                                                                                                                                           -14
                                                                                                                                                                           -15
                                                                                                                                                                           -10)
                                                                                                                                                                          (("1"
                                                                                                                                                                            (expand
                                                                                                                                                                             "AA")
                                                                                                                                                                            (("1"
                                                                                                                                                                              (expand
                                                                                                                                                                               "BB")
                                                                                                                                                                              (("1"
                                                                                                                                                                                (name-replace
                                                                                                                                                                                 "AP"
                                                                                                                                                                                 "ALPHA ^ p")
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (rewrite
                                                                                                                                                                                   "div_cancel1")
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (typepred
                                                                                                                                                                                     "q")
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (assert)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (assert)
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (rewrite
                                                                                                                                                                                           "one_times")
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (replace
                                                                                                                                                                                             -3)
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              nil
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil))
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil)
                                                                                                                                                     ("2"
                                                                                                                                                      (assert)
                                                                                                                                                      (("2"
                                                                                                                                                        (lemma
                                                                                                                                                         "posreal_div_posreal_is_posreal"
                                                                                                                                                         ("px"
                                                                                                                                                          "1"
                                                                                                                                                          "py"
                                                                                                                                                          "BETA^q"))
                                                                                                                                                        (("2"
                                                                                                                                                          (assert)
                                                                                                                                                          nil
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (lemma
                                                                                                                                                     "posreal_div_posreal_is_posreal"
                                                                                                                                                     ("px"
                                                                                                                                                      "1"
                                                                                                                                                      "py"
                                                                                                                                                      "ALPHA^p"))
                                                                                                                                                    (("2"
                                                                                                                                                      (assert)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (hide
                                                                                                                                                 2)
                                                                                                                                                (("2"
                                                                                                                                                  (apply-extensionality
                                                                                                                                                   :hide?
                                                                                                                                                   t)
                                                                                                                                                  (("1"
                                                                                                                                                    (expand
                                                                                                                                                     "abs"
                                                                                                                                                     +)
                                                                                                                                                    (("1"
                                                                                                                                                      (expand
                                                                                                                                                       "+"
                                                                                                                                                       +)
                                                                                                                                                      (("1"
                                                                                                                                                        (expand
                                                                                                                                                         "*"
                                                                                                                                                         +)
                                                                                                                                                        (("1"
                                                                                                                                                          (expand
                                                                                                                                                           "^"
                                                                                                                                                           1
                                                                                                                                                           1)
                                                                                                                                                          (("1"
                                                                                                                                                            (expand
                                                                                                                                                             "^"
                                                                                                                                                             1
                                                                                                                                                             1)
                                                                                                                                                            (("1"
                                                                                                                                                              (expand
                                                                                                                                                               "^"
                                                                                                                                                               1
                                                                                                                                                               6)
                                                                                                                                                              (("1"
                                                                                                                                                                (expand
                                                                                                                                                                 "^"
                                                                                                                                                                 1
                                                                                                                                                                 8)
                                                                                                                                                                (("1"
                                                                                                                                                                  (rewrite
                                                                                                                                                                   "div_div2")
                                                                                                                                                                  (("1"
                                                                                                                                                                    (rewrite
                                                                                                                                                                     "div_div2")
                                                                                                                                                                    (("1"
                                                                                                                                                                      (case-replace
                                                                                                                                                                       "abs(f!1(x!1)) ^ p * (1 / ALPHA ^ p) * (1 / p)=(1 / (p * (ALPHA ^ p))) * abs(f!1(x!1)) ^ p")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (case-replace
                                                                                                                                                                         "abs(g!1(x!1)) ^ q * (1 / BETA ^ q) * (1 / q)=(1 / (q * (BETA ^ q))) * abs(g!1(x!1)) ^ q")
                                                                                                                                                                        (("1"
                                                                                                                                                                          (hide
                                                                                                                                                                           -1
                                                                                                                                                                           -2)
                                                                                                                                                                          (("1"
                                                                                                                                                                            (lemma
                                                                                                                                                                             "posreal_times_posreal_is_posreal"
                                                                                                                                                                             ("px"
                                                                                                                                                                              "p"
                                                                                                                                                                              "py"
                                                                                                                                                                              "ALPHA^p"))
                                                                                                                                                                            (("1"
                                                                                                                                                                              (lemma
                                                                                                                                                                               "posreal_times_posreal_is_posreal"
                                                                                                                                                                               ("px"
                                                                                                                                                                                "q"
                                                                                                                                                                                "py"
                                                                                                                                                                                "BETA^q"))
                                                                                                                                                                              (("1"
                                                                                                                                                                                (lemma
                                                                                                                                                                                 "posreal_div_posreal_is_posreal"
                                                                                                                                                                                 ("px"
                                                                                                                                                                                  "1"
                                                                                                                                                                                  "py"
                                                                                                                                                                                  "q*BETA^q"))
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (lemma
                                                                                                                                                                                   "posreal_div_posreal_is_posreal"
                                                                                                                                                                                   ("px"
                                                                                                                                                                                    "1"
                                                                                                                                                                                    "py"
                                                                                                                                                                                    "p*ALPHA^p"))
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (name-replace
                                                                                                                                                                                     "AA"
                                                                                                                                                                                     "(1 / (p * (ALPHA ^ p)))")
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (name-replace
                                                                                                                                                                                       "BB"
                                                                                                                                                                                       "(1 / (q * (BETA ^ q)))")
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (lemma
                                                                                                                                                                                         "both_sides_times_pos_le1"
                                                                                                                                                                                         ("pz"
                                                                                                                                                                                          "AA"
                                                                                                                                                                                          "x"
                                                                                                                                                                                          "0"
                                                                                                                                                                                          "y"
                                                                                                                                                                                          "abs(f!1(x!1))^p"))
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (assert)
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (lemma
                                                                                                                                                                                             "both_sides_times_pos_le1"
                                                                                                                                                                                             ("pz"
                                                                                                                                                                                              "BB"
                                                                                                                                                                                              "x"
                                                                                                                                                                                              "0"
                                                                                                                                                                                              "y"
                                                                                                                                                                                              "abs(g!1(x!1))^q"))
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              (("1"
                                                                                                                                                                                                (expand
                                                                                                                                                                                                 "abs"
                                                                                                                                                                                                 1
                                                                                                                                                                                                 1)
                                                                                                                                                                                                (("1"
                                                                                                                                                                                                  (propax)
                                                                                                                                                                                                  nil
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil))
                                                                                                                                                                                          nil)
                                                                                                                                                                                         ("2"
                                                                                                                                                                                          (assert)
                                                                                                                                                                                          nil
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil)
                                                                                                                                                                                   ("2"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil)
                                                                                                                                                                                 ("2"
                                                                                                                                                                                  (propax)
                                                                                                                                                                                  nil
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil)
                                                                                                                                                                         ("2"
                                                                                                                                                                          (assert)
                                                                                                                                                                          nil
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("2"
                                                                                                                                                                        (assert)
                                                                                                                                                                        nil
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (skolem
                                                                                                                                                     +
                                                                                                                                                     "x!1")
                                                                                                                                                    (("2"
                                                                                                                                                      (hide
                                                                                                                                                       2)
                                                                                                                                                      (("2"
                                                                                                                                                        (expand
                                                                                                                                                         "+"
                                                                                                                                                         1)
                                                                                                                                                        (("2"
                                                                                                                                                          (expand
                                                                                                                                                           "*"
                                                                                                                                                           1)
                                                                                                                                                          (("2"
                                                                                                                                                            (expand
                                                                                                                                                             "^"
                                                                                                                                                             1
                                                                                                                                                             2)
                                                                                                                                                            (("2"
                                                                                                                                                              (expand
                                                                                                                                                               "^"
                                                                                                                                                               1
                                                                                                                                                               4)
                                                                                                                                                              (("2"
                                                                                                                                                                (expand
                                                                                                                                                                 "abs"
                                                                                                                                                                 1)
                                                                                                                                                                (("2"
                                                                                                                                                                  (lemma
                                                                                                                                                                   "posreal_div_posreal_is_posreal"
                                                                                                                                                                   ("px"
                                                                                                                                                                    "1/p"
                                                                                                                                                                    "py"
                                                                                                                                                                    "ALPHA^p"))
                                                                                                                                                                  (("2"
                                                                                                                                                                    (lemma
                                                                                                                                                                     "posreal_div_posreal_is_posreal"
                                                                                                                                                                     ("px"
                                                                                                                                                                      "1/q"
                                                                                                                                                                      "py"
                                                                                                                                                                      "BETA^q"))
                                                                                                                                                                    (("2"
                                                                                                                                                                      (name-replace
                                                                                                                                                                       "AA"
                                                                                                                                                                       "(1 / p) / (ALPHA ^ p)")
                                                                                                                                                                      (("2"
                                                                                                                                                                        (name-replace
                                                                                                                                                                         "BB"
                                                                                                                                                                         "(1 / q) / (BETA ^ q)")
                                                                                                                                                                        (("2"
                                                                                                                                                                          (lemma
                                                                                                                                                                           "both_sides_times_pos_le1"
                                                                                                                                                                           ("pz"
                                                                                                                                                                            "AA"
                                                                                                                                                                            "x"
                                                                                                                                                                            "0"
                                                                                                                                                                            "y"
                                                                                                                                                                            "abs(f!1(x!1))^p"))
                                                                                                                                                                          (("1"
                                                                                                                                                                            (lemma
                                                                                                                                                                             "both_sides_times_pos_le1"
                                                                                                                                                                             ("pz"
                                                                                                                                                                              "BB"
                                                                                                                                                                              "x"
                                                                                                                                                                              "0"
                                                                                                                                                                              "y"
                                                                                                                                                                              "abs(g!1(x!1))^q"))
                                                                                                                                                                            (("1"
                                                                                                                                                                              (assert)
                                                                                                                                                                              nil
                                                                                                                                                                              nil)
                                                                                                                                                                             ("2"
                                                                                                                                                                              (assert)
                                                                                                                                                                              nil
                                                                                                                                                                              nil))
                                                                                                                                                                            nil)
                                                                                                                                                                           ("2"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (skosimp)
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "abs"
                                                                                                                                   +)
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (rewrite
                                                                                                                           "complex_abs_mul"
                                                                                                                           -2)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (lemma
                                                                                                                         "integral_nonneg"
                                                                                                                         ("f"
                                                                                                                          "abs(f!1*g!1)"))
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (skosimp)
                                                                                                                            (("2"
                                                                                                                              (expand
                                                                                                                               "abs")
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (hide
                                                                                                                                   2
                                                                                                                                   3
                                                                                                                                   -6)
                                                                                                                                  (("2"
                                                                                                                                    (expand
                                                                                                                                     "*")
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (apply-extensionality
                                                                                                                       :hide?
                                                                                                                       t)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "*"
                                                                                                                         1)
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "abs"
                                                                                                                           1)
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (hide-all-but
                                                                                                                 (1
                                                                                                                  -5
                                                                                                                  -6
                                                                                                                  -7
                                                                                                                  -8
                                                                                                                  -11
                                                                                                                  -12
                                                                                                                  -13
                                                                                                                  -14))
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "ae_le?")
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "pointwise_ae?")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "ae?")
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "fullset")
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "ae_in?")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             +
                                                                                                                             "emptyset")
                                                                                                                            (("2"
                                                                                                                              (skosimp)
                                                                                                                              (("2"
                                                                                                                                (hide
                                                                                                                                 1)
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "member")
                                                                                                                                  (("2"
                                                                                                                                    (expand
                                                                                                                                     "*"
                                                                                                                                     +)
                                                                                                                                    (("2"
                                                                                                                                      (expand
                                                                                                                                       "abs"
                                                                                                                                       +)
                                                                                                                                      (("2"
                                                                                                                                        (expand
                                                                                                                                         "+"
                                                                                                                                         +)
                                                                                                                                        (("2"
                                                                                                                                          (expand
                                                                                                                                           "^"
                                                                                                                                           1
                                                                                                                                           1)
                                                                                                                                          (("2"
                                                                                                                                            (expand
                                                                                                                                             "^"
                                                                                                                                             1
                                                                                                                                             1)
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "x!1")
                                                                                                                                              (("2"
                                                                                                                                                (typepred
                                                                                                                                                 "abs(f!1(x!1) * g!1(x!1))")
                                                                                                                                                (("2"
                                                                                                                                                  (lemma
                                                                                                                                                   "both_sides_div_pos_ge1"
                                                                                                                                                   ("pz"
                                                                                                                                                    "ALPHA*BETA"
                                                                                                                                                    "x"
                                                                                                                                                    "abs(f!1(x!1) * g!1(x!1))"
                                                                                                                                                    "y"
                                                                                                                                                    "0"))
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    (("2"
                                                                                                                                                      (case-replace
                                                                                                                                                       "1 / (ALPHA * BETA) * (abs(f!1(x!1)) * abs(g!1(x!1)))=abs(f!1(x!1)) * abs(g!1(x!1)) / (ALPHA * BETA)")
                                                                                                                                                      (("1"
                                                                                                                                                        (hide
                                                                                                                                                         -1)
                                                                                                                                                        (("1"
                                                                                                                                                          (expand
                                                                                                                                                           "abs"
                                                                                                                                                           1
                                                                                                                                                           1)
                                                                                                                                                          (("1"
                                                                                                                                                            (name-replace
                                                                                                                                                             "LHS"
                                                                                                                                                             "abs(f!1(x!1)) * abs(g!1(x!1)) / (ALPHA * BETA)")
                                                                                                                                                            (("1"
                                                                                                                                                              (expand
                                                                                                                                                               "abs"
                                                                                                                                                               1
                                                                                                                                                               1)
                                                                                                                                                              (("1"
                                                                                                                                                                (assert)
                                                                                                                                                                nil
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil)
                                                                                                                                                       ("2"
                                                                                                                                                        (assert)
                                                                                                                                                        nil
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (hide
                                                                                                               -1
                                                                                                               2)
                                                                                                              (("2"
                                                                                                                (rewrite
                                                                                                                 "complex_abs_mul"
                                                                                                                 -1)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("3"
                                                                                                              (propax)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("3"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (rewrite
                                                                                                   "complex_abs_mul"
                                                                                                   -1)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (lemma
                                                                                                   "prod_measurable[T,S]"
                                                                                                   ("g1"
                                                                                                    "abs(f!1)"
                                                                                                    "g2"
                                                                                                    "abs(g!1)"))
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "(*[T](abs(f!1), abs(g!1)))=abs(f!1 * g!1)")
                                                                                                    (("1"
                                                                                                      (apply-extensionality
                                                                                                       :hide?
                                                                                                       t)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (propax)
                                                                                                    nil
                                                                                                    nil)
                                                                                                   ("3"
                                                                                                    (propax)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (apply-extensionality
                                                                                             1
                                                                                             :hide?
                                                                                             t)
                                                                                            (("1"
                                                                                              (hide-all-but
                                                                                               (-17
                                                                                                1))
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "^")
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "abs")
                                                                                                  (("1"
                                                                                                    (rewrite
                                                                                                     "real_expt_times"
                                                                                                     +
                                                                                                     :dir
                                                                                                     rl)
                                                                                                    (("1"
                                                                                                      (rewrite
                                                                                                       "real_expt_x1")
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (lemma
                                                                                               "posreal_div_posreal_is_posreal"
                                                                                               ("px"
                                                                                                "1"
                                                                                                "py"
                                                                                                "p"))
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("3"
                                                                                            (lemma
                                                                                             "posreal_div_posreal_is_posreal"
                                                                                             ("px"
                                                                                              "1"
                                                                                              "py"
                                                                                              "p"))
                                                                                            (("3"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide-all-but
                                                                                           (-15
                                                                                            1))
                                                                                          (("2"
                                                                                            (lemma
                                                                                             "posreal_div_posreal_is_posreal"
                                                                                             ("px"
                                                                                              "1"
                                                                                              "py"
                                                                                              "q"))
                                                                                            (("2"
                                                                                              (apply-extensionality
                                                                                               :hide?
                                                                                               t)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "abs")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "^")
                                                                                                  (("2"
                                                                                                    (rewrite
                                                                                                     "real_expt_times"
                                                                                                     +
                                                                                                     :dir
                                                                                                     rl)
                                                                                                    (("2"
                                                                                                      (rewrite
                                                                                                       "real_expt_x1")
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (expand
                                                                                         "nn_measurable?")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (hide-all-but
                                                                                             (1
                                                                                              -14))
                                                                                            (("2"
                                                                                              (skosimp)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "^")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "abs")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "nn_measurable?")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (hide-all-but
                                                                                           (-14
                                                                                            1))
                                                                                          (("2"
                                                                                            (skosimp)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "^")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "abs")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (lemma
                                                                                       "posreal_div_posreal_is_posreal"
                                                                                       ("px"
                                                                                        "1"
                                                                                        "py"
                                                                                        "p"))
                                                                                      (("3"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (lemma
                                                                       "integral_nonneg"
                                                                       ("f"
                                                                        "^[T](abs[T](f!1), p)"))
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (skosimp)
                                                                          (("2"
                                                                            (expand
                                                                             "^"
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "abs"
                                                                               1)
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (lemma
                                                                 "integral_nonneg"
                                                                 ("f"
                                                                  "^[T](abs[T](g!1), q)"))
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (skosimp)
                                                                    (("2"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("2"
                                                                        (expand
                                                                         "^")
                                                                        (("2"
                                                                          (expand
                                                                           "abs")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (apply-extensionality
                                                           :hide?
                                                           t)
                                                          (("2"
                                                            (expand
                                                             "^"
                                                             1)
                                                            (("2"
                                                              (rewrite
                                                               "real_expt_x1"
                                                               1)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (apply-extensionality
                                                       :hide?
                                                       t)
                                                      (("2"
                                                        (expand "^")
                                                        (("2"
                                                          (rewrite
                                                           "real_expt_x1")
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (skosimp)
                                                    (("2"
                                                      (hide
                                                       -4
                                                       -5
                                                       -10
                                                       -11
                                                       -12
                                                       -13)
                                                      (("2"
                                                        (typepred "q")
                                                        (("2"
                                                          (hide -1)
                                                          (("2"
                                                            (lemma
                                                             "youngs_inequality"
                                                             ("p"
                                                              "p"
                                                              "q"
                                                              "q"
                                                              "a"
                                                              "abs(f!1(x!1))/ALPHA"
                                                              "b"
                                                              "abs(g!1(x!1))/BETA"))
                                                            (("1"
                                                              (replace
                                                               -3)
                                                              (("1"
                                                                (rewrite
                                                                 "abs_mult"
                                                                 1)
                                                                (("1"
                                                                  (typepred
                                                                   "abs(f!1(x!1))")
                                                                  (("1"
                                                                    (typepred
                                                                     "abs(g!1(x!1))")
                                                                    (("1"
                                                                      (name-replace
                                                                       "FX"
                                                                       "abs(f!1(x!1))")
                                                                      (("1"
                                                                        (name-replace
                                                                         "GX"
                                                                         "abs(g!1(x!1))")
                                                                        (("1"
                                                                          (rewrite
                                                                           "div_times")
                                                                          (("1"
                                                                            (name-replace
                                                                             "LHS"
                                                                             "(FX * GX) / (ALPHA * BETA)")
                                                                            (("1"
                                                                              (rewrite
                                                                               "div_real_expt"
                                                                               +
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (rewrite
                                                                                 "div_real_expt"
                                                                                 +
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (propax)
                                                              nil
                                                              nil)
                                                             ("3"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("4"
                                                              (rewrite
                                                               "div_mult_pos_ge1"
                                                               1)
                                                              (("4"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("5"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("6"
                                                              (rewrite
                                                               "div_mult_pos_ge1"
                                                               1)
                                                              (("6"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("7"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (skosimp)
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("4"
                                                  (skosimp)
                                                  (("4"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("5"
                                                  (skosimp)
                                                  (("5"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("6"
                                                  (skosimp)
                                                  (("6"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("7"
                                                  (skosimp)
                                                  (("7"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("8"
                                                  (skosimp)
                                                  (("8"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assertnil nil)
                                           ("3" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (replace -1 * rl)
                            (("2" (rewrite "zero_times2")
                              (("2"
                                (lemma
                                 "norm_eq_0[T, S, mu, q]"
                                 ("f" "g!1"))
                                (("2"
                                  (flatten)
                                  (("2"
                                    (split -1)
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (case
                                         "cal_N?[T, S, mu](f!1*g!1)")
                                        (("1"
                                          (lemma
                                           "cal_N_is_p_integrable[T, S, mu, 1]")
                                          (("1"
                                            (inst - "f!1 * g!1")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (lemma
                                                 "norm_eq_0[T,S,mu,1]"
                                                 ("f" "f!1*g!1"))
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand "p_integrable?")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (hide-all-but (-1 1 -8))
                                              (("2"
                                                (expand "cal_N?")
                                                (("2"
                                                  (expand "ae_0?")
                                                  (("2"
                                                    (expand
                                                     "pointwise_ae?")
                                                    (("2"
                                                      (expand "ae?")
                                                      (("2"
                                                        (expand
                                                         "fullset")
                                                        (("2"
                                                          (expand
                                                           "ae_in?")
                                                          (("2"
                                                            (skosimp)
                                                            (("2"
                                                              (skosimp)
                                                              (("2"
                                                                (expand
                                                                 "member")
                                                                (("2"
                                                                  (rewrite
                                                                   "prod_complex_measurable[T,S]")
                                                                  (("2"
                                                                    (hide
                                                                     -2
                                                                     -3)
                                                                    (("2"
                                                                      (inst
                                                                       +
                                                                       "E!1")
                                                                      (("2"
                                                                        (skosimp)
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "x!1")
                                                                          (("2"
                                                                            (expand
                                                                             "*")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (flatten)
                                                                                (("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)
                                     ("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (replace -1 * rl)
                        (("2" (rewrite "zero_times1")
                          (("2"
                            (lemma "norm_eq_0[T, S, mu, p]"
                             ("f" "f!1"))
                            (("2" (flatten)
                              (("2"
                                (hide -2)
                                (("2"
                                  (split)
                                  (("1"
                                    (case "cal_N?[T,S,mu](f!1*g!1)")
                                    (("1"
                                      (lemma
                                       "cal_N_is_p_integrable[T, S, mu, 1]")
                                      (("1"
                                        (inst - "f!1 * g!1")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (lemma
                                             "norm_eq_0[T,S,mu,1]"
                                             ("f" "f!1*g!1"))
                                            (("1" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but (-1 -6 -7 1))
                                      (("2"
                                        (expand "cal_N?")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (expand "p_integrable?")
                                            (("2"
                                              (flatten)
                                              (("2"
                                                (lemma
                                                 "prod_complex_measurable[T,S]"
                                                 ("g1"
                                                  "f!1"
                                                  "g2"
                                                  "g!1"))
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide-all-but
                                                     (-2 1))
                                                    (("1"
                                                      (expand "ae_0?")
                                                      (("1"
                                                        (expand
                                                         "pointwise_ae?")
                                                        (("1"
                                                          (expand
                                                           "ae?")
                                                          (("1"
                                                            (expand
                                                             "fullset")
                                                            (("1"
                                                              (expand
                                                               "ae_in?")
                                                              (("1"
                                                                (skosimp)
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "E!1")
                                                                  (("1"
                                                                    (skosimp)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
                                                                        (expand
                                                                         "member")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "*")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2" (propax) nil nil)
                                                 ("3"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assertnil nil))
                nil)
               ("2" (assertnil nil))
              nil)
             ("2" (hide-all-but (-1 1))
              (("2" (typepred "q")
                (("2"
                  (lemma "div_cancel3" ("x" "1" "n0z" "q" "y" "1-1/p"))
                  (("2" (flatten)
                    (("2" (hide -2)
                      (("2" (split)
                        (("1" (replace -1 1)
                          (("1" (hide -1)
                            (("1"
                              (lemma "both_sides_times_pos_gt1"
                               ("pz" "q" "x" "1" "y" "1-1/p"))
                              (("1"
                                (lemma
                                 "posreal_div_posreal_is_posreal"
                                 ("px" "1" "py" "p"))
                                (("1" (assertnil nil)
                                 ("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((p_integrable nonempty-type-eq-decl nil p_integrable_def nil)
    (p_integrable? const-decl "bool" p_integrable_def nil)
    (p formal-const-decl "{a: real | a > 1}" holder_scaf nil)
    (> const-decl "bool" reals nil)
    (mu formal-const-decl "measure_type[T, S]" holder_scaf nil)
    (measure_type nonempty-type-eq-decl nil generalized_measure_def
     "measure_integration/")
    (measure? const-decl "bool" generalized_measure_def
     "measure_integration/")
    (extended_nnreal nonempty-type-eq-decl nil extended_nnreal
     "extended_nnreal/")
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (S formal-const-decl "sigma_algebra[T]" holder_scaf nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def
     "measure_integration/")
    (sigma_algebra? const-decl "bool" subset_algebra_def
     "measure_integration/")
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (complex type-decl nil complex_types "complex_alt/")
    (T formal-type-decl nil holder_scaf nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (div_cancel3 formula-decl nil real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (norm const-decl "nnreal" p_integrable_def nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (div_times formula-decl nil real_props nil)
    (div_real_expt formula-decl nil real_expt "power/")
    (youngs_inequality formula-decl nil young nil)
    (* const-decl "[T -> complex]" complex_fun_ops "complex_alt/")
    (abs const-decl "[T -> nonneg_real]" complex_fun_ops
         "complex_alt/")
    (^ const-decl "[T -> nnreal]" real_fun_power "power/")
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (both_sides_real_expt formula-decl nil real_expt "power/")
    (integrable? const-decl "bool" integral "measure_integration/")
    (integrable nonempty-type-eq-decl nil integral
     "measure_integration/")
    (integral const-decl "real" integral "measure_integration/")
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (abs_mult formula-decl nil polar "complex_alt/")
    (complex_abs_mul formula-decl nil complex_fun_ops "complex_alt/")
    (real_expt_x1 formula-decl nil real_expt "power/")
    (integrable_is_measurable judgement-tcc nil integral
     "measure_integration/")
    (measurable_function? const-decl "bool" measure_space_def
     "measure_integration/")
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posreal_div_posreal_is_posreal judgement-tcc nil real_types nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (abs const-decl "[T -> nonneg_real]" real_fun_ops "reals/")
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (integral_add formula-decl nil integral "measure_integration/")
    (BB skolem-const-decl "nzreal" holder_scaf nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (div_cancel1 formula-decl nil real_props nil)
    (one_times formula-decl nil extra_tegies nil)
    (AA skolem-const-decl "nzreal" holder_scaf nil)
    (g!1 skolem-const-decl "p_integrable[T, S, mu, q]" holder_scaf nil)
    (BETA skolem-const-decl "nnreal" holder_scaf nil)
    (f!1 skolem-const-decl "p_integrable[T, S, mu, p]" holder_scaf nil)
    (ALPHA skolem-const-decl "nnreal" holder_scaf nil)
    (div_div2 formula-decl nil real_props nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (abs_mult formula-decl nil real_props nil)
    (integral_nonneg formula-decl nil integral "measure_integration/")
    (integral_scal formula-decl nil integral "measure_integration/")
    (ae_le? const-decl "bool" measure_theory "measure_integration/")
    (subset_algebra_fullset name-judgement "(S)" holder_scaf nil)
    (measurable_fullset name-judgement "measurable_set[T, S]"
     holder_scaf nil)
    (ae? const-decl "bool" measure_theory "measure_integration/")
    (ae_in? const-decl "bool" measure_theory "measure_integration/")
    (member const-decl "bool" sets nil)
    (TRUE const-decl "bool" booleans nil)
    (both_sides_div_pos_ge1 formula-decl nil real_props nil)
    (set type-eq-decl nil sets nil)
    (negligible_set? const-decl "bool" measure_theory
     "measure_integration/")
    (negligible nonempty-type-eq-decl nil measure_theory
     "measure_integration/")
    (emptyset const-decl "set" sets nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set[T]" countable_setofsets
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set[T]" sigma_countable
     "sigma_set/")
    (finite_emptyset name-judgement "finite_set[T]" step_fun_props
     "analysis/")
    (subset_algebra_emptyset name-judgement "(S)" holder_scaf nil)
    (null_emptyset name-judgement "null_set[T, S, mu]" holder_scaf nil)
    (fullset const-decl "set" sets nil)
    (pointwise_ae? const-decl "bool" measure_theory
     "measure_integration/")
    (+ const-decl "[T -> real]" real_fun_ops "reals/")
    (integral_ae_abs formula-decl nil integral "measure_integration/")
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (integrable_add judgement-tcc nil integral "measure_integration/")
    (integrable_scal judgement-tcc nil integral "measure_integration/")
    (nzreal_times_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (measurable_function nonempty-type-eq-decl nil measure_space_def
     "measure_integration/")
    (scal_measurable judgement-tcc nil measure_space_def
     "measure_integration/")
    (prod_measurable judgement-tcc nil measure_space
     "measure_integration/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nn_measurable nonempty-type-eq-decl nil measure_space
     "measure_integration/")
    (nn_measurable? const-decl "bool" measure_space
     "measure_integration/")
    (expt_measurable judgement-tcc nil measure_space
     "measure_integration/")
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_expt_times formula-decl nil real_expt "power/")
    (^ const-decl "nnreal" real_expt "power/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "complex" complex_types "complex_alt/")
    (abs const-decl "nnreal" polar "complex_alt/")
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (real_expt_pos formula-decl nil real_expt "power/")
    (prod_complex_measurable judgement-tcc nil complex_measurable nil)
    (complex_measurable? const-decl "bool" complex_measurable nil)
    (complex_measurable nonempty-type-eq-decl nil complex_measurable
     nil)
    (zero_times2 formula-decl nil real_props nil)
    (ae_0? const-decl "bool" complex_measure_theory nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (Re_mul1 formula-decl nil complex_types "complex_alt/")
    (Re_rew formula-decl nil complex_types "complex_alt/")
    (Im_mul1 formula-decl nil complex_types "complex_alt/")
    (Im_rew formula-decl nil complex_types "complex_alt/")
    (c_eq1 formula-decl nil complex_types "complex_alt/")
    (pointwise_ae? const-decl "bool" complex_measure_theory nil)
    (cal_N_is_p_integrable judgement-tcc nil p_integrable_def nil)
    (cal_N nonempty-type-eq-decl nil complex_measure_theory nil)
    (cal_N? const-decl "bool" complex_measure_theory nil)
    (norm_eq_0 formula-decl nil p_integrable_def nil)
    (zero_times1 formula-decl nil real_props nil)
    (<= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types 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)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (q formal-const-decl "{a: posreal | 1 / p + 1 / a = 1}" holder_scaf
     nil))
   shostak))
 (holder_judge1 0
  (holder_judge1-1 nil 3477456171
   ("" (skosimp)
    (("" (lemma "holder_aux" ("f" "f!1" "g" "g!1"))
      (("" (flatten) nil nil)) nil))
    nil)
   ((q formal-const-decl "{a: posreal | 1 / p + 1 / a = 1}" holder_scaf
     nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (p_integrable nonempty-type-eq-decl nil p_integrable_def nil)
    (p_integrable? const-decl "bool" p_integrable_def nil)
    (p formal-const-decl "{a: real | a > 1}" holder_scaf nil)
    (> const-decl "bool" reals nil)
    (mu formal-const-decl "measure_type[T, S]" holder_scaf nil)
    (measure_type nonempty-type-eq-decl nil generalized_measure_def
     "measure_integration/")
    (measure? const-decl "bool" generalized_measure_def
     "measure_integration/")
    (extended_nnreal nonempty-type-eq-decl nil extended_nnreal
     "extended_nnreal/")
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (S formal-const-decl "sigma_algebra[T]" holder_scaf nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def
     "measure_integration/")
    (sigma_algebra? const-decl "bool" subset_algebra_def
     "measure_integration/")
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (complex type-decl nil complex_types "complex_alt/")
    (T formal-type-decl nil holder_scaf nil)
    (holder_aux formula-decl nil holder_scaf nil))
   nil))
 (holder_judge2 0
  (holder_judge2-1 nil 3477456171
   ("" (skosimp)
    (("" (lemma "holder_aux" ("f" "f!1" "g" "g!1"))
      (("" (flatten)
        (("" (hide -2)
          (("" (expand "*")
            (("" (expand "*") (("" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((q formal-const-decl "{a: posreal | 1 / p + 1 / a = 1}" holder_scaf
     nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (p_integrable nonempty-type-eq-decl nil p_integrable_def nil)
    (p_integrable? const-decl "bool" p_integrable_def nil)
    (p formal-const-decl "{a: real | a > 1}" holder_scaf nil)
    (> const-decl "bool" reals nil)
    (mu formal-const-decl "measure_type[T, S]" holder_scaf nil)
    (measure_type nonempty-type-eq-decl nil generalized_measure_def
     "measure_integration/")
    (measure? const-decl "bool" generalized_measure_def
     "measure_integration/")
    (extended_nnreal nonempty-type-eq-decl nil extended_nnreal
     "extended_nnreal/")
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (S formal-const-decl "sigma_algebra[T]" holder_scaf nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def
     "measure_integration/")
    (sigma_algebra? const-decl "bool" subset_algebra_def
     "measure_integration/")
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (complex type-decl nil complex_types "complex_alt/")
    (T formal-type-decl nil holder_scaf nil)
    (holder_aux formula-decl nil holder_scaf nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (* const-decl "complex" complex_types "complex_alt/")
    (* const-decl "[T -> complex]" complex_fun_ops "complex_alt/"))
   nil))
 (holder_scaf 0
  (holder_scaf-1 nil 3452581063
   ("" (skosimp)
    (("" (lemma "holder_aux" ("f" "f!1" "g" "g!1"))
      (("" (flatten) nil nil)) nil))
    nil)
   ((q formal-const-decl "{a: posreal | 1 / p + 1 / a = 1}" holder_scaf
     nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (p_integrable nonempty-type-eq-decl nil p_integrable_def nil)
    (p_integrable? const-decl "bool" p_integrable_def nil)
    (p formal-const-decl "{a: real | a > 1}" holder_scaf nil)
    (> const-decl "bool" reals nil)
    (mu formal-const-decl "measure_type[T, S]" holder_scaf nil)
    (measure_type nonempty-type-eq-decl nil generalized_measure_def
     "measure_integration/")
    (measure? const-decl "bool" generalized_measure_def
     "measure_integration/")
    (extended_nnreal nonempty-type-eq-decl nil extended_nnreal
     "extended_nnreal/")
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (S formal-const-decl "sigma_algebra[T]" holder_scaf nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def
     "measure_integration/")
    (sigma_algebra? const-decl "bool" subset_algebra_def
     "measure_integration/")
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (complex type-decl nil complex_types "complex_alt/")
    (T formal-type-decl nil holder_scaf nil)
    (holder_aux formula-decl nil holder_scaf nil))
   shostak)))


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

¤ Dauer der Verarbeitung: 0.136 Sekunden  (vorverarbeitet am  2026-04-30) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge