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

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: branch_and_bound.prf   Sprache: Lisp

Original von: PVS©

(branch_and_bound
 (emptyDirVars_TCC1 0
  (emptyDirVars_TCC1-1 nil 3546959448 ("" (grind) nil nil)
   ((length def-decl "nat" list_props nil)) nil))
 (length_empty 0
  (length_empty-1 nil 3546943024 ("" (grind) nil nil)
   ((emptyDirVars const-decl "DirVarStack" branch_and_bound nil))
   shostak))
 (topDirVar_TCC1 0
  (topDirVar_TCC1-2 nil 3546959497
   ("" (skeep :preds? t)
    (("" (typepred "stack(dirvars)") (("" (grind) nil nil)) nil)) nil)
   ((nonempty? const-decl "bool" branch_and_bound nil)
    (DirVarStack type-eq-decl nil branch_and_bound nil)
    (stack type-eq-decl nil stack nil)
    (length def-decl "nat" list_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals 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)
    (list type-decl nil list_adt nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (top const-decl "Maybe[T]" stack nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil)
  (topDirVar_TCC1-1 nil 3546959448 ("" (subtype-tcc) nil nilnil nil))
 (pushDirVar_TCC1 0
  (pushDirVar_TCC1-2 nil 3546959526
   ("" (skeep)
    (("" (typepred "stack(dirvars)") (("" (grind) nil nil)) nil)) nil)
   ((DirVarStack type-eq-decl nil branch_and_bound nil)
    (stack type-eq-decl nil stack nil)
    (length def-decl "nat" list_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals 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)
    (list type-decl nil list_adt nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (push const-decl "stack" stack nil))
   nil)
  (pushDirVar_TCC1-1 nil 3546959448 ("" (subtype-tcc) nil nilnil
   nil))
 (pushDirVar_TCC2 0
  (pushDirVar_TCC2-1 nil 3546959448 ("" (grind) nil nil)
   ((real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (push const-decl "stack" stack nil)
    (nonempty? const-decl "bool" branch_and_bound nil))
   nil))
 (popDirVar_TCC1 0
  (popDirVar_TCC1-1 nil 3546959448 ("" (subtype-tcc) nil nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (popDirVar_TCC2 0
  (popDirVar_TCC2-2 nil 3546959629
   ("" (skeep)
    (("" (typepred "stack(dirvars)")
      (("" (expand "length" -1) (("" (grind) nil nil)) nil)) nil))
    nil)
   ((DirVarStack type-eq-decl nil branch_and_bound nil)
    (stack type-eq-decl nil stack nil)
    (length def-decl "nat" list_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals 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)
    (list type-decl nil list_adt nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (pop const-decl "stack" stack nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (popDirVar_TCC2-1 nil 3546959448 ("" (subtype-tcc) nil nilnil nil))
 (branch_and_bound_TCC1 0
  (branch_and_bound_TCC1-1 nil 3521295757 ("" (subtype-tcc) nil nil)
   nil nil))
 (branch_and_bound_TCC2 0
  (branch_and_bound_TCC2-1 nil 3521298539 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (<= const-decl "bool" reals nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (list type-decl nil list_adt nil)
    (stack type-eq-decl nil stack nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (length def-decl "nat" list_props nil)
    (DirVarStack type-eq-decl nil branch_and_bound nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (branch_and_bound_TCC3 0
  (branch_and_bound_TCC3-1 nil 3521298539
   ("" (termination-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (<= const-decl "bool" reals nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (list type-decl nil list_adt nil)
    (stack type-eq-decl nil stack nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (length def-decl "nat" list_props nil)
    (DirVarStack type-eq-decl nil branch_and_bound nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (push const-decl "stack" stack nil)
    (pushDirVar const-decl "(nonempty?)" branch_and_bound nil))
   nil))
 (branch_and_bound_TCC4 0
  (branch_and_bound_TCC4-1 nil 3546942913 ("" (subtype-tcc) nil nil)
   ((push const-decl "stack" stack nil)
    (pushDirVar const-decl "(nonempty?)" branch_and_bound nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (branch_and_bound_TCC5 0
  (branch_and_bound_TCC5-1 nil 3546942913
   ("" (termination-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (<= const-decl "bool" reals nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (list type-decl nil list_adt nil)
    (stack type-eq-decl nil stack nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (length def-decl "nat" list_props nil)
    (DirVarStack type-eq-decl nil branch_and_bound nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (push const-decl "stack" stack nil)
    (pushDirVar const-decl "(nonempty?)" branch_and_bound nil))
   nil))
 (branch_and_bound_TCC6 0
  (branch_and_bound_TCC6-1 nil 3547374379
   ("" (termination-tcc) nil nil)
   ((push const-decl "stack" stack nil)
    (pushDirVar const-decl "(nonempty?)" branch_and_bound nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (branch_and_bound_sound 0
  (branch_and_bound_sound-2 nil 3546959685
   ("" (skeep)
    ((""
      (name-replace "PP" "(simplify, evaluate, branch, subdivide,
                                                            denorm, combine, prune, le, ge, select,accumulate,
                                                            maxdepth)"
       :hide? nil)
      (("" (decompose-equality -1)
        ((""
          (case " FORALL (obj, dom, acc, dirvars,(depth:nat)):
                                                                                                   depth = maxdepth-length(dirvars) IMPLIES
                                                                                                    LET bandb = branch_and_bound(PP)(obj, dom, acc, dirvars)
                                                                                                      IN sound(dom, obj, bandb`ans)")
          (("1" (skeep)
            (("1" (inst? -)
              (("1" (inst - "maxdepth-length(dirvars)")
                (("1" (assertnil nil)) nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (induct "depth")
              (("1" (assertnil nil)
               ("2" (skeep)
                (("2" (move-terms -1 r 2)
                  (("2" (assert)
                    (("2" (expand "branch_and_bound")
                      (("2" (expand "accomodates?")
                        (("2" (inst - "dom" "obj")
                          (("2" (expand "evaluate_simplify?")
                            (("2" (inst - "dom" "obj")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("3" (skolem 1 "depth")
                (("3" (flatten)
                  (("3" (skeep)
                    (("3"
                      (name-replace "bandb"
                       "branch_and_bound(PP)(obj, dom, acc,dirvars)"
                       :hide? nil)
                      (("3"
                        (expand "branch_and_bound" -1 :assert? none)
                        (("3"
                          (label "PP"
                                 (-4
                                  -5
                                  -6
                                  -7
                                  -8
                                  -9
                                  -10
                                  -11
                                  -12
                                  -13
                                  -14
                                  -15))
                          (("3" (replaces "PP" :hide? nil :dir rl)
                            (("3" (skoletin* -1)
                              (("3"
                                (case-replace
                                 "length(dirvars) = maxdepth OR le(thisans) OR thisout`exit OR prune(dirvars, newacc1, thisans)")
                                (("1"
                                  (hide (-1 -7))
                                  (("1"
                                    (replaces (-2 -1))
                                    (("1"
                                      (assert)
                                      (("1"
                                        (replaces (-2 -3))
                                        (("1"
                                          (expand "accomodates?")
                                          (("1"
                                            (inst - "dom" "obj")
                                            (("1"
                                              (expand
                                               "evaluate_simplify?")
                                              (("1"
                                                (inst - "dom" "obj")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (flatten)
                                  (("2"
                                    (replace 1)
                                    (("2"
                                      (replace 2)
                                      (("2"
                                        (replace 3)
                                        (("2"
                                          (replace 4)
                                          (("2"
                                            (skoletin -1 :postfix "p")
                                            (("2"
                                              (skoletin* -1)
                                              (("2"
                                                (case "firstout`exit")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (replaces
                                                     -2
                                                     :dir
                                                     rl)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "subdiv_presound?")
                                                        (("1"
                                                          (inst? -32)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (hide 5)
                                                              (("1"
                                                                (split
                                                                 5)
                                                                (("1"
                                                                  (expand
                                                                   "accomodates?")
                                                                  (("1"
                                                                    (inst
                                                                     -29
                                                                     "dom"
                                                                     "obj")
                                                                    (("1"
                                                                      (expand
                                                                       "evaluate_simplify?")
                                                                      (("1"
                                                                        (inst
                                                                         -31
                                                                         "dom"
                                                                         "obj")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (case
                                                                   "sound(dom1,sp1,branch_and_bound(PP)(sp1,dom1,newacc1,pushDirVar((dirp, vp), dirvars))`ans)")
                                                                  (("1"
                                                                    (expand
                                                                     "sound_dir")
                                                                    (("1"
                                                                      (split
                                                                       1)
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "branch_simplify?")
                                                                            (("1"
                                                                              (inst?
                                                                               -35)
                                                                              (("1"
                                                                                (expand
                                                                                 "simplify_invariant?"
                                                                                 -)
                                                                                (("1"
                                                                                  (inst?
                                                                                   -32)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (expand
                                                                             "branch_simplify?")
                                                                            (("2"
                                                                              (inst?
                                                                               -34)
                                                                              (("2"
                                                                                (expand
                                                                                 "simplify_invariant?"
                                                                                 -)
                                                                                (("2"
                                                                                  (inst?
                                                                                   -31)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (inst?
                                                                       -)
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (expand
                                                                           "pushDirVar"
                                                                           6)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("3"
                                                                    (expand
                                                                     "pushDirVar"
                                                                     1)
                                                                    (("3"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (replace 1)
                                                  (("2"
                                                    (skoletin* -)
                                                    (("2"
                                                      (replaces
                                                       -1
                                                       :dir
                                                       rl)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case
                                                           "FORALL(accl,accr:AccType):sound(dom,obj,combine(vp,
                                                                                                                                                                                                                                                                  denorm(left(vp),
                                                                                                                                                                                                                                                                         branch_and_bound(PP)
                                                                                                                                                                                                                                                                                         (funsplit`1,domsplit`1,accl,pushDirVar(left(vp),dirvars))`ans),
                                                                                                                                                                                                                                                                  denorm(right(vp),
                                                                                                                                                                                                                                                                         branch_and_bound(PP)
                                                                                                                                                                                                                                                                                         (funsplit`2,domsplit`2,accr,pushDirVar(right(vp),dirvars))`ans)))")
                                                          (("1"
                                                            (case
                                                             "dirp")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "newacc1"
                                                                 "newacc2")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "newacc2"
                                                                 "newacc1")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 7)
                                                            (("2"
                                                              (skeep)
                                                              (("2"
                                                                (expand
                                                                 "subdiv_sound?")
                                                                (("2"
                                                                  (inst?
                                                                   -36)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (hide
                                                                       1)
                                                                      (("2"
                                                                        (expand
                                                                         "branch_simplify?")
                                                                        (("2"
                                                                          (inst
                                                                           -36
                                                                           "vp"
                                                                           "obj")
                                                                          (("2"
                                                                            (replaces
                                                                             (-10
                                                                              -11
                                                                              -17
                                                                              -36))
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (split
                                                                                 6)
                                                                                (("1"
                                                                                  (expand
                                                                                   "simplify_invariant?"
                                                                                   -30)
                                                                                  (("1"
                                                                                    (inst?
                                                                                     -30)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (hide
                                                                                         1)
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "simplify(branch(vp, obj)`1)"
                                                                                           "subdivide(vp, dom)`1"
                                                                                           "accl"
                                                                                           "pushDirVar((TRUE, vp), dirvars)")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "pushDirVar"
                                                                                               6)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (expand
                                                                                   "simplify_invariant?"
                                                                                   -30)
                                                                                  (("2"
                                                                                    (inst?
                                                                                     -30)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (hide
                                                                                         1)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "simplify(branch(vp, obj)`2)"
                                                                                           "subdivide(vp, dom)`2"
                                                                                           "accr"
                                                                                           "pushDirVar((FALSE, vp), dirvars)")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "pushDirVar"
                                                                                               6)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("3"
                                                            (expand
                                                             "pushDirVar"
                                                             1)
                                                            (("3"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("4"
                                                            (expand
                                                             "pushDirVar"
                                                             1)
                                                            (("4"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("4" (hide 2)
                (("4" (skosimp*) (("4" (assertnil nil)) nil)) nil))
              nil))
            nil)
           ("3" (hide 2)
            (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((ObjType formal-type-decl nil branch_and_bound nil)
    (Simplifier type-eq-decl nil branch_and_bound nil)
    (DomainType formal-type-decl nil branch_and_bound nil)
    (AnsType formal-type-decl nil branch_and_bound nil)
    (Evaluator type-eq-decl nil branch_and_bound nil)
    (VarType formal-type-decl nil branch_and_bound nil)
    (Brancher type-eq-decl nil branch_and_bound nil)
    (SubdivDomain type-eq-decl nil branch_and_bound nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (DirVar type-eq-decl nil branch_and_bound nil)
    (DenormAns type-eq-decl nil branch_and_bound nil)
    (Combiner type-eq-decl nil branch_and_bound nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (list type-decl nil list_adt nil)
    (stack type-eq-decl nil stack nil)
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (DirVarStack type-eq-decl nil branch_and_bound nil)
    (ExitPred type-eq-decl nil branch_and_bound nil)
    (LocalExitPred type-eq-decl nil branch_and_bound nil)
    (DirVarSelector type-eq-decl nil branch_and_bound nil)
    (Accumulator type-eq-decl nil branch_and_bound nil)
    (branch_and_bound def-decl "Output" branch_and_bound nil)
    (<= const-decl "bool" reals nil)
    (SoundPred type-eq-decl nil branch_and_bound nil)
    (Output type-eq-decl nil branch_and_bound nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AccType type-eq-decl nil branch_and_bound nil)
    (Maybe type-decl nil Maybe nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (dirvars skolem-const-decl "DirVarStack" branch_and_bound nil)
    (maxdepth skolem-const-decl "nat" branch_and_bound nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (PP skolem-const-decl
     "[Simplifier, Evaluator, Brancher, SubdivDomain, DenormAns, Combiner,
 ExitPred, LocalExitPred, ExitPred, DirVarSelector, Accumulator, nat]"
     branch_and_bound nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (evaluate_simplify? const-decl "bool" branch_and_bound nil)
    (accomodates? const-decl "bool" branch_and_bound nil)
    (nonneg_rat_max application-judgement
     "{s: nonneg_rat | s >= q AND s >= r}" real_defs nil)
    (nat_max application-judgement "{k: nat | i <= k AND j <= k}"
     real_defs nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (TRUE const-decl "bool" booleans nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (bijective? const-decl "bool" functions nil)
    (Some adt-constructor-decl "[T -> (some?)]" Maybe nil)
    (pushDirVar const-decl "(nonempty?)" branch_and_bound nil)
    (nonempty? const-decl "bool" branch_and_bound nil)
    (naturalnumber type-eq-decl nil naturalnumbers nil)
    (val adt-accessor-decl "[(some?) -> T]" Maybe nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (some? adt-recognizer-decl "[Maybe -> boolean]" Maybe nil)
    (none? adt-recognizer-decl "[Maybe -> boolean]" Maybe nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (FALSE const-decl "bool" booleans nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (subdiv_sound? const-decl "bool" branch_and_bound nil)
    (push const-decl "stack" stack nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (simplify_invariant? const-decl "bool" branch_and_bound nil)
    (branch_simplify? const-decl "bool" branch_and_bound nil)
    (sound_dir const-decl "bool" branch_and_bound nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (subdiv_presound? const-decl "bool" branch_and_bound nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil))
   nil)
  (branch_and_bound_sound-1 nil 3546361375
   ("" (skeep)
    ((""
      (name-replace "PP" "(simplify, evaluate, branch, subdivide,
                                                  denorm, combine, prune, le, ge, select,accumulate,
                                                  maxdepth)" :hide?
       nil)
      (("" (decompose-equality -1)
        ((""
          (case " FORALL (obj, dom, acc, dirvars,(depth:nat)):
                                                                depth = maxdepth-length(dirvars) IMPLIES
                                                                 LET bandb = branch_and_bound(PP)(obj, dom, acc, dirvars)
                                                                   IN sound(dom, obj, bandb`ans)")
          (("1" (skeep)
            (("1" (inst? -)
              (("1" (inst - "maxdepth-length(dirvars)")
                (("1" (assertnil nil)) nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (induct "depth")
              (("1" (assertnil nil)
               ("2" (skeep)
                (("2" (move-terms -1 r 2)
                  (("2" (assert)
                    (("2" (expand "branch_and_bound")
                      (("2" (expand "accomodates?")
                        (("2" (inst - "dom" "obj" "dirvars")
                          (("2" (expand "evaluate_simplify?")
                            (("2" (inst - "dom" "obj" "dirvars")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("3" (skolem 1 "depth")
                (("3" (flatten)
                  (("3" (skeep)
                    (("3"
                      (name-replace "bandb"
                       "branch_and_bound(PP)(obj, dom, acc,dirvars)"
                       :hide? nil)
                      (("3"
                        (expand "branch_and_bound" -1 :assert? none)
                        (("3"
                          (label "PP"
                                 (-4
                                  -5
                                  -6
                                  -7
                                  -8
                                  -9
                                  -10
                                  -11
                                  -12
                                  -13
                                  -14
                                  -15))
                          (("3" (replaces "PP" :hide? nil :dir rl)
                            (("3" (skoletin* -1)
                              (("3"
                                (case-replace
                                 "length(dirvars) = maxdepth OR
                                                                                                                                                                                                                          le(thisans) OR
                                                                                                                                                                                                                           thisout`exit OR prune(dirvars, acc, thisans)")
                                (("1"
                                  (hide (-1 -6))
                                  (("1"
                                    (replaces (-2 -1))
                                    (("1"
                                      (assert)
                                      (("1"
                                        (replaces (-1 -2))
                                        (("1"
                                          (expand "accomodates?")
                                          (("1"
                                            (inst
                                             -
                                             "dom"
                                             "obj"
                                             "dirvars")
                                            (("1"
                                              (expand
                                               "evaluate_simplify?")
                                              (("1"
                                                (inst
                                                 -
                                                 "dom"
                                                 "obj"
                                                 "dirvars")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (flatten)
                                  (("2"
                                    (replace 1)
                                    (("2"
                                      (replace 2)
                                      (("2"
                                        (replace 3)
                                        (("2"
                                          (replace 4)
                                          (("2"
                                            (skoletin -2 :postfix "p")
                                            (("2"
                                              (skoletin* -3)
                                              (("2"
                                                (case "firstout`exit")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (replaces
                                                     -3
                                                     :dir
                                                     rl)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "subdiv_presound?")
                                                        (("1"
                                                          (inst? -32)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (hide 5)
                                                              (("1"
                                                                (split
                                                                 5)
                                                                (("1"
                                                                  (expand
                                                                   "accomodates?")
                                                                  (("1"
                                                                    (inst
                                                                     -29
                                                                     "dom"
                                                                     "obj"
                                                                     "dirvars")
                                                                    (("1"
                                                                      (expand
                                                                       "evaluate_simplify?")
                                                                      (("1"
                                                                        (inst
                                                                         -31
                                                                         "dom"
                                                                         "obj"
                                                                         "dirvars")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (case
                                                                   "sound(dom1,sp1,branch_and_bound(PP)(sp1,dom1,newacc1,push((dirp, vp), dirvars))`ans)")
                                                                  (("1"
                                                                    (expand
                                                                     "sound_dir")
                                                                    (("1"
                                                                      (split
                                                                       1)
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "branch_simplify?")
                                                                            (("1"
                                                                              (inst?
                                                                               -35)
                                                                              (("1"
                                                                                (expand
                                                                                 "simplify_invariant?"
                                                                                 -)
                                                                                (("1"
                                                                                  (inst?
                                                                                   -32)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (expand
                                                                             "branch_simplify?")
                                                                            (("2"
                                                                              (inst?
                                                                               -34)
                                                                              (("2"
                                                                                (expand
                                                                                 "simplify_invariant?"
                                                                                 -)
                                                                                (("2"
                                                                                  (inst?
                                                                                   -31)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.36 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