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


Quelle  sigma_nat.prf

  Sprache: Lisp
 

(sigma_nat
 (IMP_sigma_TCC1 0
  (IMP_sigma_TCC1-1 nil 3620720752 ("" (assuming-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)
    (integer nonempty-type-from-decl nil 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))
   nil))
 (int_is_T_high 0
  (int_is_T_high-1 nil 3352138082
   ("" (skosimp*)
    (("" (inst-cp + 0)
      (("" (inst + "x!1")
        (("1" (assertnil nil) ("2" (assertnil nil)) nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (nat_is_T_low 0
  (nat_is_T_low-1 nil 3352138082 ("" (judgement-tcc) nil nilnil nil))
 (sigma_shift_TCC1 0
  (sigma_shift_TCC1-1 nil 3403006081
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_shift 0
  (sigma_shift-1 nil 3308675684
   ("" (skosimp*) (("" (rewrite "sigma_shift_T"nil nil)) nil)
   ((nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sigma_shift_T formula-decl nil sigma nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   nil))
 (sigma_shift_neg_TCC1 0
  (sigma_shift_neg_TCC1-1 nil 3308675684
   ("" (skosimp*) (("" (inst + 0) (("" (assertnil nil)) nil)) nil)
   nil nil))
 (sigma_shift_neg_TCC2 0
  (sigma_shift_neg_TCC2-1 nil 3352138082 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_shift_neg_TCC3 0
  (sigma_shift_neg_TCC3-1 nil 3403006081
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props 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))
 (sigma_shift_neg 0
  (sigma_shift_neg-1 nil 3308675684
   ("" (skosimp*)
    (("" (lemma "sigma_shift_T2")
      (("" (inst?)
        (("" (inst - "high!1" "low!1" "0 - m!1")
          (("" (assert)
            (("" (prop)
              (("1" (replace -1 :hide? t)
                (("1" (rewrite "sigma_eq")
                  (("1" (skosimp*) (("1" (assertnil nil)) nil)) nil))
                nil)
               ("2" (case "high!1<low!1")
                (("1" (expand "sigma") (("1" (assertnil nil)) nil)
                 ("2" (assertnil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (sigma_shift_T2 formula-decl nil sigma nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma_eq formula-decl nil sigma nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (sigma def-decl "real" sigma nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   nil))
 (sigma_shift_ng2 0
  (sigma_shift_ng2-1 nil 3308675684
   ("" (skosimp*)
    (("" (lemma "sigma_shift_T2")
      (("" (inst?)
        (("" (inst - "high!1" "low!1" "0-m!1")
          (("" (assert)
            (("" (prop)
              (("1" (replace -1 :hide? t)
                (("1" (rewrite "sigma_eq")
                  (("1" (expand "~")
                    (("1" (assert)
                      (("1" (skosimp*)
                        (("1" (assert)
                          (("1" (lift-if) (("1" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (case "high!1<low!1")
                (("1" (expand "sigma") (("1" (assertnil nil)) nil)
                 ("2" (assertnil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (sigma_shift_T2 formula-decl nil sigma nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (~ const-decl "nat" naturalnumbers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma_eq formula-decl nil sigma nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (sigma def-decl "real" sigma nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   nil))
 (sigma_shift_i_TCC1 0
  (sigma_shift_i_TCC1-1 nil 3410183793 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_plus_int_is_int application-judgement "int" 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))
   nil))
 (sigma_shift_i_TCC2 0
  (sigma_shift_i_TCC2-1 nil 3410183793 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_plus_int_is_int application-judgement "int" 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))
   nil))
 (sigma_shift_i_TCC3 0
  (sigma_shift_i_TCC3-1 nil 3410183793 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (sigma_shift_i 0
  (sigma_shift_i-1 nil 3410183811
   ("" (skosimp*)
    (("" (rewrite "sigma_shift_T2")
      (("1" (rewrite "sigma_restrict_eq")
        (("1" (hide 2)
          (("1" (expand "restrict") (("1" (propax) nil nil)) nil)) nil)
         ("2" (skosimp*) (("2" (assertnil nil)) nil))
        nil)
       ("2" (case "low!1 <= high!1")
        (("1" (assertnil nil) ("2" (grind) nil nil)) nil))
      nil))
    nil)
   ((sigma_shift_T2 formula-decl nil sigma nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (< const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (sigma def-decl "real" sigma nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (sigma_shift_to_zero_TCC1 0
  (sigma_shift_to_zero_TCC1-1 nil 3594380184 ("" (subtype-tcc) nil nil)
   nil nil))
 (sigma_shift_to_zero_TCC2 0
  (sigma_shift_to_zero_TCC2-1 nil 3594380184 ("" (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)
    (int_minus_int_is_int application-judgement "int" 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))
   nil))
 (sigma_shift_to_zero 0
  (sigma_shift_to_zero-1 nil 3594380186
   ("" (induct "n")
    (("1" (skeep)
      (("1" (assert)
        (("1" (rewrite "sigma_restrict_eq")
          (("1" (decompose-equality 1)
            (("1" (expand "restrict") (("1" (propax) nil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skeep)
      (("2" (induct "m")
        (("1" (assertnil nil)
         ("2" (skolem 1 "kk")
          (("2" (flatten)
            (("2" (assert)
              (("2" (skeep)
                (("2" (assert)
                  (("2" (inst - "F")
                    (("2" (case "NOT 1+j <=kk")
                      (("1" (case "NOT kk=j")
                        (("1" (assertnil nil)
                         ("2" (replace -1)
                          (("2" (assert)
                            (("2" (expand "sigma" +)
                              (("2"
                                (expand "sigma" +)
                                (("2" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (expand "sigma" 1 1)
                          (("2" (replace -2 +)
                            (("2" (assert)
                              (("2"
                                (expand "sigma" 1 2)
                                (("2" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (hide 2) (("3" (skosimp*) (("3" (assertnil nil)) nil))
          nil))
        nil))
      nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil))
    nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (j skolem-const-decl "nat" sigma_nat nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sigma def-decl "real" sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak))
 (sigma_first_ge 0
  (sigma_first_ge-1 nil 3308675684
   ("" (skosimp*) (("" (rewrite "sigma_first"nil nil)) nil)
   ((sigma_first formula-decl nil sigma nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   nil))
 (sigma_split_ge_TCC1 0
  (sigma_split_ge_TCC1-1 nil 3352162210
   ("" (skosimp*) (("" (inst + 0) (("" (assertnil nil)) nil)) nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props 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))
 (sigma_split_ge_TCC2 0
  (sigma_split_ge_TCC2-1 nil 3403006081
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_split_ge 0
  (sigma_split_ge-1 nil 3308675684
   ("" (skosimp*) (("" (rewrite "sigma_split"nil nil)) nil)
   ((sigma_split formula-decl nil sigma nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   nil))
 (sigma_reverse_TCC1 0
  (sigma_reverse_TCC1-1 nil 3481027293 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   nil))
 (sigma_reverse 0
  (sigma_reverse-1 nil 3481027293
   (""
    (case "FORALL (F: [nat -> real], k: nat, low: nat):
        sigma(low, low+k, F) =
         sigma(low, low+k,
               LAMBDA (n: nat):
                 IF n > k + 2*low THEN 0 ELSE F(2*low+k - n) ENDIF)")
    (("1" (skeep)
      (("1" (case "high < low")
        (("1" (expand "sigma" +) (("1" (assertnil nil)) nil)
         ("2" (inst - "F" "high-low" "low")
          (("1" (assertnil nil) ("2" (assertnil nil)) nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "k")
        (("1" (skeep)
          (("1" (expand "sigma")
            (("1" (expand "sigma") (("1" (propax) nil nil)) nil)) nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (inst - "F" "low")
              (("2" (expand "sigma" 1 1)
                (("2" (lemma "sigma_split")
                  (("2"
                    (inst - "LAMBDA (n: nat):
               IF n > 1 + j + 2 * low THEN 0
               ELSE F(1 - n + j + 2 * low)
               ENDIF" "1+j+low" "low" "low")
                    (("1" (assert)
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (expand "sigma" + 3)
                            (("1" (expand "sigma" + 3)
                              (("1"
                                (lemma "sigma_shift")
                                (("1"
                                  (inst
                                   -
                                   "LAMBDA (n: nat):
               IF n > 1 + j + 2 * low THEN 0
               ELSE F(1 - n + j + 2 * low)
               ENDIF"
                                   "low+j"
                                   "low"
                                   "1")
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (rewrite
                                               "sigma_restrict_eq")
                                              (("1"
                                                (hide 2)
                                                (("1"
                                                  (decompose-equality)
                                                  (("1"
                                                    (expand "restrict")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (skosimp*)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("3"
                                                (skosimp*)
                                                (("3"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (skosimp*)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (skosimp*) (("2" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (skosimp*) (("3" (assertnil nil)) nil))
        nil))
      nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil))
    nil)
   ((sigma_split formula-decl nil sigma nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (sigma_shift formula-decl nil sigma_nat nil)
    (low skolem-const-decl "nat" sigma_nat nil)
    (j skolem-const-decl "nat" sigma_nat nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (high skolem-const-decl "int" sigma_nat nil)
    (low skolem-const-decl "nat" sigma_nat nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil) (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (sigma def-decl "real" sigma nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (> const-decl "bool" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   shostak))
 (sigma_product_TCC1 0
  (sigma_product_TCC1-1 nil 3541327761 ("" (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)
    (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)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_product_TCC2 0
  (sigma_product_TCC2-1 nil 3541327761 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_product 0
  (sigma_product-1 nil 3541327793
   (""
    (case "FORALL (F, G: [nat -> real], high1, high2: int, low1, low2,rn: nat):
                      rn = high1-low1 IMPLIES
                      sigma(low1, high1, F) * sigma(low2, high2, G) =
                       sigma(low1 + low2, high1 + high2,
                             LAMBDA (k: nat):
                               sigma(low1, high1,
                                     LAMBDA (i: nat):
                                       IF (i < k - high2 OR i > k - low2) THEN 0
                                       ELSE F(i) * G(k - i)
                                       ENDIF))")
    (("1" (skeep)
      (("1" (case "high1 >= low1")
        (("1" (inst?)
          (("1" (inst - "high1-low1") (("1" (assertnil nil)) nil))
          nil)
         ("2" (hide -)
          (("2" (expand "sigma" + 1)
            (("2" (assert)
              (("2" (assert)
                (("2" (case "FORALL (eg1:real): 0*eg1 = 0")
                  (("1" (rewrite -1)
                    (("1" (hide -1)
                      (("1" (rewrite "sigma_restrict_eq_0")
                        (("1" (hide 3)
                          (("1" (skosimp*)
                            (("1" (expand "sigma")
                              (("1" (propax) nil nil)) nil))
                            nil))
                          nil)
                         ("2" (hide 3) (("2" (grind) nil nil)) nil)
                         ("3" (hide 3)
                          (("3" (flatten) (("3" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide 3) (("2" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "rn")
        (("1" (skeep)
          (("1" (case "high1 = low1")
            (("1" (replace -1)
              (("1" (assert)
                (("1" (expand "sigma" + 1)
                  (("1" (expand "sigma" + 2)
                    (("1" (rewrite "sigma_scal" :dir rl)
                      (("1" (expand "sigma" + 3)
                        (("1" (expand "sigma" + 3)
                          (("1" (assert)
                            (("1" (lemma "sigma_shift")
                              (("1"
                                (invoke (inst - "%1" _ _ _) (! 1 2 3))
                                (("1"
                                  (inst - "high2" "low2" "low1")
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (rewrite "sigma_eq")
                                        nil
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (skosimp*)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (case "high1 >= low1 AND high2 >= low2")
              (("1" (flatten)
                (("1" (inst - "F" "G" "high1-1" "high2" "low1" "low2")
                  (("1" (assert)
                    (("1" (expand "sigma" + 1)
                      (("1" (replace -3)
                        (("1" (hide -3)
                          (("1" (expand "sigma" + 5)
                            (("1" (lemma "sigma_sum")
                              (("1"
                                (inst
                                 -
                                 "LAMBDA (k: nat):
               IF (high1 < k - high2 OR high1 > k - low2) THEN 0
               ELSE F(high1) * G(k - high1)
               ENDIF"
                                 "LAMBDA (k: nat):
                sigma(low1, high1 - 1,
                      LAMBDA (i: nat):
                        IF (i < k - high2 OR i > k - low2) THEN 0
                        ELSE F(i) * G(k - i)
                        ENDIF)"
                                 "high1+high2"
                                 "low1+low2")
                                (("1"
                                  (replace -1 :dir rl)
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (case
                                       "FORALL (a1,a2,b1,b2:real): a1=b1 AND a2=b2 IMPLIES a1+a2=b2+b1")
                                      (("1"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide 2)
                                            (("1"
                                              (split +)
                                              (("1"
                                                (expand "sigma" + 3)
                                                (("1"
                                                  (lemma
                                                   "sigma_restrict_eq_0")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (grind)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (lemma "sigma_split")
                                                (("2"
                                                  (inst
                                                   -
                                                   "LAMBDA (k: nat):
               IF (high1 < k - high2 OR high1 > k - low2) THEN 0
               ELSE F(high1) * G(k - high1)
               ENDIF"
                                                   "high1+high2"
                                                   "low1+low2"
                                                   "high1+low2-1")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (replace -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (case
                                                           "NOT sigma(low1 + low2, high1 - 1 + low2,
              LAMBDA (k: nat):
                IF (high1 < k - high2 OR high1 > k - low2) THEN 0
                ELSE F(high1) * G(k - high1)
                ENDIF)
 = 0")
                                                          (("1"
                                                            (hide 2)
                                                            (("1"
                                                              (rewrite
                                                               "sigma_restrict_eq_0")
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (replaces
                                                             -1)
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (lemma
                                                                 "sigma_shift")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "LAMBDA (k: nat):
               IF (high1 < k - high2 OR high1 > k - low2) THEN 0
               ELSE F(high1) * G(k - high1)
               ENDIF"
                                                                   "high2"
                                                                   "low2"
                                                                   "high1")
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (rewrite
                                                                         "sigma_scal"
                                                                         :dir
                                                                         rl)
                                                                        (("1"
                                                                          (rewrite
                                                                           "sigma_eq")
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (skosimp*)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("3"
                                                            (hide 2)
                                                            (("3"
                                                              (skosimp*)
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2)
                                          (("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (hide 2)
                                          (("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide 2)
                                        (("2"
                                          (skosimp*)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (skosimp*)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil)
                                 ("3"
                                  (hide 2)
                                  (("3"
                                    (skosimp*)
                                    (("3" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -1)
                (("2" (ground)
                  (("2" (expand "sigma" + 2)
                    (("2" (rewrite "sigma_restrict_eq_0")
                      (("1" (hide 3)
                        (("1" (skosimp*)
                          (("1" (rewrite "sigma_restrict_eq_0")
                            (("1" (hide 2)
                              (("1"
                                (skosimp*)
                                (("1"
                                  (assert)
                                  (("1"
                                    (lift-if)
                                    (("1" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide 2)
                              (("2"
                                (skosimp*)
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 3)
                        (("2" (skosimp*) (("2" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (hide 2) (("3" (skosimp*) (("3" (assertnil nil)) nil))
          nil)
         ("4" (hide 2) (("4" (skosimp*) (("4" (assertnil nil)) nil))
          nil)
         ("5" (hide 2) (("5" (skosimp*) (("5" (assertnil nil)) nil))
          nil)
         ("6" (hide 2) (("6" (skosimp*) (("6" (assertnil nil)) nil))
          nil))
        nil))
      nil)
     ("3" (hide 2) (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil)
     ("4" (hide 2) (("4" (skosimp*) (("4" (assertnil nil)) nil)) nil)
     ("5" (hide 2) (("5" (skosimp*) (("5" (assertnil nil)) nil)) nil)
     ("6" (hide 2) (("6" (skosimp*) (("6" (assertnil nil)) nil))
      nil))
    nil)
   ((sigma_sum formula-decl nil sigma nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma_split formula-decl nil sigma nil)
    (low2 skolem-const-decl "nat" sigma_nat nil)
    (high2 skolem-const-decl "int" sigma_nat nil)
    (high1 skolem-const-decl "int" sigma_nat nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (subrange type-eq-decl nil integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (sigma_scal formula-decl nil sigma nil)
    (sigma_shift formula-decl nil sigma_nat nil)
    (sigma_eq formula-decl nil sigma nil)
    (low1 skolem-const-decl "nat" sigma_nat nil)
    (high2 skolem-const-decl "int" sigma_nat nil)
    (low2 skolem-const-decl "nat" sigma_nat nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sigma_restrict_eq_0 formula-decl nil sigma nil)
    (low1 skolem-const-decl "nat" sigma_nat nil)
    (high1 skolem-const-decl "int" sigma_nat nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil) (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (sigma def-decl "real" sigma nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil))
   shostak))
 (sigma_tolambda 0
  (sigma_tolambda-1 nil 3620720753
   ("" (skeep) (("" (rewrite "sigma_eq"nil nil)) nil)
   ((sigma_eq formula-decl nil sigma nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (sigma_bij_TCC1 0
  (sigma_bij_TCC1-1 nil 3620667440 ("" (subtype-tcc) nil nilnil nil))
 (sigma_bij_TCC2 0
  (sigma_bij_TCC2-1 nil 3620667440 ("" (subtype-tcc) nil nilnil nil))
 (sigma_bij 0
  (sigma_bij-1 nil 3620667441
   ("" (skeep)
    (("" (label "ontoz" -2)
      (("" (label "rangez" -1)
        (("" (label "injz" -3)
          (("" (case "NOT low<=high")
            (("1" (expand "sigma" +) (("1" (assertnil nil)) nil)
             ("2"
              (name "FF"
                    "LAMBDA (k:nat): (LAMBDA (i:nat): IF low<=i AND i<=low+k THEN F(i) ELSE 0 ENDIF)")
              (("2"
                (case "FORALL (k:nat): low+k<=high IMPLIES sigma(low,high, FF(k)) = sigma(low,high,FF(k) o sig)")
                (("1" (inst - "high-low")
                  (("1" (assert)
                    (("1"
                      (case "sigma(low, high, FF(high - low)) = sigma(low, high,F) AND  sigma(low, high, FF(high - low) o sig) = sigma(low, high, F o sig)")
                      (("1" (flatten) (("1" (assertnil nil)) nil)
                       ("2" (split 1)
                        (("1" (rewrite "sigma_eq" 1)
                          (("1" (skosimp*)
                            (("1" (typepred "n!1")
                              (("1"
                                (expand "FF" 1)
                                (("1" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (rewrite "sigma_eq" 1)
                          (("2" (expand "o")
                            (("2" (skosimp*)
                              (("2"
                                (expand "FF" 1)
                                (("2"
                                  (lift-if)
                                  (("2"
                                    (inst - "n!1")
                                    (("2" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil)
                 ("2" (hide 2)
                  (("2" (induct "k")
                    (("1" (assert)
                      (("1" (inst -4 "low")
                        (("1" (skosimp*)
                          (("1" (lemma "sigma_eq_one_arg")
                            (("1" (inst?)
                              (("1"
                                (inst - "low")
                                (("1"
                                  (assert)
                                  (("1"
                                    (split -)
                                    (("1"
                                      (replaces -1)
                                      (("1"
                                        (lemma "sigma_eq_one_arg")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (inst - "j!1")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (split -)
                                                (("1"
                                                  (replaces -1)
                                                  (("1"
                                                    (expand "o")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (skosimp*)
                                                  (("2"
                                                    (expand "o" 1)
                                                    (("2"
                                                      (expand "FF" 1)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "j!1"
                                                         "i!1")
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (skosimp*)
                                                  (("3"
                                                    (inst
                                                     -
                                                     "i!1"
                                                     "j!1")
                                                    (("3"
                                                      (expand "o" 1)
                                                      (("3"
                                                        (assert)
                                                        (("3"
                                                          (expand
                                                           "FF"
                                                           1)
                                                          (("3"
                                                            (lift-if)
                                                            (("3"
                                                              (inst
                                                               -
                                                               "i!1")
                                                              (("3"
                                                                (ground)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2" (skosimp*) nil nil)
                                     ("3"
                                      (skosimp*)
                                      (("3"
                                        (inst - "i!1" "j!1")
                                        (("3"
                                          (expand "FF" 1)
                                          (("3" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (skolem 1 "k")
                      (("2" (flatten)
                        (("2"
                          (name "GG"
                                "LAMBDA (i:nat): IF i=low+k+1 THEN F(i) ELSE 0 ENDIF")
                          (("2" (assert)
                            (("2"
                              (case "NOT (FF(k+1) = (LAMBDA (d:nat): FF(k)(d) + GG(d)))")
                              (("1"
                                (decompose-equality 1)
                                (("1"
                                  (expand "FF" 1)
                                  (("1"
                                    (expand "GG" 1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (lift-if)
                                          (("1"
                                            (lift-if)
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (lift-if)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (name
                                 "HH"
                                 "LAMBDA (i:nat): IF sig(i)=(low+k+1) THEN F(sig(i)) ELSE 0 ENDIF")
                                (("2"
                                  (case
                                   "NOT ((FF(k+1) o sig) = (LAMBDA (d:nat): (FF(k) o sig)(d) + HH(d)))")
                                  (("1"
                                    (decompose-equality 1)
                                    (("1"
                                      (expand "o" 1)
                                      (("1"
                                        (expand "FF" 1)
                                        (("1"
                                          (expand "HH" 1)
                                          (("1"
                                            (lift-if)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (lift-if)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lift-if)
                                                        (("1"
                                                          (ground)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (replaces -1 +)
                                    (("2"
                                      (replaces -2 +)
                                      (("2"
                                        (rewrite "sigma_sum" :dir rl)
                                        (("2"
                                          (rewrite "sigma_sum" :dir rl)
                                          (("2"
                                            (case
                                             "sigma(low,high,GG) = sigma(low,high,HH)")
                                            (("1"
                                              (replaces -1)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (rewrite
                                                   "sigma_tolambda"
                                                   -3)
                                                  (("1"
                                                    (replaces -3)
                                                    (("1"
                                                      (rewrite
                                                       "sigma_tolambda"
                                                       1)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (lemma
                                                 "sigma_eq_one_arg2")
                                                (("2"
                                                  (inst
                                                   -
                                                   "GG"
                                                   "high"
                                                   "low"
                                                   "low+k+1")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (split -)
                                                      (("1"
                                                        (replaces -1)
                                                        (("1"
                                                          (lemma
                                                           "sigma_eq_one_arg2")
                                                          (("1"
                                                            (inst
                                                             "ontoz"
                                                             "low+k+1")
                                                            (("1"
                                                              (skosimp*)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "HH"
                                                                 "high"
                                                                 "low"
                                                                 "j!1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (split
                                                                     -)
                                                                    (("1"
                                                                      (replaces
                                                                       -1)
                                                                      (("1"
                                                                        (expand
                                                                         "GG"
                                                                         1)
                                                                        (("1"
                                                                          (expand
                                                                           "HH"
                                                                           1)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (skosimp*)
                                                                      (("2"
                                                                        (expand
                                                                         "HH"
                                                                         2)
                                                                        (("2"
                                                                          (lift-if)
                                                                          (("2"
                                                                            (ground)
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "i!1"
                                                                               "j!1")
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (expand
                                                             "GG"
                                                             +)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("3" (skosimp*) (("3" (assertnil nil)) nil)
                     ("4" (skosimp*) (("4" (assertnil nil)) nil)
                     ("5" (skosimp*) (("5" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (GG skolem-const-decl "[nat -> real]" sigma_nat nil)
    (HH skolem-const-decl "[nat -> real]" sigma_nat nil)
    (sigma_eq_one_arg2 formula-decl nil sigma nil)
    (sigma_tolambda formula-decl nil sigma_nat nil)
    (sigma_sum formula-decl nil sigma nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (sigma_eq_one_arg formula-decl nil sigma nil)
    (k!1 skolem-const-decl "nat" sigma_nat nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (high skolem-const-decl "int" sigma_nat nil)
    (low skolem-const-decl "nat" sigma_nat nil)
    (sigma_eq formula-decl nil sigma nil)
    (subrange type-eq-decl nil integers nil)
    (FF skolem-const-decl "[nat -> [nat -> real]]" sigma_nat nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (O const-decl "T3" function_props nil)
    (sigma def-decl "real" sigma nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (sigma_inj_TCC1 0
  (sigma_inj_TCC1-1 nil 3621161667 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sigma_inj_TCC2 0
  (sigma_inj_TCC2-1 nil 3621161667 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sigma_inj_TCC3 0
  (sigma_inj_TCC3-1 nil 3621161667 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (sigma_inj 0
  (sigma_inj-2 nil 3621161684
   ("" (skeep)
    (("" (label "Gdef" -4)
      (("" (label "ontoz" -3)
        (("" (label "rangez" -1)
          (("" (label "injz" -2)
            (("" (case "NOT low1<=high1")
              (("1" (expand "sigma" + 1)
                (("1" (assert)
                  (("1" (rewrite "sigma_restrict_eq_0" +)
                    (("1" (skosimp*)
                      (("1" (inst "ontoz" "i!1")
                        (("1" (assert) (("1" (skosimp*) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (case "NOT low2<=high2")
                (("1" (assert)
                  (("1" (inst - "low1")
                    (("1" (assert) (("1" (ground) nil nil)) nil)) nil))
                  nil)
                 ("2"
                  (name "FF"
                        "LAMBDA (k:nat): (LAMBDA (i:nat): IF low1<=i AND i<=low1+k THEN F(i) ELSE 0 ENDIF)")
                  (("2"
                    (name "GG"
                          "LAMBDA (k:nat): (LAMBDA (i:nat): IF (EXISTS (j:nat): low1<=j AND j<=low1+k AND sig(j)=i) THEN G(i) ELSE 0 ENDIF)")
                    (("2"
                      (case "FORALL (k:nat): low1+k<=high1 IMPLIES sigma(low1,high1, FF(k)) = sigma(low2,high2,GG(k))")
                      (("1" (inst - "high1-low1")
                        (("1" (assert)
                          (("1"
                            (case "sigma(low1, high1, FF(high1 - low1)) = sigma(low1, high1,F) AND  sigma(low2, high2, GG(high1 - low1)) = sigma(low2, high2, G)")
                            (("1" (flatten) (("1" (assertnil nil))
                              nil)
                             ("2" (split 1)
                              (("1"
                                (rewrite "sigma_eq" 1)
                                (("1"
                                  (skosimp*)
                                  (("1"
                                    (expand "FF" 1)
                                    (("1" (propax) nil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (rewrite "sigma_eq" 1)
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (expand "GG" 1)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (ground)
                                        (("2"
                                          (copy "ontoz")
                                          (("2"
                                            (inst - "n!1")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (skeep -)
                                                (("2"
                                                  (inst + "j")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assertnil nil))
                        nil)
                       ("2" (hide 2)
                        (("2" (induct "k")
                          (("1" (assert)
                            (("1" (lemma "sigma_eq_one_arg2")
                              (("1"
                                (inst?)
                                (("1"
                                  (inst - "low1")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (split -)
                                      (("1"
                                        (replaces -1)
                                        (("1"
                                          (lemma "sigma_eq_one_arg2")
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (inst - "sig(low1)")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (split -)
                                                  (("1"
                                                    (replaces -1)
                                                    (("1"
                                                      (expand "FF" 1)
                                                      (("1"
                                                        (expand "GG" 1)
                                                        (("1"
                                                          (lift-if)
                                                          (("1"
                                                            (ground)
                                                            (("1"
                                                              (inst?
                                                               "Gdef")
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (inst
                                                               +
                                                               "low1")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (inst
                                                     "rangez"
                                                     "low1")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (inst
                                                     "rangez"
                                                     "low1")
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("4"
                                                    (skosimp*)
                                                    (("4"
                                                      (expand "GG" 2)
                                                      (("4"
                                                        (lift-if)
                                                        (("4"
                                                          (ground)
                                                          (("4"
                                                            (skosimp*)
                                                            (("4"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skeep)
                                        (("2"
                                          (expand "FF" 2)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skolem 1 "k")
                            (("2" (assert)
                              (("2"
                                (flatten)
                                (("2"
                                  (assert)
                                  (("2"
                                    (case
                                     "sigma(low1, high1, FF(1 + k)) = sigma(low1, high1, FF(k))+F(low1+k+1)")
                                    (("1"
                                      (case
                                       "sigma(low2, high2, GG(1 + k)) = sigma(low2, high2, GG(k)) + G(sig(low1+k+1))")
                                      (("1"
                                        (copy "Gdef")
                                        (("1"
                                          (inst - "low1+k+1")
                                          (("1" (assertnil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide (-1 2))
                                        (("2"
                                          (name
                                           "RD5"
                                           "LAMBDA (i:nat): IF i = sig(low1 + k + 1) THEN G(i) ELSE 0 ENDIF")
                                          (("2"
                                            (case
                                             "GG(1+k) = (LAMBDA (pz:nat): GG(k)(pz) + RD5(pz))")
                                            (("1"
                                              (replaces -1 +)
                                              (("1"
                                                (rewrite
                                                 "sigma_sum"
                                                 :dir
                                                 rl)
                                                (("1"
                                                  (lemma
                                                   "sigma_tolambda")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "GG(k)"
                                                     "high2"
                                                     "low2")
                                                    (("1"
                                                      (replaces
                                                       -1
                                                       :dir
                                                       rl)
                                                      (("1"
                                                        (lemma
                                                         "sigma_eq_one_arg2")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "RD5"
                                                           "high2"
                                                           "low2"
                                                           "sig(low1+k+1)")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (split -)
                                                              (("1"
                                                                (expand
                                                                 "RD5"
                                                                 -1
                                                                 2)
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (inst?
                                                                 "rangez")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (inst?
                                                                 "rangez")
                                                                (("3"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("4"
                                                                (skosimp*)
                                                                (("4"
                                                                  (expand
                                                                   "RD5"
                                                                   2)
                                                                  (("4"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (decompose-equality 1)
                                                (("2"
                                                  (expand "GG" 1)
                                                  (("2"
                                                    (expand "RD5" +)
                                                    (("2"
                                                      (lift-if)
                                                      (("2"
                                                        (lift-if)
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (lift-if)
                                                            (("2"
                                                              (lift-if)
                                                              (("2"
                                                                (lift-if)
                                                                (("2"
                                                                  (lift-if)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (ground)
                                                                      (("1"
                                                                        (skeep
                                                                         -2)
                                                                        (("1"
                                                                          (copy
                                                                           "injz")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "j"
                                                                             "1+k+low1")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (skeep)
                                                                        (("2"
                                                                          (inst
                                                                           +
                                                                           "j")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("3"
                                                                        (inst
                                                                         +
                                                                         "1+k+low1")
                                                                        (("3"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil)
                                                                       ("4"
                                                                        (skeep
                                                                         -1)
                                                                        (("4"
                                                                          (inst
                                                                           +
                                                                           "j")
                                                                          (("4"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("5"
                                                                        (inst
                                                                         +
                                                                         "1+k+low1")
                                                                        (("5"
                                                                          (inst
                                                                           +
                                                                           "1+k+low1")
                                                                          (("5"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (name
                                       "R2D2"
                                       "LAMBDA (i:nat): IF i = low1+k+1 THEN F(i) ELSE 0 ENDIF")
                                      (("2"
                                        (case
                                         "FF(1+k) = (LAMBDA (j:nat): FF(k)(j) + R2D2(j))")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide 2)
                                            (("1"
                                              (rewrite
                                               "sigma_sum"
                                               :dir
                                               rl)
                                              (("1"
                                                (lemma
                                                 "sigma_tolambda")
                                                (("1"
                                                  (inst
                                                   -
                                                   "FF(k)"
                                                   "high1"
                                                   "low1")
                                                  (("1"
                                                    (replaces
                                                     -1
                                                     :dir
                                                     rl)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "sigma_eq_one_arg2")
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "1+k+low1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (split
                                                                 -)
                                                                (("1"
                                                                  (replaces
                                                                   -1)
                                                                  (("1"
                                                                    (expand
                                                                     "R2D2"
                                                                     +)
                                                                    (("1"
                                                                      (propax)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (skosimp*)
                                                                  (("2"
                                                                    (expand
                                                                     "R2D2"
                                                                     2)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide (2 3))
                                          (("2"
                                            (decompose-equality 1)
                                            (("2"
                                              (expand "FF" 1)
                                              (("2"
                                                (expand "R2D2" +)
                                                (("2"
                                                  (lift-if)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lift-if)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (lift-if)
                                                              (("2"
                                                                (ground)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil)
                           ("5" (skosimp*) (("5" (assertnil nil))
                            nil)
                           ("6" (skosimp*) (("6" (assertnil nil))
                            nil)
                           ("7" (skosimp*) (("7" (assertnil nil))
                            nil)
                           ("8" (skosimp*) (("8" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (<= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (subrange type-eq-decl nil integers nil)
    (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (sigma_restrict_eq_0 formula-decl nil sigma nil)
    (sigma def-decl "real" sigma nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (FF skolem-const-decl "[nat -> [nat -> real]]" sigma_nat nil)
    (sigma_eq formula-decl nil sigma nil)
    (GG skolem-const-decl "[nat -> [nat -> real]]" sigma_nat nil)
    (low1 skolem-const-decl "nat" sigma_nat nil)
    (high1 skolem-const-decl "int" sigma_nat nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (high2 skolem-const-decl "int" sigma_nat nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (k!1 skolem-const-decl "nat" sigma_nat nil)
    (k!1 skolem-const-decl "nat" sigma_nat nil)
    (sigma_eq_one_arg2 formula-decl nil sigma nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (R2D2 skolem-const-decl "[nat -> real]" sigma_nat nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (j skolem-const-decl "nat" sigma_nat nil)
    (sigma_tolambda formula-decl nil sigma_nat nil)
    (RD5 skolem-const-decl "[nat -> real]" sigma_nat nil)
    (sigma_sum formula-decl nil sigma nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil)
  (sigma_inj-1 nil 3621161674 ("" (postpone) nil nilnil shostak))
 (sigma_0_neg_TCC1 0
  (sigma_0_neg_TCC1-1 nil 3403521637
   ("" (skosimp*) (("" (inst + "0") (("" (assertnil nil)) nil)) nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_0_neg 0
  (sigma_0_neg-1 nil 3403521650
   ("" (skosimp*) (("" (expand "sigma") (("" (propax) nil nil)) nil))
    nil)
   ((sigma def-decl "real" sigma nil)) shostak))
 (sigma_product2_TCC1 0
  (sigma_product2_TCC1-1 nil 3615631562 ("" (subtype-tcc) nil nilnil
   nil))
 (sigma_product2_TCC2 0
  (sigma_product2_TCC2-1 nil 3615631562 ("" (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)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil))
   nil))
 (sigma_product2_TCC3 0
  (sigma_product2_TCC3-1 nil 3615631562 ("" (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)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (mod const-decl "{k | abs(k) < abs(j)}" mod nil)
    (nonneg_floor_is_nat application-judgement "nat" floor_ceil nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil))
   nil))
 (sigma_product2 0
  (sigma_product2-1 nil 3615631614
   ("" (induct "M")
    (("1" (grind) nil nil) ("2" (grind) nil nil)
     ("3" (skeep)
      (("3" (skeep)
        (("3" (lemma "sigma_split_ge")
          (("3" (inst-cp -1 "F" "j" "j-1" "0")
            (("3"
              (inst -1
               "LAMBDA (k: nat): F((k - mod(k, N)) / N) * G(mod(k, N))"
               "(j+1)*N-1" "j*N-1" "0")
              (("1" (split -2)
                (("1" (split -2)
                  (("1" (case-replace "j+1-1=j")
                    (("1" (hide -1)
                      (("1" (replace -2)
                        (("1" (replace -1)
                          (("1" (case-replace "j*N-1+1 = j*N")
                            (("1" (simplify 1)
                              (("1"
                                (split -4)
                                (("1"
                                  (inst -1 "F" "G" "N")
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (simplify 1)
                                      (("1"
                                        (hide -)
                                        (("1"
                                          (lemma "sigma_shift_to_zero")
                                          (("1"
                                            (inst
                                             -1
                                             "LAMBDA (k: nat): F((k - mod(k, N)) / N) * G(mod(k, N))"
                                             "N-1 +N*j"
                                             "j*N")
                                            (("1"
                                              (split -1)
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (case-replace
                                                   "N-1+N*j-j*N = N-1")
                                                  (("1"
                                                    (hide -)
                                                    (("1"
                                                      (lemma
                                                       "sigma_eq")
                                                      (("1"
                                                        (inst
                                                         -1
                                                         "LAMBDA (i: nat):
               F((i + j * N - mod(i + j * N, N)) / N) *
                G(mod(i + j * N, N))"
                                                         "LAMBDA (i: nat): G(i)*F(j)"
                                                         "N-1"
                                                         "0")
                                                        (("1"
                                                          (split -1)
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (lemma
                                                               "sigma_scal_right")
                                                              (("1"
                                                                (inst
                                                                 -1
                                                                 "G"
                                                                 "F(j)"
                                                                 "N-1"
                                                                 "0")
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (lemma
                                                                     "sigma_eq_arg")
                                                                    (("1"
                                                                      (inst
                                                                       -1
                                                                       "F"
                                                                       "j")
                                                                      (("1"
                                                                        (replace
                                                                         -1)
                                                                        (("1"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (skeep)
                                                              (("2"
                                                                (case-replace
                                                                 "mod(n+j*N, N) = n")
                                                                (("1"
                                                                  (ground)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (expand
                                                                     "mod")
                                                                    (("2"
                                                                      (case-replace
                                                                       "(j*N+n)/N = n/N + j")
                                                                      (("1"
                                                                        (lemma
                                                                         "floor_plus_int")
                                                                        (("1"
                                                                          (inst
                                                                           -1
                                                                           "j"
                                                                           "n/N")
                                                                          (("1"
                                                                            (replace
                                                                             -1)
                                                                            (("1"
                                                                              (simplify
                                                                               1)
                                                                              (("1"
                                                                                (lemma
                                                                                 "floor_0")
                                                                                (("1"
                                                                                  (inst
                                                                                   -1
                                                                                   "n/N")
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (split
                                                                                         -1)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("1"
                                                                                            (ground)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (cross-mult
                                                                                           1)
                                                                                          nil
                                                                                          nil)
                                                                                         ("3"
                                                                                          (cross-mult
                                                                                           1)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (ground)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (ground)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2" (grind) nil nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2" (grind) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (typepred (j))
                                  (("2"
                                    (split-ineq -1)
                                    (("2"
                                      (replace -1)
                                      (("2"
                                        (lemma "sigma_eq_arg")
                                        (("2"
                                          (inst -1 "F" "0")
                                          (("2"
                                            (replace -1)
                                            (("2"
                                              (lemma "sigma_eq")
                                              (("2"
                                                (inst
                                                 -1
                                                 "LAMBDA (k: nat): F((k - mod(k, N)) / N) * G(mod(k, N))"
                                                 "LAMBDA (k:nat): F(0)*G(k)"
                                                 "N-1"
                                                 "0")
                                                (("1"
                                                  (split -1)
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (lemma
                                                       "sigma_scal_right")
                                                      (("1"
                                                        (inst
                                                         -1
                                                         "G"
                                                         "F(0)"
                                                         "N-1"
                                                         "0")
                                                        (("1"
                                                          (replace -1)
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (skeep)
                                                      (("2"
                                                        (case-replace
                                                         "mod(n, N) = n")
                                                        (("1"
                                                          (ground)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (typepred
                                                             (n))
                                                            (("2"
                                                              (grind)
                                                              (("2"
                                                                (case-replace
                                                                 "floor(n/N)=0")
                                                                (("1"
                                                                  (ground)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (grind)
                                                                    (("2"
                                                                      (typepred
                                                                       (N))
                                                                      (("2"
                                                                        (grind)
                                                                        (("2"
                                                                          (lemma
                                                                           "floor_0")
                                                                          (("2"
                                                                            (inst
                                                                             -1
                                                                             "n/N")
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (hide
                                                                                 -1)
                                                                                (("2"
                                                                                  (case
                                                                                   "n/N<1")
                                                                                  (("1"
                                                                                    (div-by
                                                                                     -4
                                                                                     "N")
                                                                                    (("1"
                                                                                      (simplify
                                                                                       -4)
                                                                                      (("1"
                                                                                        (grind)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (cross-mult
                                                                                     1)
                                                                                    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"
                                                    (skosimp*)
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (ground) nil nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (ground) nil nil))
                    nil)
                   ("2" (ground) nil nil) ("3" (ground) nil nil))
                  nil)
                 ("2" (ground) nil nil) ("3" (ground) nil nil))
                nil)
               ("2" (skeep)
                (("2" (hide-all-but 1) (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("4" (hide 2)
      (("4" (skeep)
        (("4" (skeep)
          (("4" (lemma "mod_pos")
            (("4" (inst -1 "k" "N")
              (("4" (flatten) (("4" (grind) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("5" (hide 2) (("5" (skosimp*) (("5" (grind) nil nil)) nil)) nil)
     ("6" (skeep 1) (("6" (grind) nil nil)) nil))
    nil)
   ((mod_pos formula-decl nil mod nil)
    (sigma_split_ge formula-decl nil sigma_nat nil)
    (N skolem-const-decl "posnat" sigma_nat nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (floor const-decl "{i | i <= x & x < i + 1}" floor_ceil nil)
    (sigma_0_neg formula-decl nil sigma_nat nil)
    (sigma_shift_to_zero formula-decl nil sigma_nat nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (sigma_eq formula-decl nil sigma nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (nonneg_floor_is_nat application-judgement "nat" floor_ceil nil)
    (sigma_scal_right formula-decl nil sigma nil)
    (sigma_eq_arg formula-decl nil sigma nil)
    (integer nonempty-type-from-decl nil integers nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (floor_0 formula-decl nil floor_ceil nil)
    (floor_plus_int formula-decl nil floor_ceil nil)
    (subrange type-eq-decl nil integers nil)
    (j skolem-const-decl "nat" sigma_nat nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sigma def-decl "real" sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nonzero_integer nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (mod const-decl "{k | abs(k) < abs(j)}" mod nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (> const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (nil application-judgement "below(m)" mod nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil))
   shostak))
 (sigma_geometric_TCC1 0
  (sigma_geometric_TCC1-1 nil 3609924876 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sigma_geometric_TCC2 0
  (sigma_geometric_TCC2-1 nil 3609924876 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sigma_geometric_TCC3 0
  (sigma_geometric_TCC3-1 nil 3609924876 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sigma_geometric_TCC4 0
  (sigma_geometric_TCC4-1 nil 3609924876 ("" (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)
    (real_minus_real_is_real application-judgement "real" reals 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)
    (/= const-decl "boolean" notequal nil))
   nil))
 (sigma_geometric 0
  (sigma_geometric-1 nil 3609924878
   (""
    (case "FORALL (m, n: nat, r: real):
        r /= 1 IMPLIES
         (1-r)*sigma(n, n+m, LAMBDA (k: nat): r ^ k) =
          (r ^ n - r ^ (n+m + 1))")
    (("1" (skeep)
      (("1" (inst - "m-n" "n" "r")
        (("1" (assertnil nil) ("2" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "m")
        (("1" (skeep)
          (("1" (assert)
            (("1" (expand "sigma")
              (("1" (expand "sigma")
                (("1" (assert)
                  (("1" (expand "^")
                    (("1" (expand "expt" + 2) (("1" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skolem 1 "m")
          (("2" (flatten)
            (("2" (assert)
              (("2" (skeep)
                (("2" (inst - "n" "r")
                  (("2" (assert)
                    (("2" (expand "sigma" +)
                      (("2" (assert)
                        (("2"
                          (name "A"
                                "sigma(n, m + n, LAMBDA (k: nat): r ^ k)")
                          (("2" (replace -1)
                            (("2" (hide -1)
                              (("2"
                                (both-sides
                                 "+"
                                 "r ^ (1 + m + n) - (r ^ (1 + m + n)) * r"
                                 -1)
                                (("2"
                                  (replace -1)
                                  (("2"
                                    (hide -1)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "^")
                                        (("2"
                                          (expand "expt" + 2)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((NOT const-decl "[bool -> bool]" booleans nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (expt def-decl "real" exponentiation nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (n skolem-const-decl "nat" sigma_nat nil)
    (m skolem-const-decl "nat" sigma_nat nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (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)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil) (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (sigma def-decl "real" sigma nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (^ const-decl "real" exponentiation nil))
   shostak)))


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

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.105Angebot  (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-05-06) ¤

*Eine klare Vorstellung vom Zielzustand






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge