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

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: poly_minmax.prf   Sprache: Lisp

Original von: PVS©

(poly_minmax
 (sound_poly_lb_le_ub 0
  (sound_poly_lb_le_ub-1 nil 3509729606
   ("" (skeep)
    (("" (expand "sound_poly?")
      (("" (label "altb" -2)
        (("" (assert)
          (("" (hide (-2 -3))
            (("" (split -)
              (("1" (flatten)
                (("1" (expand "sound_poly_fin?")
                  (("1" (flatten)
                    (("1" (hide (-3 -4))
                      (("1" (expand "forall_X_poly_between")
                        (("1"
                          (case "EXISTS (ABv:Vars): boxbetween?(nvars)(Avars, Bvars, intendpts, boundedpts)(ABv)")
                          (("1" (skeep -1)
                            (("1" (inst - "ABv")
                              (("1"
                                (assert)
                                (("1"
                                  (expand "lb_le_ub?")
                                  (("1" (ground) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2"
                            (name "ABvv"
                                  "LAMBDA (i:nat): (Avars(i) + Bvars(i))/2")
                            (("2"
                              (case "FORALL (ij:nat): ij)
                              (("1"
                                (inst + "ABvv")
                                (("1"
                                  (hide -4)
                                  (("1"
                                    (expand "boxbetween?")
                                    (("1"
                                      (expand "interval_between?")
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (inst - "j!1")
                                          (("1"
                                            (expand
                                             "bounded_points_true?")
                                            (("1"
                                              (inst - "j!1")
                                              (("1" (ground) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (hide -3)
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (reveal "altb")
                                      (("2"
                                        (expand "lt_below?")
                                        (("2"
                                          (inst - "ij!1")
                                          (("2"
                                            (expand "ABvv" +)
                                            (("2" (ground) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (flatten)
                (("2" (expand "sound_poly_inf?")
                  (("2" (inst - ">")
                    (("2" (expand "lb_le_ub?") (("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sound_poly? const-decl "bool" poly_minmax nil)
    (sound_poly_fin? const-decl "bool" poly_minmax nil)
    (boxbetween? const-decl "bool" util nil)
    (IntervalEndpoints type-eq-decl nil util nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (Vars type-eq-decl nil util nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (lb_le_ub? const-decl "bool" minmax nil)
    (ge_realorder name-judgement "RealOrder" util nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (le_realorder name-judgement "RealOrder" util nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (lt_realorder name-judgement "RealOrder" util nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (interval_between? const-decl "bool" util nil)
    (below type-eq-decl nil naturalnumbers nil)
    (bounded_points_true? const-decl "bool" util nil)
    (ij!1 skolem-const-decl "nat" poly_minmax nil)
    (nvars skolem-const-decl "posnat" poly_minmax nil)
    (ABvv skolem-const-decl "[nat -> real]" poly_minmax nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (lt_below? const-decl "bool" util nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields 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 "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (forall_X_poly_between const-decl "bool" multi_polynomial nil)
    (sound_poly_inf? const-decl "bool" poly_minmax nil)
    (RealOrder type-eq-decl nil util nil)
    (realorder? const-decl "bool" util nil)
    (gt_realorder name-judgement "RealOrder" util nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (multipolynomial_minmax_TCC1 0
  (multipolynomial_minmax_TCC1-7 nil 3600444242
   ("" (skosimp*)
    ((""
      (case "FORALL (AXYZ:Vars): boxbetween?(nvars!1)(zeroes, ones, infintendpts!1, boundedpts_true)(AXYZ) IMPLIES EXISTS (cr: posreal):
                                                                                                                 cr *
                                                                                                                  multipoly_eval(multipoly_translate(mpoly!1,
                                                                                                                                                     polydegmono!1,
                                                                                                                                                     nvars!1,
                                                                                                                                                     boundedpts!1)
                                                                                                                                                    (Avars!1, Bvars!1),
                                                                                                                                 polydegmono!1, cf!1, nvars!1, terms!1)
                                                                                                                                (AXYZ)
                                                                                                                  =
                                                                                                                  multibs_eval(bspoly!1, polydegmono!1, cf!1, nvars!1, terms!1)(AXYZ)")
      (("1" (label "AXYZlem" -1)
        (("1" (hide "AXYZlem")
          (("1"
            (case "FORALL (ll:list[real]): length(ll)=nvars!1 AND (FORALL (ii:below(nvars!1)): (NOT (boundedpts!1(ii)`1 AND boundedpts!1(ii)`2)) IMPLIES nth(ll,ii)>0) IMPLIES (EXISTS (ccrr:posreal): (bounded_points_true?(nvars!1)(boundedpts!1) IMPLIES ccrr=1) AND
                                                                                                                                                                                               ( ccrr*multipoly_eval(multipoly_translate(mpoly!1,
                                                                                                                                                                                                                                         polydegmono!1,
                                                                                                                                                                                                                                         nvars!1,
                                                                                                                                                                                                                                         boundedpts!1)
                                                                                                                                                                                                                                        (Avars!1, Bvars!1),
                                                                                                                                                                                                                     polydegmono!1, cf!1, nvars!1, terms!1)
                                                                                                                                                                                                                    (list2array(0)(ll))
                                                                                                                                                                                                       =
                                                                                                                                                                                                       multipoly_eval(mpoly!1, polydegmono!1, cf!1, nvars!1, terms!1)
                                                                                                                                                                                                                     (list2array(0)
                                                                                                                                                                                                                                (denormalize_listreal(ll)
                                                                                                                                                                                                                                                     (Avars!1,
                                                                                                                                                                                                                                                      Bvars!1,
                                                                                                                                                                                                                                                      boundedpts!1)))))")
            (("1" (label "mlem" -1)
              (("1" (hide "mlem")
                (("1" (label "mpolytrname" -1)
                  (("1" (hide -1)
                    (("1" (label "bspolyname" -1)
                      (("1" (hide -1)
                        (("1" (label "infintendptsname" -1)
                          (("1" (hide -1)
                            (("1" (label "bsminmaxname" -1)
                              (("1"
                                (hide -1)
                                (("1"
                                  (typepred "bs_minmax!1")
                                  (("1"
                                    (expand "sound_poly?")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "sound?")
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (case
                                             "bounded_points_true?(nvars!1)(boundedpts!1)")
                                            (("1"
                                              (case
                                               "NOT FORALL (iijj:below(nvars!1)): infintendpts!1(iijj) = intendpts!1(iijj)")
                                              (("1"
                                                (hide-all-but (1 -))
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (expand
                                                     "bounded_points_true?")
                                                    (("1"
                                                      (inst - "iijj!1")
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (reveal
                                                           "infintendptsname")
                                                          (("1"
                                                            (replace
                                                             "infintendptsname"
                                                             +)
                                                            (("1"
                                                              (hide
                                                               "infintendptsname")
                                                              (("1"
                                                                (expand
                                                                 "interval_endpoints_inf_trans")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (label "infdef" -1)
                                                (("2"
                                                  (hide "infdef")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (hide 2)
                                                      (("2"
                                                        (expand
                                                         "sound_poly_fin?")
                                                        (("2"
                                                          (split +)
                                                          (("1"
                                                            (hide
                                                             (-3 -4))
                                                            (("1"
                                                              (expand
                                                               "forall_X_poly_between")
                                                              (("1"
                                                                (skosimp*)
                                                                (("1"
                                                                  (reveal
                                                                   "bspolyname")
                                                                  (("1"
                                                                    (replace
                                                                     "bspolyname")
                                                                    (("1"
                                                                      (hide
                                                                       "bspolyname")
                                                                      (("1"
                                                                        (lemma
                                                                         "bs_convert_poly_def")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "polydegmono!1"
                                                                           "cf!1"
                                                                           "mpolytr!1"
                                                                           "nvars!1"
                                                                           "polydegmono!1"
                                                                           "terms!1")
                                                                          (("1"
                                                                            (split
                                                                             -)
                                                                            (("1"
                                                                              (expand
                                                                               "forall_X_between")
                                                                              (("1"
                                                                                (replace
                                                                                 -1
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (hide
                                                                                   -1)
                                                                                  (("1"
                                                                                    (reveal
                                                                                     "mpolytrname")
                                                                                    (("1"
                                                                                      (replace
                                                                                       "mpolytrname")
                                                                                      (("1"
                                                                                        (hide
                                                                                         "mpolytrname")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "multipoly_translate_bounded_def")
                                                                                          (("1"
                                                                                            (inst?)
                                                                                            (("1"
                                                                                              (inst
                                                                                               -
                                                                                               "X!1"
                                                                                               "intendpts!1")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "normalize_lambda(nvars!1, X!1, boundedpts!1)
                                                                                                                                                                                                                                                                                                                                                                                                   (Avars!1, Bvars!1)")
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (split
                                                                                                       -4)
                                                                                                      (("1"
                                                                                                        (ground)
                                                                                                        nil
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (hide
                                                                                                         2)
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "normalize_lambda(nvars!1, X!1, boundedpts!1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (Avars!1, Bvars!1) = (LAMBDA (i: nat):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 IF i < nvars!1 THEN
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (X!1(i) - Avars!1(i)) /
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Bvars!1(i) - Avars!1(i))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ELSE 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ENDIF)")
                                                                                                          (("1"
                                                                                                            (replace
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (hide
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (hide
                                                                                                                 -1)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "boxbetween?")
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "interval_between?")
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "unitbox?")
                                                                                                                      (("1"
                                                                                                                        (skosimp*)
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "j!1")
                                                                                                                          (("1"
                                                                                                                            (expand
                                                                                                                             "bounded_points_true?")
                                                                                                                            (("1"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "j!1")
                                                                                                                              (("1"
                                                                                                                                (flatten)
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  (("1"
                                                                                                                                    (case
                                                                                                                                     "Avars!1(j!1) <= X!1(j!1) AND X!1(j!1) <= Bvars!1(j!1)")
                                                                                                                                    (("1"
                                                                                                                                      (flatten)
                                                                                                                                      (("1"
                                                                                                                                        (split
                                                                                                                                         +)
                                                                                                                                        (("1"
                                                                                                                                          (cross-mult
                                                                                                                                           1)
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (cross-mult
                                                                                                                                           1)
                                                                                                                                          (("2"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (ground)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               -1)
                                                                                                              (("2"
                                                                                                                (decompose-equality)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "bounded_points_true?")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "x!1")
                                                                                                                    (("1"
                                                                                                                      (flatten)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "normalize_lambda")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (expand
                                                                                                                             "boxbetween?")
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "interval_between?")
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "x!1")
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  (("1"
                                                                                                                                    (lift-if)
                                                                                                                                    (("1"
                                                                                                                                      (ground)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "normalize_lambda")
                                                                                                                        (("2"
                                                                                                                          (propax)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (skosimp*)
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "boxbetween?")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "interval_between?")
                                                                                                                      (("2"
                                                                                                                        (inst
                                                                                                                         -
                                                                                                                         "i!1")
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "bounded_points_true?")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "i!1")
                                                                                                                            (("2"
                                                                                                                              (flatten)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("3"
                                                                                                            (hide
                                                                                                             (-1
                                                                                                              2))
                                                                                                            (("3"
                                                                                                              (skosimp*)
                                                                                                              (("3"
                                                                                                                (expand
                                                                                                                 "lt_below?")
                                                                                                                (("3"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "i!1")
                                                                                                                  (("3"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (grind)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             (-2 -4))
                                                            (("2"
                                                              (expand
                                                               "box_poly_lb?")
                                                              (("2"
                                                                (expand
                                                                 "unit_box_lb?")
                                                                (("2"
                                                                  (expand
                                                                   "interval_between?")
                                                                  (("2"
                                                                    (flatten)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (case
                                                                         "cons?(bs_minmax!1`lb_var)")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (case
                                                                               "NOT length(denormalize_listreal(bs_minmax!1`lb_var)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (Avars!1, Bvars!1, boundedpts!1))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               = nvars!1")
                                                                              (("1"
                                                                                (hide
                                                                                 2)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (split
                                                                                   +)
                                                                                  (("1"
                                                                                    (skosimp*)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "bounded_points_true?")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "iup!1")
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (inst
                                                                                               -
                                                                                               "iup!1")
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "lt_below?")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "iup!1")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "denormalize_listreal")
                                                                                                        (("1"
                                                                                                          (typepred
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.47 Sekunden  (vorverarbeitet)  ¤





Download des
Quellennavigators
Download des
sprechenden Kalenders

in der Quellcodebibliothek suchen




Haftungshinweis

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


Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.


Bot Zugriff