Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/PVS/analysis/   (Beweissystem der NASA Version 6.0.9©)  Datei vom 28.9.2014 mit Größe 2 MB image not shown  

Impressum rs_integral_def.prf

  Sprache: Lisp
 

(rs_integral_def
 (IMP_rs_partition_TCC1 0
  (IMP_rs_partition_TCC1-1 nil 3494855846
   ("" (lemma "connected_domain") (("" (propax) nil nil)) nil)
   ((connected_domain formula-decl nil rs_integral_def nil)) nil))
 (IMP_rs_partition_TCC2 0
  (IMP_rs_partition_TCC2-1 nil 3494855846
   ("" (lemma "not_one_element") (("" (propax) nil nil)) nil)
   ((not_one_element formula-decl nil rs_integral_def nil)) nil))
 (xis_join_TCC1 0
  (xis_join_TCC1-1 nil 3489830608 ("" (subtype-tcc) nil nilnil nil))
 (xis_join_TCC2 0
  (xis_join_TCC2-1 nil 3489830608
   ("" (skeep)
    (("" (assert)
      (("" (ground)
        (("1" (expand "o")
          (("1" (expand "partjoin")
            (("1" (expand "o")
              (("1" (expand "delete") (("1" (assertnil nil)) nil))
              nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (ground)
            (("1" (expand "o")
              (("1" (lift-if)
                (("1" (assert)
                  (("1" (ground)
                    (("1" (expand "partjoin")
                      (("1" (expand "o")
                        (("1" (typepred "xab")
                          (("1" (inst?) (("1" (ground) nil nil)) nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "partjoin")
                      (("2" (expand "o")
                        (("2" (lift-if)
                          (("2" (assert)
                            (("2" (ground)
                              (("1"
                                (typepred "Pab")
                                (("1"
                                  (inst -6 "ii")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (typepred "xbc")
                                      (("1"
                                        (inst -2 "ii-xab`length")
                                        (("1"
                                          (flatten)
                                          (("1" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (expand "delete")
                                (("2"
                                  (assert)
                                  (("2"
                                    (typepred "xbc")
                                    (("2"
                                      (inst - "ii-xab`length")
                                      (("2"
                                        (flatten)
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("3"
                                (expand "delete")
                                (("3" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("3" (typepred "ii")
                      (("3" (expand "partjoin" -)
                        (("3" (expand "o")
                          (("3" (expand "delete")
                            (("3" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (expand "o")
              (("2" (expand "partjoin")
                (("2" (expand "o")
                  (("2" (expand "delete")
                    (("2" (assert)
                      (("2" (lift-if)
                        (("2" (lift-if)
                          (("2" (assert)
                            (("2" (ground)
                              (("1"
                                (typepred "xab")
                                (("1"
                                  (inst - "ii")
                                  (("1" (ground) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (typepred "xbc")
                                (("2"
                                  (inst - "ii-xab`length")
                                  (("2" (ground) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil rs_partition nil)
    (below 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals 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)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_def 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (O const-decl "fseq" fseqs "structures/")
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (delete const-decl "fseq" fseqs_ops "structures/")
    (partjoin const-decl "partition(a, c)" rs_partition nil))
   nil))
 (xis_lem 0
  (xis_lem-1 nil 3278409455
   ("" (skosimp*)
    (("" (assert)
      (("" (typepred "xis!1")
        (("" (assert)
          (("" (flatten) (("" (assert) (("" (inst?) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers 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)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers 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)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (AND 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)
    (restrict const-decl "R" restrict nil)
    (<= const-decl "bool" reals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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) (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def nil))
   shostak))
 (xis_bounded 0
  (xis_bounded-1 nil 3489771807
   ("" (skeep)
    (("" (typepred "xis")
      (("" (inst - "ii")
        (("" (flatten)
          (("" (typepred "P")
            (("" (inst-cp -5 "ii")
              (("" (inst -5 "ii+1") (("" (ground) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((xis? type-eq-decl nil rs_integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (> const-decl "bool" reals 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)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_def 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (real_lt_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)
    (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)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (Rie_sum_TCC1 0
  (Rie_sum_TCC1-1 nil 3278175567
   ("" (skosimp*)
    (("" (assert) (("" (typepred "xis!1") (("" (assertnil nil)) nil))
      nil))
    nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (Rie_sum_TCC2 0
  (Rie_sum_TCC2-1 nil 3278691242
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (Rie_sum_TCC3 0
  (Rie_sum_TCC3-1 nil 3278691242
   ("" (skosimp*)
    (("" (typepred "P!1")
      (("" (inst -6 "n!1+1")
        (("1" (flatten)
          (("1" (assert)
            (("1" (lemma "connected_domain")
              (("1" (expand "connected?")
                (("1" (inst - "a!1" "b!1" "P!1`seq(1+n!1)")
                  (("1" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assertnil nil))
        nil))
      nil))
    nil)
   ((partition type-eq-decl nil rs_partition nil)
    (below 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (< const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (nat nonempty-type-eq-decl nil naturalnumbers 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)
    (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))
   shostak))
 (Rie_sec_TCC1 0
  (Rie_sec_TCC1-1 nil 3278154574
   ("" (skosimp*)
    (("" (lemma "connected_domain")
      (("" (expand "connected?")
        (("" (inst - "a!1" "b!1" "P!1`seq(n!1)")
          (("" (assert)
            (("" (typepred "P!1")
              (("" (inst - "n!1") (("" (inst - "n!1"nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((connected_domain formula-decl nil rs_integral_def nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (connected? const-decl "bool" deriv_domain_def nil))
   shostak))
 (Rie_sec_TCC2 0
  (Rie_sec_TCC2-1 nil 3278154574
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (Rie_sum_alt_TCC1 0
  (Rie_sum_alt_TCC1-1 nil 3278324172 ("" (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)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (AND 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)
    (restrict const-decl "R" restrict nil)
    (<= const-decl "bool" reals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (Rie_sum_alt_TCC2 0
  (Rie_sum_alt_TCC2-1 nil 3278324172 ("" (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)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (AND 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)
    (restrict const-decl "R" restrict nil)
    (<= const-decl "bool" reals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (Rie_sum_alt_TCC3 0
  (Rie_sum_alt_TCC3-1 nil 3278324172 ("" (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)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (AND 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)
    (restrict const-decl "R" restrict nil)
    (<= const-decl "bool" reals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (Rie_sum_alt_TCC4 0
  (Rie_sum_alt_TCC4-1 nil 3278324172 ("" (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)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (AND 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)
    (restrict const-decl "R" restrict nil)
    (<= const-decl "bool" reals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def 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)
    (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_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (integer nonempty-type-from-decl nil integers nil))
   shostak))
 (Rie_sum_alt_lem 0
  (Rie_sum_alt_lem-3 nil 3280252836
   ("" (skosimp*)
    (("" (expand "Rie_sum")
      (("" (assert)
        (("" (expand "Rie_sum_alt")
          (("" (expand "Rie_sec")
            (("" (assert)
              ((""
                (case "FORALL (NN: below(length(P!1)-1)):  sigma[below(length(P!1) - 1)]
                                                    (0, NN,
                                                     LAMBDA (n: below(length(P!1) - 1)):
                                                       g!1(P!1`seq(1 + n)) * f!1(xis!1`seq(n)) -
                                                        g!1(P!1`seq(n)) * f!1(xis!1`seq(n)))
                                                 =
                                                 sigma[upto(length(P!1) - 1)]
                                                     (1, NN+1,
                                                      LAMBDA (n: upto(length(P!1) - 1)):
                                                        IF n = 0 THEN 0
                                                        ELSE g!1(P!1`seq(n)) * f!1(xis!1`seq(n - 1)) -
                                                              g!1(P!1`seq(n - 1)) * f!1(xis!1`seq(n - 1))
                                                        ENDIF)")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (replace -1)
                      (("1" (replace -1 :dir rl)
                        (("1" (propax) nil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide 2)
                  (("2"
                    (induct "NN" 1 "below_induction[length(P!1)-1]")
                    (("1" (assert)
                      (("1" (expand "sigma")
                        (("1" (expand "sigma") (("1" (propax) nil nil))
                          nil))
                        nil))
                      nil)
                     ("2" (skosimp*)
                      (("2" (expand "sigma" 1) (("2" (assertnil nil))
                        nil))
                      nil)
                     ("3" (hide 2)
                      (("3" (skosimp*) (("3" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("3" (hide 2)
                  (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (Rie_sum const-decl "real" rs_integral_def nil)
    (Rie_sum_alt const-decl "real" rs_integral_def nil)
    (below_induction formula-decl nil bounded_nat_inductions nil)
    (pred type-eq-decl nil defined_types nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" rs_integral_def
     nil)
    (b!1 skolem-const-decl "T" rs_integral_def nil)
    (a!1 skolem-const-decl "T" rs_integral_def nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sigma def-decl "real" sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (Rie_sec const-decl "real" rs_integral_def 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_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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (partition type-eq-decl nil rs_partition nil)
    (below 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (> const-decl "bool" reals nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields 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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil)
  (Rie_sum_alt_lem-2 nil 3280252800
   ("" (skosimp*)
    (("" (expand "Rie_sum")
      (("" (assert)
        (("" (expand "Rie_sum_alt")
          (("" (expand "Rie_sec")
            (("" (assert)
              (("" (assert)
                ((""
                  (case "FORALL (NN: below(length(P!1)-1)):  sigma[below(length(P!1) - 1)]
                        (0, NN,
                         LAMBDA (n: below(length(P!1) - 1)):
                           P!1`seq(1 + n) * f!1(xis!1(n)) -
                            P!1`seq(n) * f!1(xis!1(n)))
                     =
                     sigma[upto(length(P!1) - 1)]
                         (1, NN+1,
                          LAMBDA (n: upto(length(P!1) - 1)):
                            IF n = 0 THEN 0
                            ELSE P!1`seq(n) * f!1(xis!1`seq(n - 1)) -
                                  P!1`seq(n - 1) * f!1(xis!1`seq(n - 1))
                            ENDIF)")
                  (("1" (inst?) (("1" (assertnil)))
                   ("2" (hide 2)
                    (("2"
                      (induct "NN" 1 "below_induction[length(P!1)-1]")
                      (("1" (assert)
                        (("1" (expand "sigma") (("1" (propax) nil)))))
                       ("2" (skosimp*)
                        (("2" (expand "sigma" 1)
                          (("2" (assertnil)))))
                       ("3" (hide 2)
                        (("3" (skosimp*) (("3" (assertnil)))))
                       ("4" (skosimp*) (("4" (assertnil)))
                       ("5" (skosimp*)
                        (("5" (hide 3)
                          (("5" (assert)
                            (("5" (typepred "xis!1")
                              (("5"
                                (expand "xis?")
                                (("5" (propax) nil)))))))))))
                       ("6" (assert)
                        (("6" (hide 2)
                          (("6" (skosimp*) (("6" (assertnil)))))))
                       ("7" (skosimp*)
                        (("7" (assert)
                          (("7" (hide 2)
                            (("7" (typepred "xis!1")
                              (("7" (assertnil)))))))))))))
                   ("3" (hide 2)
                    (("3" (skosimp*) (("3" (assertnil)))))
                   ("4" (hide 2)
                    (("4" (skosimp*) (("4" (assertnil)))))
                   ("5" (hide 2)
                    (("5" (skosimp*)
                      (("5" (assert)
                        (("5" (typepred "xis!1")
                          (("5" (assertnil)))))))))
                   ("6" (hide 2)
                    (("6" (skosimp*) (("6" (assertnil)))))
                   ("7" (hide 2)
                    (("7" (skosimp*)
                      (("7" (assert)
                        (("7" (typepred "xis!1")
                          (("7" (assertnil))))))))))))))))))))))))
    nil)
   nil nil)
  (Rie_sum_alt_lem-1 nil 3278324183
   ("" (skosimp*)
    (("" (expand "Rie_sum")
      (("" (assert)
        (("" (expand "Rie_sum_alt")
          (("" (expand "Rie_sec")
            (("" (assert)
              (("" (assert)
                ((""
                  (case "FORALL (NN: below(length(P!1)-1)):  sigma[below(length(P!1) - 1)]
                 (0, NN,
                  LAMBDA (n: below(length(P!1) - 1)):
                    P!1`seq(1 + n) * f!1(xis!1`seq(n)) -
                     P!1`seq(n) * f!1(xis!1`seq(n)))
              =
              sigma[upto(length(P!1) - 1)]
                  (1, NN+1,
                   LAMBDA (n: upto(length(P!1) - 1)):
                     IF n = 0 THEN 0
                     ELSE P!1`seq(n) * f!1(xis!1`seq(n - 1)) -
                           P!1`seq(n - 1) * f!1(xis!1`seq(n - 1))
                     ENDIF)")
                  (("1" (inst?) (("1" (assertnil nil)) nil)
                   ("2" (hide 2)
                    (("2"
                      (induct "NN" 1 "below_induction[length(P!1)-1]")
                      (("1" (assert)
                        (("1" (expand "sigma") (("1" (propax) nil nil))
                          nil))
                        nil)
                       ("2" (skosimp*)
                        (("2" (expand "sigma" 1)
                          (("2" (assertnil nil)) nil))
                        nil)
                       ("3" (hide 2)
                        (("3" (skosimp*) (("3" (assertnil nil)) nil))
                        nil)
                       ("4" (skosimp*) (("4" (assertnil nil)) nil)
                       ("5" (skosimp*)
                        (("5" (hide 3)
                          (("5" (assert)
                            (("5" (typepred "xis!1")
                              (("5"
                                (expand "xis?")
                                (("5" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("6" (assert)
                        (("6" (hide 2)
                          (("6" (skosimp*) (("6" (assertnil nil))
                            nil))
                          nil))
                        nil)
                       ("7" (skosimp*)
                        (("7" (assert)
                          (("7" (hide 2)
                            (("7" (typepred "xis!1")
                              (("7" (assertnil 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" (assert)
                        (("5" (typepred "xis!1")
                          (("5" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil)
                   ("6" (hide 2)
                    (("6" (skosimp*) (("6" (assertnil nil)) nil))
                    nil)
                   ("7" (hide 2)
                    (("7" (skosimp*)
                      (("7" (assert)
                        (("7" (typepred "xis!1")
                          (("7" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma def-decl "real" sigma "reals/")) shostak))
 (Riemann_sum_strictly_sort_TCC1 0
  (Riemann_sum_strictly_sort_TCC1-1 nil 3492270809
   ("" (lemma "partition_strictly_sort")
    (("" (assert)
      (("" (skeep)
        (("" (skeep)
          (("" (inst - "a" "b")
            (("" (assert) (("" (inst - "P"nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    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)
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (> const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (partition_strictly_sort formula-decl nil rs_partition 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)
    (T_pred const-decl "[real -> boolean]" rs_integral_def nil)
    (T formal-nonempty-subtype-decl nil rs_integral_def nil))
   nil))
 (Riemann_sum_strictly_sort 0
  (Riemann_sum_strictly_sort-3 nil 3495206538
   ("" (auto-rewrite + "member")
    (("" (skeep)
      (("" (skeep)
        ((""
          (name "XISfun"
                "(LAMBDA (xis:xis?(a,b,P)): (# length := strictly_sort(P)`length-1, seq := (LAMBDA (ii:nat): IF ii < strictly_sort(P)`length-1 THEN xis`seq(strictly_sort_map(P)(ii)) ELSE default[T] ENDIF) #))")
          (("1" (label "XISfunname" -1)
            (("1"
              (case "FORALL (xis:xis?(a,b,P)): Rie_sum(a,b,g,P,xis,f) = Rie_sum(a,b,g,strictly_sort(P),XISfun(xis),f)")
              (("1" (ground)
                (("1" (skeep -)
                  (("1" (inst - "xis")
                    (("1" (inst + "XISfun(xis)")
                      (("1" (assertnil nil)
                       ("2" (assert)
                        (("2" (expand "XISfun" +)
                          (("2" (assert)
                            (("2" (typepred "strictly_sort(P)")
                              (("2"
                                (inst - "a")
                                (("2"
                                  (case "member(a,P)")
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (assert)
                                        (("1" (skosimp*) nil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide-all-but 1)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (inst + "0")
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (skeep -)
                  (("2" (assert)
                    (("2"
                      (case "FORALL (xiss:xis?(a,b,strictly_sort(P))): EXISTS (xis:xis?(a,b,P)): xiss = XISfun(xis)")
                      (("1" (inst - "xis")
                        (("1" (skolem -1 "xisp")
                          (("1" (inst - "xisp")
                            (("1" (inst + "xisp")
                              (("1" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide -1)
                        (("2" (hide -1)
                          (("2" (hide 2)
                            (("2" (skeep)
                              (("2"
                                (name
                                 "sig"
                                 "partition_union_map(a,b,P,P)")
                                (("2"
                                  (label "signame" -1)
                                  (("2"
                                    (typepred "sig")
                                    (("2"
                                      (label "sigtp" -1)
                                      (("2"
                                        (name
                                         "yis"
                                         "(# length := P`length-1, seq := (LAMBDA (ii:nat): IF ii < P`length-1 THEN IF sig(ii) = strictly_sort(P)`length-1 THEN b ELSIF sig(ii) = sig(ii+1) THEN P`seq(ii) ELSE xiss`seq(sig(ii)) ENDIF ELSE default[T] ENDIF) #)")
                                        (("1"
                                          (label "yisname" -1)
                                          (("1"
                                            (lemma
                                             "partition_union_is_strictly_sort")
                                            (("1"
                                              (inst - "a" "b")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (inst - "P")
                                                  (("1"
                                                    (label
                                                     "unionsort"
                                                     -1)
                                                    (("1"
                                                      (replace
                                                       "unionsort")
                                                      (("1"
                                                        (stop-rewrite
                                                         "xis_lem")
                                                        (("1"
                                                          (inst
                                                           +
                                                           "yis")
                                                          (("1"
                                                            (expand
                                                             "XISfun"
                                                             +)
                                                            (("1"
                                                              (decompose-equality
                                                               +)
                                                              (("1"
                                                                (decompose-equality
                                                                 +)
                                                                (("1"
                                                                  (lift-if)
                                                                  (("1"
                                                                    (ground)
                                                                    (("1"
                                                                      (expand
                                                                       "yis"
                                                                       +)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (ground)
                                                                          (("1"
                                                                            (name
                                                                             "ssm"
                                                                             "strictly_sort_map(P)")
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (label
                                                                                 "ssmname"
                                                                                 -1)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "partition_union_strictly_sort_map_inv")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "a"
                                                                                     "b")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "P"
                                                                                         "x!1")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (name
                                                                               "ssm"
                                                                               "strictly_sort_map(P)")
                                                                              (("2"
                                                                                (replace
                                                                                 -1)
                                                                                (("2"
                                                                                  (label
                                                                                   "ssmname"
                                                                                   -1)
                                                                                  (("2"
                                                                                    (typepred
                                                                                     "ssm")
                                                                                    (("2"
                                                                                      (lemma
                                                                                       "partition_union_strictly_sort_map_inv")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "a"
                                                                                         "b")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "P"
                                                                                             "x!1")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (replace
                                                                                                 "ssmname")
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   "signame")
                                                                                                  (("2"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "x!1")
                                                                                                      (("2"
                                                                                                        (flatten)
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (typepred
                                                                                                             "sig")
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "1+ssm(x!1)")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (typepred
                                                                                                                   "sig")
                                                                                                                  (("2"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "ssm(x!1)")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (case
                                                                                                                         "NOT P`seq(ssm(x!1)) = P`seq(1+ssm(x!1))")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (typepred
                                                                                                                           "xiss")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "x!1")
                                                                                                                            (("2"
                                                                                                                              (flatten)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("3"
                                                                            (name
                                                                             "ssm"
                                                                             "strictly_sort_map(P)")
                                                                            (("3"
                                                                              (replace
                                                                               -1)
                                                                              (("3"
                                                                                (label
                                                                                 "ssmname"
                                                                                 -1)
                                                                                (("3"
                                                                                  (lemma
                                                                                   "partition_union_strictly_sort_map_inv")
                                                                                  (("3"
                                                                                    (inst
                                                                                     -
                                                                                     "a"
                                                                                     "b")
                                                                                    (("3"
                                                                                      (assert)
                                                                                      (("3"
                                                                                        (inst
                                                                                         -
                                                                                         "P"
                                                                                         "x!1")
                                                                                        (("3"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("4"
                                                                            (name
                                                                             "ssm"
                                                                             "strictly_sort_map(P)")
                                                                            (("4"
                                                                              (replace
                                                                               -1)
                                                                              (("4"
                                                                                (label
                                                                                 "ssmname"
                                                                                 -1)
                                                                                (("4"
                                                                                  (typepred
                                                                                   "ssm")
                                                                                  (("4"
                                                                                    (assert)
                                                                                    (("4"
                                                                                      (inst
                                                                                       -
                                                                                       "x!1")
                                                                                      (("4"
                                                                                        (flatten)
                                                                                        (("4"
                                                                                          (assert)
                                                                                          (("4"
                                                                                            (typepred
                                                                                             "strictly_sort(P)")
                                                                                            (("4"
                                                                                              (expand
                                                                                               "strictly_increasing?")
                                                                                              (("4"
                                                                                                (inst
                                                                                                 -
                                                                                                 "x!1"
                                                                                                 "strictly_sort(P)`length-1")
                                                                                                (("4"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (typepred
                                                                       "xiss`seq")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "x!1")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (skosimp*)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (skosimp*)
                                                                (("3"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (split +)
                                                            (("1"
                                                              (skosimp*)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "yis"
                                                                   +)
                                                                  (("1"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skeep)
                                                              (("2"
                                                                (split
                                                                 +)
                                                                (("1"
                                                                  (expand
                                                                   "yis"
                                                                   +)
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (split
                                                                         +)
                                                                        (("1"
                                                                          (flatten)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (typepred
                                                                               "xiss")
                                                                              (("1"
                                                                                (typepred
                                                                                 "sig")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "ii")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (flatten)
                                                                          (("2"
                                                                            (ground)
                                                                            (("2"
                                                                              (typepred
                                                                               "xiss")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "sig(ii)")
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (typepred
                                                                                     "sig")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "ii")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "yis"
                                                                   +)
                                                                  (("2"
                                                                    (lift-if)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (ground)
                                                                        (("1"
                                                                          (typepred
                                                                           "sig")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "ii")
                                                                            (("1"
                                                                              (typepred
                                                                               "P")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "ii+1")
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "increasing?")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "ii"
                                                                                       "1+ii")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (typepred
                                                                           "P")
                                                                          (("2"
                                                                            (expand
                                                                             "increasing?")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "ii"
                                                                               "1+ii")
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (typepred
                                                                           "xiss")
                                                                          (("3"
                                                                            (inst
                                                                             -
                                                                             "sig(ii)")
                                                                            (("3"
                                                                              (flatten)
                                                                              (("3"
                                                                                (case
                                                                                 "1+sig(ii) <= sig(1+ii)")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (typepred
                                                                                     "strictly_sort(P)")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "strictly_increasing?")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "1+sig(ii)"
                                                                                         "sig(1+ii)")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (typepred
                                                                                             "sig")
                                                                                            (("1"
                                                                                              (inst
                                                                                               -
                                                                                               "1+ii")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (typepred
                                                                                   "sig")
                                                                                  (("2"
                                                                                    (inst-cp
                                                                                     -
                                                                                     "ii")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "ii+1")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           "strictly_sort(P)")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "strictly_increasing?")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "sig(1+ii)"
                                                                                               "sig(ii)")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (flatten)
                                                                                                  (("2"
                                                                                                    (typepred
                                                                                                     "P")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "increasing?")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "ii"
                                                                                                         "1+ii")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (skosimp*)
                                          (("2" (assertnil 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))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide ("xispred" "XISfunname"))
                (("2" (hide 2)
                  (("2" (skeep)
                    (("2" (expand "XISfun")
                      (("2"
                        (name "yis"
                              "(# length := strictly_sort(P)`length-1, seq := (LAMBDA (ii:nat): IF ii < strictly_sort(P)`length-1 THEN xis`seq(strictly_sort_map(P)(ii)) ELSE default[T] ENDIF) #)")
                        (("1" (replace -1)
                          (("1" (hide -1)
                            (("1" (expand "Rie_sum")
                              (("1"
                                (name "ssp" "strictly_sort(P)")
                                (("1"
                                  (label "sspname" -1)
                                  (("1"
                                    (replace "sspname")
                                    (("1"
                                      (name
                                       "sig"
                                       "strictly_sort_map(P)")
                                      (("1"
                                        (label "signame" -1)
                                        (("1"
                                          (case
                                           "FORALL (mm:below(ssp`length-1)): sigma[below(strictly_sort(P)`length - 1)]
                                                                                                                                                                                (0, mm,
                                                                                                                                                                                 LAMBDA (n: below(strictly_sort(P)`length - 1)):
                                                                                                                                                                                   f(yis`seq(n)) * g(ssp`seq(1 + n)) -
                                                                                                                                                                                    f(yis`seq(n)) * g(ssp`seq(n))) = sigma[below(P`length - 1)]
                                                                                                                                                                               (0, sig(mm),
                                                                                                                                                                                LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                  f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n)))")
                                          (("1"
                                            (inst - "ssp`length-2")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (hide -1)
                                                (("1"
                                                  (lemma
                                                   "sigma_split[below(P`length-1)]")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                     f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n))"
                                                     "P`length-2"
                                                     "0"
                                                     "sig(ssp`length - 2)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case
                                                         "sig(ssp`length-2) <= P`length-2")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (replace
                                                             -2)
                                                            (("1"
                                                              (case
                                                               "sigma(1 + sig(ssp`length - 2), P`length - 2,
                                                                                                                                                                                                                                                                                          LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                                            f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                                                                             f(xis`seq(n)) * g(P`seq(n))) = 0")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (hide
                                                                   -2)
                                                                  (("2"
                                                                    (rewrite
                                                                     "sigma_restrict_eq_0")
                                                                    (("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (skeep)
                                                                        (("2"
                                                                          (typepred
                                                                           "i")
                                                                          (("2"
                                                                            (case
                                                                             "g(P`seq(1+i)) = g(P`seq(i))")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (typepred
                                                                                 "sig")
                                                                                (("2"
                                                                                  (hide
                                                                                   -1)
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "ssp`length-2")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (name
                                                                                           "jj"
                                                                                           "ssp`length-2")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (case
                                                                                               "ssp`length-1 = jj+1")
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (case
                                                                                                   "P`seq(1+i) = P`seq(i)")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (hide
                                                                                                     2)
                                                                                                    (("2"
                                                                                                      (lemma
                                                                                                       "strictly_sort_map_between")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "P")
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           "sspname")
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             "signame")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "jj")
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "i")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    (("1"
                                                                                                                      (case
                                                                                                                       "P`seq(sig(1+jj)) = P`seq(1+i)")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (case
                                                                                                                           "1+sig(jj) <= sig(jj+1)")
                                                                                                                          (("1"
                                                                                                                            (case
                                                                                                                             "sig(jj+1) = P`length-1")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (replace
                                                                                                                               -3
                                                                                                                               :dir
                                                                                                                               rl)
                                                                                                                              (("2"
                                                                                                                                (typepred
                                                                                                                                 "sig")
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  (("2"
                                                                                                                                    (case
                                                                                                                                     "NOT P`length = 0")
                                                                                                                                    (("1"
                                                                                                                                      (lemma
                                                                                                                                       "fseq_length_zero")
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "ssp")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          (("1"
                                                                                                                                            (typepred
                                                                                                                                             "ssp")
                                                                                                                                            (("1"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "P`seq(0)")
                                                                                                                                              (("1"
                                                                                                                                                (case
                                                                                                                                                 "member(P`seq(0),P)")
                                                                                                                                                (("1"
                                                                                                                                                  (replace
                                                                                                                                                   -1)
                                                                                                                                                  (("1"
                                                                                                                                                    (hide
                                                                                                                                                     -1)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      (("1"
                                                                                                                                                        (skosimp*)
                                                                                                                                                        nil
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil)
                                                                                                                                                 ("2"
                                                                                                                                                  (expand
                                                                                                                                                   "member")
                                                                                                                                                  (("2"
                                                                                                                                                    (inst
                                                                                                                                                     +
                                                                                                                                                     "0")
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (lemma
                                                                                                                               "fseq_length_zero")
                                                                                                                              (("3"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "ssp")
                                                                                                                                (("3"
                                                                                                                                  (assert)
                                                                                                                                  (("3"
                                                                                                                                    (typepred
                                                                                                                                     "ssp")
                                                                                                                                    (("3"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "P`seq(0)")
                                                                                                                                      (("3"
                                                                                                                                        (case
                                                                                                                                         "member(P`seq(0),P)")
                                                                                                                                        (("1"
                                                                                                                                          (replace
                                                                                                                                           -1)
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (skosimp*)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (expand
                                                                                                                                           "member")
                                                                                                                                          (("2"
                                                                                                                                            (inst
                                                                                                                                             +
                                                                                                                                             "0")
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("2"
                                                                                                                            (lemma
                                                                                                                             "strictly_sort_map_increasing")
                                                                                                                            (("2"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "P")
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "jj"
                                                                                                                                   "1+jj")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (lemma
                                                                                                                                       "fseq_length_zero")
                                                                                                                                      (("2"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "ssp")
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          (("2"
                                                                                                                                            (typepred
                                                                                                                                             "ssp")
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "P`seq(0)")
                                                                                                                                              (("2"
                                                                                                                                                (case
                                                                                                                                                 "member(P`seq(0),P)")
                                                                                                                                                (("1"
                                                                                                                                                  (replace
                                                                                                                                                   -1)
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    (("1"
                                                                                                                                                      (skosimp*)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil)
                                                                                                                                                 ("2"
                                                                                                                                                  (expand
                                                                                                                                                   "member")
                                                                                                                                                  (("2"
                                                                                                                                                    (inst
                                                                                                                                                     +
                                                                                                                                                     "0")
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("3"
                                                                                                                                    (lemma
                                                                                                                                     "partition_strictly_sort")
                                                                                                                                    (("3"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "a"
                                                                                                                                       "b")
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        (("3"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           "P")
                                                                                                                                          (("3"
                                                                                                                                            (flatten)
                                                                                                                                            (("3"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("3"
                                                                                                                            (lemma
                                                                                                                             "partition_strictly_sort")
                                                                                                                            (("3"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "a"
                                                                                                                               "b")
                                                                                                                              (("3"
                                                                                                                                (assert)
                                                                                                                                (("3"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "P")
                                                                                                                                  (("3"
                                                                                                                                    (flatten)
                                                                                                                                    (("3"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("4"
                                                                                                                            (lemma
                                                                                                                             "partition_strictly_sort")
                                                                                                                            (("4"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "a"
                                                                                                                               "b")
                                                                                                                              (("4"
                                                                                                                                (assert)
                                                                                                                                (("4"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "P")
                                                                                                                                  (("4"
                                                                                                                                    (flatten)
                                                                                                                                    (("4"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (assert)
                                                                                                                        (("2"
                                                                                                                          (lemma
                                                                                                                           "strictly_sort_map_between")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "P")
                                                                                                                            (("2"
                                                                                                                              (replace
                                                                                                                               -11)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (replace
                                                                                                                                   -3
                                                                                                                                   +
                                                                                                                                   :dir
                                                                                                                                   rl)
                                                                                                                                  (("2"
                                                                                                                                    (typepred
                                                                                                                                     "sig")
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      (("2"
                                                                                                                                        (split
                                                                                                                                         -)
                                                                                                                                        (("1"
                                                                                                                                          (hide
                                                                                                                                           -2)
                                                                                                                                          (("1"
                                                                                                                                            (replace
                                                                                                                                             "sspname")
                                                                                                                                            (("1"
                                                                                                                                              (replace
                                                                                                                                               -1)
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                (("1"
                                                                                                                                                  (inst
                                                                                                                                                   -
                                                                                                                                                   "jj")
                                                                                                                                                  (("1"
                                                                                                                                                    (inst
                                                                                                                                                     -
                                                                                                                                                     "1+i")
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (assert)
                                                                                                                                                    (("2"
                                                                                                                                                      (lemma
                                                                                                                                                       "partition_strictly_sort")
                                                                                                                                                      (("2"
                                                                                                                                                        (inst
                                                                                                                                                         -
                                                                                                                                                         "a"
                                                                                                                                                         "b")
                                                                                                                                                        (("2"
                                                                                                                                                          (assert)
                                                                                                                                                          (("2"
                                                                                                                                                            (inst
                                                                                                                                                             -
                                                                                                                                                             "P")
                                                                                                                                                            (("2"
                                                                                                                                                              (flatten)
                                                                                                                                                              (("2"
                                                                                                                                                                (assert)
                                                                                                                                                                nil
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (lemma
                                                                                                                                           "partition_strictly_sort")
                                                                                                                                          (("2"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "a"
                                                                                                                                             "b")
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              (("2"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "P")
                                                                                                                                                (("2"
                                                                                                                                                  (flatten)
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("3"
                                                                                                                        (lemma
                                                                                                                         "partition_strictly_sort")
                                                                                                                        (("3"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "a"
                                                                                                                           "b")
                                                                                                                          (("3"
                                                                                                                            (assert)
                                                                                                                            (("3"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "P")
                                                                                                                              (("3"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (lemma
                                                                                                                   "partition_strictly_sort")
                                                                                                                  (("2"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "a"
                                                                                                                     "b")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (inst
                                                                                                                         -
                                                                                                                         "P")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (lemma
                                                                                       "partition_strictly_sort")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "a"
                                                                                         "b")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "P")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide (-1 2))
                                                          (("2"
                                                            (typepred
                                                             "sig")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (case
                                                                 "strictly_sort(P)`length >= 1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (replace
                                                                     "sspname")
                                                                    (("1"
                                                                      (inst-cp
                                                                       -
                                                                       "ssp`length-2")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "ssp`length-1")
                                                                        (("1"
                                                                          (flatten)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (case
                                                                               "NOT sig(ssp`length-2) = P`length-1")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil)
                                                                               ("2"
                                                                                (replace
                                                                                 -1)
                                                                                (("2"
                                                                                  (typepred
                                                                                   "ssp")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "strictly_increasing?")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "ssp`length-2"
                                                                                       "ssp`length-1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (lemma
                                                                                         "partition_strictly_sort")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "a"
                                                                                           "b")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "P")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "partition_strictly_sort")
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "a"
                                                                           "b")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "P")
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (lemma
                                                                   "partition_strictly_sort")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "a"
                                                                     "b")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "P")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("3"
                                                          (lemma
                                                           "partition_strictly_sort")
                                                          (("3"
                                                            (inst
                                                             -
                                                             "a"
                                                             "b")
                                                            (("3"
                                                              (assert)
                                                              (("3"
                                                                (inst
                                                                 -
                                                                 "P")
                                                                (("3"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (lemma
                                                       "partition_strictly_sort")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "a"
                                                         "b")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "P")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (lemma
                                               "partition_strictly_sort")
                                              (("2"
                                                (inst - "a" "b")
                                                (("2"
                                                  (assert)
                                                  (("1"
                                                    (inst - "P")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma
                                                     "partition_strictly_sort")
                                                    (("2"
                                                      (expand "ssp")
                                                      (("2"
                                                        (typepred
                                                         "strictly_sort(P)")
                                                        (("2"
                                                          (inst-cp
                                                           -
                                                           "a")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "b")
                                                            (("2"
                                                              (case
                                                               "member(b,P) and member(a,P)")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (replace
                                                                     -2)
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (expand
                                                                           "member")
                                                                          (("1"
                                                                            (skosimp*)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (split)
                                                                    (("1"
                                                                      (inst
                                                                       +
                                                                       "P`length-1")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (inst
                                                                       +
                                                                       "0")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (label "altb" -3)
                                              (("2"
                                                (induct "mm")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand "sigma")
                                                    (("1"
                                                      (expand
                                                       "sigma"
                                                       1
                                                       1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lift-if)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (case
                                                               "sigma(0, sig(0) - 1,
                                                                                                                                                                                                                                      LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                        f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                         f(xis`seq(n)) * g(P`seq(n))) = 0")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (typepred
                                                                     "sig")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "0")
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (replace
                                                                             "sspname")
                                                                            (("1"
                                                                              (replace
                                                                               -2
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (replace
                                                                                 -3
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (expand
                                                                                   "yis")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (rewrite
                                                                   "sigma_restrict_eq_0")
                                                                  (("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (skeep)
                                                                      (("2"
                                                                        (typepred
                                                                         "i")
                                                                        (("2"
                                                                          (case
                                                                           "P`seq(1+i) = P`seq(i)")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (typepred
                                                                               "sig")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "0")
                                                                                (("2"
                                                                                  (hide
                                                                                   -1)
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (hide
                                                                                         -2)
                                                                                        (("2"
                                                                                          (case
                                                                                           "P`seq(sig(0)) = a")
                                                                                          (("1"
                                                                                            (typepred
                                                                                             "P")
                                                                                            (("1"
                                                                                              (copy
                                                                                               -4)
                                                                                              (("1"
                                                                                                (case
                                                                                                 "P`seq(i) = a AND P`seq(1+i) = a")
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (split
                                                                                                     +)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "increasing?"
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (inst-cp
                                                                                                         -
                                                                                                         "0"
                                                                                                         "i")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "i"
                                                                                                           "sig(0)")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (expand
                                                                                                       "increasing?"
                                                                                                       -1)
                                                                                                      (("2"
                                                                                                        (inst-cp
                                                                                                         -
                                                                                                         "0"
                                                                                                         "1+i")
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "1+i"
                                                                                                           "sig(0)")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (lemma
                                                                                             "partition_strictly_sort")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "a"
                                                                                               "b")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "P")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (skolem 1 "mm")
                                                  (("2"
                                                    (assert)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (expand
                                                         "sigma"
                                                         1
                                                         1)
                                                        (("1"
                                                          (replace -2)
                                                          (("1"
                                                            (lemma
                                                             "strictly_sort_map_increasing")
                                                            (("1"
                                                              (expand
                                                               "sigma"
                                                               1
                                                               2)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (ground)
                                                                  (("1"
                                                                    (expand
                                                                     "yis"
                                                                     +)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (replace
                                                                         "signame")
                                                                        (("1"
                                                                          (case
                                                                           "f(xis`seq(sig(1 + mm))) * g(ssp`seq(2 + mm))
                                                                                                                                                                                                                                                          - f(xis`seq(sig(1 + mm))) * g(ssp`seq(1 + mm)) = f(xis`seq(sig(1 + mm))) * g(P`seq(1 + sig(1 + mm)))
                                                                                                                                                                                                                                                           - f(xis`seq(sig(1 + mm))) * g(P`seq(sig(1 + mm))) AND sigma[below(P`length - 1)]
                                                                                                                                                                                                                                                             (0, sig(mm),
                                                                                                                                                                                                                                                              LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n))) = sigma(0, sig(1 + mm) - 1,
                                                                                                                                                                                                                                                                LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                  f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                                                   f(xis`seq(n)) * g(P`seq(n)))")
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             3)
                                                                            (("2"
                                                                              (split
                                                                               +)
                                                                              (("1"
                                                                                (typepred
                                                                                 "sig")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "1+mm")
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (lemma
                                                                                 "sigma_split[below(P`length-1)]")
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "(LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                     f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                                      f(xis`seq(n)) * g(P`seq(n)))"
                                                                                   "sig(1+mm)-1"
                                                                                   "0"
                                                                                   "sig(mm)")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (split
                                                                                       -)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -1)
                                                                                          (("1"
                                                                                            (case
                                                                                             "sigma(1 + sig(mm), sig(1 + mm) - 1,
                                                                                                                                                                                                                                                                                                                                               (LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                                                                                                  f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                                                                                                                                   f(xis`seq(n)) * g(P`seq(n)))) = 0")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide
                                                                                               2)
                                                                                              (("2"
                                                                                                (rewrite
                                                                                                 "sigma_restrict_eq_0")
                                                                                                (("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (hide
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (hide
                                                                                                       -2)
                                                                                                      (("2"
                                                                                                        (skeep)
                                                                                                        (("2"
                                                                                                          (typepred
                                                                                                           "i")
                                                                                                          (("2"
                                                                                                            (case
                                                                                                             "P`seq(i) = P`seq(1+i)")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (hide
                                                                                                               2)
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "strictly_sort_map_between")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "P")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (replace
                                                                                                                       "signame")
                                                                                                                      (("2"
                                                                                                                        (inst
                                                                                                                         -
                                                                                                                         "mm")
                                                                                                                        (("2"
                                                                                                                          (inst-cp
                                                                                                                           -
                                                                                                                           "i")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "1+i")
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (inst
                                                                                         -
                                                                                         "P")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "mm"
                                                                                             "1+mm")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (replace -2)
                                                        (("2"
                                                          (case
                                                           "ssp`length >= 2")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (lemma
                                                               "partition_strictly_sort")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "a"
                                                                 "b")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (hide 2)
                                                  (("3"
                                                    (skeep)
                                                    (("3"
                                                      (case "mm < 0")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        (("2"
                                                          (typepred
                                                           "sig(mm)")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (case
                                                               "NOT sig(mm) = P`length-1")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (typepred
                                                                 "sig")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "mm")
                                                                  (("2"
                                                                    (replace
                                                                     "sspname")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (typepred
                                                                           "sig")
                                                                          (("2"
                                                                            (hide
                                                                             -1)
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "ssp`length-1")
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (typepred
                                                                                     "ssp")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "strictly_increasing?")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "mm"
                                                                                         "ssp`length-1")
                                                                                        (("2"
                                                                                          (ground)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("4"
                                                  (skosimp*)
                                                  (("4"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("5"
                                                  (skosimp*)
                                                  (("5"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("6"
                                                  (skosimp*)
                                                  (("6"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("7"
                                                  (lemma
                                                   "partition_strictly_sort")
                                                  (("7"
                                                    (inst - "a" "b")
                                                    (("7"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("3"
                                            (hide 2)
                                            (("3"
                                              (skeep)
                                              (("3"
                                                (case "mm < 0")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  (("2"
                                                    (typepred
                                                     "sig(mm)")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case
                                                         "NOT sig(mm) = P`length-1")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (typepred
                                                           "sig")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "mm")
                                                            (("2"
                                                              (replace
                                                               -6)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (typepred
                                                                     "sig")
                                                                    (("2"
                                                                      (hide
                                                                       -1)
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "ssp`length-1")
                                                                        (("2"
                                                                          (flatten)
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (typepred
                                                                               "ssp")
                                                                              (("2"
                                                                                (expand
                                                                                 "strictly_increasing?")
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "mm"
                                                                                   "ssp`length-1")
                                                                                  (("2"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("4"
                                            (skosimp*)
                                            (("4" (assertnil nil))
                                            nil)
                                           ("5"
                                            (skosimp*)
                                            (("5" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (skeep)
                            (("2" (hide -2) (("2" (ground) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("3" (hide -1)
                (("3" (skeep)
                  (("3" (assert)
                    (("3" (hide 2)
                      (("3" (split +)
                        (("1" (skeep)
                          (("1" (expand "XISfun")
                            (("1" (lift-if) (("1" (ground) nil nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "XISfun")
                          (("2" (lemma "partition_strictly_sort")
                            (("2" (inst - "a" "b")
                              (("2"
                                (assert)
                                (("2"
                                  (inst - "P")
                                  (("2" (ground) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("3" (expand "XISfun")
                          (("3" (propax) nil nil)) nil)
                         ("4" (skeep)
                          (("4" (expand "XISfun")
                            (("4" (name "sig" "strictly_sort_map(P)")
                              (("4"
                                (replace -1)
                                (("4"
                                  (typepred "ii")
                                  (("4"
                                    (typepred "sig")
                                    (("4"
                                      (inst - "ii")
                                      (("4"
                                        (flatten)
                                        (("4"
                                          (assert)
                                          (("4"
                                            (typepred "xis")
                                            (("4"
                                              (inst - "sig(ii)")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (case
                                                 "sig(ii) = P`length-1")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (lemma
                                                       "strictly_sort_map_increasing")
                                                      (("1"
                                                        (inst - "P")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "ii"
                                                             "strictly_sort(P)`length-1")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("4" (hide 2)
                (("4" (skeep)
                  (("4" (lemma "partition_strictly_sort")
                    (("4" (inst - "a" "b")
                      (("4" (assert) (("4" (inst - "P"nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("5" (assertnil nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skeep)
              (("2" (lemma "partition_strictly_sort")
                (("2" (inst - "a" "b") (("2" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((default const-decl "T" fseqs "structures/")
    (strictly_sort_map const-decl
     "{sq: [below(strictly_sort(s)`length) -> below(s`length)] |
         LET sss = strictly_sort(s) IN
           (increasing?(s) AND sss`length >= 1 IMPLIES
             sq(sss`length - 1) = s`length - 1)
            AND
            (FORALL (ii: below(sss`length)):
               (sss`seq(ii) = s`seq(sq(ii)) AND
                 (increasing?(s) AND ii < sss`length - 1 IMPLIES
                   sss`seq(ii + 1) = s`seq(sq(ii) + 1))))}" sort_fseq
     "structures/")
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (strictly_sort const-decl "{ss: fseq |
         strictly_increasing?(ss) AND
          (FORALL (x: T): member(x, s) IFF member(x, ss))}" sort_fseq
     "structures/")
    (member const-decl "bool" fseqs "structures/")
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (strictly_increasing? const-decl "bool" sort_fseq "structures/")
    (xis? type-eq-decl nil rs_integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (> const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (T formal-nonempty-subtype-decl nil rs_integral_def nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_def 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (reflexive_restrict application-judgement "(reflexive?[S])"
     restrict_order_props nil)
    (antisymmetric_restrict application-judgement "(antisymmetric?[S])"
     restrict_order_props nil)
    (transitive_restrict application-judgement "(transitive?[S])"
     restrict_order_props nil)
    (preorder_restrict application-judgement "(preorder?[S])"
     restrict_order_props nil)
    (partial_order_restrict application-judgement "(partial_order?[S])"
     restrict_order_props nil)
    (dichotomous_restrict application-judgement "(dichotomous?[S])"
     restrict_order_props nil)
    (total_order_restrict application-judgement "(total_order?[S])"
     restrict_order_props nil)
    (Rie_sum const-decl "real" rs_integral_def 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)
    (partition_union_strictly_sort_map_inv formula-decl nil
     rs_partition nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (yis skolem-const-decl "[# length: int, seq: [nat -> T] #]"
     rs_integral_def nil)
    (partition_union_is_strictly_sort formula-decl nil rs_partition
     nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (partition_union_map const-decl
     "{pm: [below(P`length) -> below(partition_union(a, b)(P, Q)`length)] |
         FORALL (ii: below(P`length)):
           P`seq(ii) = partition_union(a, b)(P, Q)`seq(pm(ii))}"
     rs_partition nil)
    (partition_union const-decl "{PQ: partition(a, b) |
         (FORALL (x: T): member(x, PQ) IFF (member(x, P) OR member(x, Q)))
          AND strictly_increasing?(PQ)}" rs_partition nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (a skolem-const-decl "T" rs_integral_def nil)
    (b skolem-const-decl "T" rs_integral_def nil)
    (P skolem-const-decl "partition[T](a, b)" rs_integral_def nil)
    (XISfun skolem-const-decl
     "[xis?(a, b, P) -> [# length: int, seq: [nat -> T] #]]"
     rs_integral_def nil)
    (xis skolem-const-decl "xis?(a, b, P)" rs_integral_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sigma_0_neg formula-decl nil sigma_below "reals/")
    (sigma_split formula-decl nil sigma "reals/")
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (subrange type-eq-decl nil integers nil)
    (strictly_sort_map_between formula-decl nil sort_fseq
     "structures/")
    (fseq_length_zero formula-decl nil fseqs "structures/")
    (empty_seq_fseq name-judgement "fseq[T]" rs_integral_def nil)
    (partition_strictly_sort formula-decl nil rs_partition nil)
    (strictly_sort_map_increasing formula-decl nil sort_fseq
     "structures/")
    (jj skolem-const-decl "int" rs_integral_def nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (ssp skolem-const-decl "{ss: fseq[T] |
         strictly_increasing?(ss) AND
          (FORALL (x: T): member(x, P) IFF member(x, ss))}"
     rs_integral_def nil)
    (yis skolem-const-decl "[# length: int, seq: [nat -> T] #]"
     rs_integral_def nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (below_induction formula-decl nil bounded_nat_inductions nil)
    (pred type-eq-decl nil defined_types nil)
    (sig skolem-const-decl
         "{sq: [below(strictly_sort(P)`length) -> below(P`length)] |
         (strictly_sort(P)`length >= 1 IMPLIES
           sq(strictly_sort(P)`length - 1) = P`length - 1)
          AND
          (FORALL (ii: below(strictly_sort(P)`length)):
             (strictly_sort(P)`seq(ii) = P`seq(sq(ii)) AND
               (ii < strictly_sort(P)`length - 1 IMPLIES
                 strictly_sort(P)`seq(1 + ii) = P`seq(1 + sq(ii)))))}"
         rs_integral_def nil)
    (sig skolem-const-decl
         "{sq: [below(strictly_sort(P)`length) -> below(P`length)] |
         (strictly_sort(P)`length >= 1 IMPLIES
           sq(strictly_sort(P)`length - 1) = P`length - 1)
          AND
          (FORALL (ii: below(strictly_sort(P)`length)):
             (strictly_sort(P)`seq(ii) = P`seq(sq(ii)) AND
               (ii < strictly_sort(P)`length - 1 IMPLIES
                 strictly_sort(P)`seq(1 + ii) = P`seq(1 + sq(ii)))))}"
         rs_integral_def nil)
    (ii skolem-const-decl "below(strictly_sort(P)`length - 1)"
     rs_integral_def nil))
   nil)
  (Riemann_sum_strictly_sort-2 nil 3492270772
   ("" (skeep)
    (("" (skeep)
      ((""
        (name "XISfun"
              "(LAMBDA (xis:xis?(a,b,P)): (# length := strictly_sort(P)`length-1, seq := (LAMBDA (ii:nat): IF ii < strictly_sort(P)`length-1 THEN xis`seq(strictly_sort_map(P)(ii)) ELSE default[T] ENDIF) #))")
        (("1" (label "XISfunname" -1)
          (("1"
            (case "FORALL (xis:xis?(a,b,P)): Rie_sum(a,b,g,P,xis,f) = Rie_sum(a,b,g,strictly_sort(P),XISfun(xis),f)")
            (("1" (ground)
              (("1" (skeep -)
                (("1" (inst - "xis")
                  (("1" (inst + "XISfun(xis)")
                    (("1" (assertnil nil)
                     ("2" (assert)
                      (("2" (expand "XISfun" +)
                        (("2" (assert)
                          (("2" (typepred "strictly_sort(P)")
                            (("2" (inst - "a")
                              (("2"
                                (case "member(a,P)")
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (assert)
                                      (("1" (skosimp*) nil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (inst + "0")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (skeep -)
                (("2" (assert)
                  (("2"
                    (case "FORALL (xiss:xis?(a,b,strictly_sort(P))): EXISTS (xis:xis?(a,b,P)): xiss = XISfun(xis)")
                    (("1" (inst - "xis")
                      (("1" (skolem -1 "xisp")
                        (("1" (inst - "xisp")
                          (("1" (inst + "xisp")
                            (("1" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide -1)
                      (("2" (hide -1)
                        (("2" (hide 2)
                          (("2" (skeep)
                            (("2"
                              (name "sig"
                                    "partition_union_map(a,b,P,P)")
                              (("2"
                                (label "signame" -1)
                                (("2"
                                  (typepred "sig")
                                  (("2"
                                    (label "sigtp" -1)
                                    (("2"
                                      (name
                                       "yis"
                                       "(# length := P`length-1, seq := (LAMBDA (ii:nat): IF ii < P`length-1 THEN IF sig(ii) = strictly_sort(P)`length-1 THEN b ELSIF sig(ii) = sig(ii+1) THEN P`seq(ii) ELSE xiss`seq(sig(ii)) ENDIF ELSE default[T] ENDIF) #)")
                                      (("1"
                                        (label "yisname" -1)
                                        (("1"
                                          (lemma
                                           "partition_union_is_strictly_sort")
                                          (("1"
                                            (inst - "a" "b")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (inst - "P")
                                                (("1"
                                                  (label
                                                   "unionsort"
                                                   -1)
                                                  (("1"
                                                    (replace
                                                     "unionsort")
                                                    (("1"
                                                      (stop-rewrite
                                                       "xis_lem")
                                                      (("1"
                                                        (inst + "yis")
                                                        (("1"
                                                          (expand
                                                           "XISfun"
                                                           +)
                                                          (("1"
                                                            (decompose-equality
                                                             +)
                                                            (("1"
                                                              (decompose-equality
                                                               +)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (ground)
                                                                  (("1"
                                                                    (expand
                                                                     "yis"
                                                                     +)
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (ground)
                                                                        (("1"
                                                                          (name
                                                                           "ssm"
                                                                           "strictly_sort_map(P)")
                                                                          (("1"
                                                                            (replace
                                                                             -1)
                                                                            (("1"
                                                                              (label
                                                                               "ssmname"
                                                                               -1)
                                                                              (("1"
                                                                                (lemma
                                                                                 "partition_union_strictly_sort_map_inv")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "a"
                                                                                   "b")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "P"
                                                                                       "x!1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (name
                                                                             "ssm"
                                                                             "strictly_sort_map(P)")
                                                                            (("2"
                                                                              (replace
                                                                               -1)
                                                                              (("2"
                                                                                (label
                                                                                 "ssmname"
                                                                                 -1)
                                                                                (("2"
                                                                                  (typepred
                                                                                   "ssm")
                                                                                  (("2"
                                                                                    (lemma
                                                                                     "partition_union_strictly_sort_map_inv")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "a"
                                                                                       "b")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "P"
                                                                                           "x!1")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (replace
                                                                                               "ssmname")
                                                                                              (("2"
                                                                                                (replace
                                                                                                 "signame")
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "x!1")
                                                                                                    (("2"
                                                                                                      (flatten)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (typepred
                                                                                                           "sig")
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "1+ssm(x!1)")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (typepred
                                                                                                                 "sig")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "ssm(x!1)")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (case
                                                                                                                       "NOT P`seq(ssm(x!1)) = P`seq(1+ssm(x!1))")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (typepred
                                                                                                                         "xiss")
                                                                                                                        (("2"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "x!1")
                                                                                                                          (("2"
                                                                                                                            (flatten)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (name
                                                                           "ssm"
                                                                           "strictly_sort_map(P)")
                                                                          (("3"
                                                                            (replace
                                                                             -1)
                                                                            (("3"
                                                                              (label
                                                                               "ssmname"
                                                                               -1)
                                                                              (("3"
                                                                                (lemma
                                                                                 "partition_union_strictly_sort_map_inv")
                                                                                (("3"
                                                                                  (inst
                                                                                   -
                                                                                   "a"
                                                                                   "b")
                                                                                  (("3"
                                                                                    (assert)
                                                                                    (("3"
                                                                                      (inst
                                                                                       -
                                                                                       "P"
                                                                                       "x!1")
                                                                                      (("3"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("4"
                                                                          (name
                                                                           "ssm"
                                                                           "strictly_sort_map(P)")
                                                                          (("4"
                                                                            (replace
                                                                             -1)
                                                                            (("4"
                                                                              (label
                                                                               "ssmname"
                                                                               -1)
                                                                              (("4"
                                                                                (typepred
                                                                                 "ssm")
                                                                                (("4"
                                                                                  (assert)
                                                                                  (("4"
                                                                                    (inst
                                                                                     -
                                                                                     "x!1")
                                                                                    (("4"
                                                                                      (flatten)
                                                                                      (("4"
                                                                                        (assert)
                                                                                        (("4"
                                                                                          (typepred
                                                                                           "strictly_sort(P)")
                                                                                          (("4"
                                                                                            (expand
                                                                                             "strictly_increasing?")
                                                                                            (("4"
                                                                                              (inst
                                                                                               -
                                                                                               "x!1"
                                                                                               "strictly_sort(P)`length-1")
                                                                                              (("4"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (typepred
                                                                     "xiss`seq")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (skosimp*)
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (split +)
                                                          (("1"
                                                            (skosimp*)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "yis"
                                                                 +)
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (skeep)
                                                            (("2"
                                                              (split +)
                                                              (("1"
                                                                (expand
                                                                 "yis"
                                                                 +)
                                                                (("1"
                                                                  (lift-if)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (split
                                                                       +)
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (typepred
                                                                             "xiss")
                                                                            (("1"
                                                                              (typepred
                                                                               "sig")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "ii")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (ground)
                                                                          (("2"
                                                                            (typepred
                                                                             "xiss")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "sig(ii)")
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (typepred
                                                                                   "sig")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "ii")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "yis"
                                                                 +)
                                                                (("2"
                                                                  (lift-if)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (ground)
                                                                      (("1"
                                                                        (typepred
                                                                         "sig")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "ii")
                                                                          (("1"
                                                                            (typepred
                                                                             "P")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "ii+1")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (expand
                                                                                   "increasing?")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "ii"
                                                                                     "1+ii")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (typepred
                                                                         "P")
                                                                        (("2"
                                                                          (expand
                                                                           "increasing?")
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "ii"
                                                                             "1+ii")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("3"
                                                                        (typepred
                                                                         "xiss")
                                                                        (("3"
                                                                          (inst
                                                                           -
                                                                           "sig(ii)")
                                                                          (("3"
                                                                            (flatten)
                                                                            (("3"
                                                                              (case
                                                                               "1+sig(ii) <= sig(1+ii)")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (typepred
                                                                                   "strictly_sort(P)")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "strictly_increasing?")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "1+sig(ii)"
                                                                                       "sig(1+ii)")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (typepred
                                                                                           "sig")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "1+ii")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (typepred
                                                                                 "sig")
                                                                                (("2"
                                                                                  (inst-cp
                                                                                   -
                                                                                   "ii")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "ii+1")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (typepred
                                                                                         "strictly_sort(P)")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "strictly_increasing?")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "sig(1+ii)"
                                                                                             "sig(ii)")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (typepred
                                                                                                   "P")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "increasing?")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "ii"
                                                                                                       "1+ii")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skosimp*)
                                        (("2" (assertnil 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))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide ("xispred" "XISfunname"))
              (("2" (hide 2)
                (("2" (skeep)
                  (("2" (expand "XISfun")
                    (("2"
                      (name "yis"
                            "(# length := strictly_sort(P)`length-1, seq := (LAMBDA (ii:nat): IF ii < strictly_sort(P)`length-1 THEN xis`seq(strictly_sort_map(P)(ii)) ELSE default[T] ENDIF) #)")
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (expand "Rie_sum")
                            (("1" (name "ssp" "strictly_sort(P)")
                              (("1"
                                (label "sspname" -1)
                                (("1"
                                  (replace "sspname")
                                  (("1"
                                    (name "sig" "strictly_sort_map(P)")
                                    (("1"
                                      (label "signame" -1)
                                      (("1"
                                        (case
                                         "FORALL (mm:below(ssp`length-1)): sigma[below(strictly_sort(P)`length - 1)]
                                                                                                                                                      (0, mm,
                                                                                                                                                       LAMBDA (n: below(strictly_sort(P)`length - 1)):
                                                                                                                                                         f(yis`seq(n)) * g(ssp`seq(1 + n)) -
                                                                                                                                                          f(yis`seq(n)) * g(ssp`seq(n))) = sigma[below(P`length - 1)]
                                                                                                                                                     (0, sig(mm),
                                                                                                                                                      LAMBDA (n: below(P`length - 1)):
                                                                                                                                                        f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n)))")
                                        (("1"
                                          (inst - "ssp`length-2")
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma
                                                 "sigma_split[below(P`length-1)]")
                                                (("1"
                                                  (inst
                                                   -
                                                   "LAMBDA (n: below(P`length - 1)):
                                                                                                                                             f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n))"
                                                   "P`length-2"
                                                   "0"
                                                   "sig(ssp`length - 2)")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (case
                                                       "sig(ssp`length-2) <= P`length-2")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (replace -2)
                                                          (("1"
                                                            (case
                                                             "sigma(1 + sig(ssp`length - 2), P`length - 2,
                                                                                                                                                                                                                                                LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                  f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                                   f(xis`seq(n)) * g(P`seq(n))) = 0")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (hide
                                                                 -2)
                                                                (("2"
                                                                  (rewrite
                                                                   "sigma_restrict_eq_0")
                                                                  (("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (skeep)
                                                                      (("2"
                                                                        (typepred
                                                                         "i")
                                                                        (("2"
                                                                          (case
                                                                           "g(P`seq(1+i)) = g(P`seq(i))")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (typepred
                                                                               "sig")
                                                                              (("2"
                                                                                (hide
                                                                                 -1)
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "ssp`length-2")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (name
                                                                                         "jj"
                                                                                         "ssp`length-2")
                                                                                        (("1"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("1"
                                                                                            (case
                                                                                             "ssp`length-1 = jj+1")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1)
                                                                                              (("1"
                                                                                                (case
                                                                                                 "P`seq(1+i) = P`seq(i)")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (lemma
                                                                                                     "strictly_sort_map_between")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "P")
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         "sspname")
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           "signame")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "jj")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "i")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (case
                                                                                                                     "P`seq(sig(1+jj)) = P`seq(1+i)")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (case
                                                                                                                         "1+sig(jj) <= sig(jj+1)")
                                                                                                                        (("1"
                                                                                                                          (case
                                                                                                                           "sig(jj+1) = P`length-1")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil)
                                                                                                                           ("2"
                                                                                                                            (replace
                                                                                                                             -3
                                                                                                                             :dir
                                                                                                                             rl)
                                                                                                                            (("2"
                                                                                                                              (typepred
                                                                                                                               "sig")
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (case
                                                                                                                                   "NOT P`length = 0")
                                                                                                                                  (("1"
                                                                                                                                    (lemma
                                                                                                                                     "fseq_length_zero")
                                                                                                                                    (("1"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "ssp")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        (("1"
                                                                                                                                          (typepred
                                                                                                                                           "ssp")
                                                                                                                                          (("1"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "P`seq(0)")
                                                                                                                                            (("1"
                                                                                                                                              (case
                                                                                                                                               "member(P`seq(0),P)")
                                                                                                                                              (("1"
                                                                                                                                                (replace
                                                                                                                                                 -1)
                                                                                                                                                (("1"
                                                                                                                                                  (hide
                                                                                                                                                   -1)
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    (("1"
                                                                                                                                                      (skosimp*)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (expand
                                                                                                                                                 "member")
                                                                                                                                                (("2"
                                                                                                                                                  (inst
                                                                                                                                                   +
                                                                                                                                                   "0")
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("3"
                                                                                                                            (lemma
                                                                                                                             "fseq_length_zero")
                                                                                                                            (("3"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "ssp")
                                                                                                                              (("3"
                                                                                                                                (assert)
                                                                                                                                (("3"
                                                                                                                                  (typepred
                                                                                                                                   "ssp")
                                                                                                                                  (("3"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "P`seq(0)")
                                                                                                                                    (("3"
                                                                                                                                      (case
                                                                                                                                       "member(P`seq(0),P)")
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -1)
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          (("1"
                                                                                                                                            (skosimp*)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (expand
                                                                                                                                         "member")
                                                                                                                                        (("2"
                                                                                                                                          (inst
                                                                                                                                           +
                                                                                                                                           "0")
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (lemma
                                                                                                                           "strictly_sort_map_increasing")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "P")
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "jj"
                                                                                                                                 "1+jj")
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (assert)
                                                                                                                                  (("2"
                                                                                                                                    (lemma
                                                                                                                                     "fseq_length_zero")
                                                                                                                                    (("2"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "ssp")
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (typepred
                                                                                                                                           "ssp")
                                                                                                                                          (("2"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "P`seq(0)")
                                                                                                                                            (("2"
                                                                                                                                              (case
                                                                                                                                               "member(P`seq(0),P)")
                                                                                                                                              (("1"
                                                                                                                                                (replace
                                                                                                                                                 -1)
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (skosimp*)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (expand
                                                                                                                                                 "member")
                                                                                                                                                (("2"
                                                                                                                                                  (inst
                                                                                                                                                   +
                                                                                                                                                   "0")
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("3"
                                                                                                                                  (lemma
                                                                                                                                   "partition_strictly_sort")
                                                                                                                                  (("3"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "a"
                                                                                                                                     "b")
                                                                                                                                    (("3"
                                                                                                                                      (assert)
                                                                                                                                      (("3"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "P")
                                                                                                                                        (("3"
                                                                                                                                          (flatten)
                                                                                                                                          (("3"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("3"
                                                                                                                          (lemma
                                                                                                                           "partition_strictly_sort")
                                                                                                                          (("3"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "a"
                                                                                                                             "b")
                                                                                                                            (("3"
                                                                                                                              (assert)
                                                                                                                              (("3"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "P")
                                                                                                                                (("3"
                                                                                                                                  (flatten)
                                                                                                                                  (("3"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("4"
                                                                                                                          (lemma
                                                                                                                           "partition_strictly_sort")
                                                                                                                          (("4"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "a"
                                                                                                                             "b")
                                                                                                                            (("4"
                                                                                                                              (assert)
                                                                                                                              (("4"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "P")
                                                                                                                                (("4"
                                                                                                                                  (flatten)
                                                                                                                                  (("4"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (lemma
                                                                                                                         "strictly_sort_map_between")
                                                                                                                        (("2"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "P")
                                                                                                                          (("2"
                                                                                                                            (replace
                                                                                                                             -11)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (replace
                                                                                                                                 -3
                                                                                                                                 +
                                                                                                                                 :dir
                                                                                                                                 rl)
                                                                                                                                (("2"
                                                                                                                                  (typepred
                                                                                                                                   "sig")
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (split
                                                                                                                                       -)
                                                                                                                                      (("1"
                                                                                                                                        (hide
                                                                                                                                         -2)
                                                                                                                                        (("1"
                                                                                                                                          (replace
                                                                                                                                           "sspname")
                                                                                                                                          (("1"
                                                                                                                                            (replace
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "jj")
                                                                                                                                                (("1"
                                                                                                                                                  (inst
                                                                                                                                                   -
                                                                                                                                                   "1+i")
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil)
                                                                                                                                                 ("2"
                                                                                                                                                  (assert)
                                                                                                                                                  (("2"
                                                                                                                                                    (lemma
                                                                                                                                                     "partition_strictly_sort")
                                                                                                                                                    (("2"
                                                                                                                                                      (inst
                                                                                                                                                       -
                                                                                                                                                       "a"
                                                                                                                                                       "b")
                                                                                                                                                      (("2"
                                                                                                                                                        (assert)
                                                                                                                                                        (("2"
                                                                                                                                                          (inst
                                                                                                                                                           -
                                                                                                                                                           "P")
                                                                                                                                                          (("2"
                                                                                                                                                            (flatten)
                                                                                                                                                            (("2"
                                                                                                                                                              (assert)
                                                                                                                                                              nil
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (lemma
                                                                                                                                         "partition_strictly_sort")
                                                                                                                                        (("2"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           "a"
                                                                                                                                           "b")
                                                                                                                                          (("2"
                                                                                                                                            (assert)
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "P")
                                                                                                                                              (("2"
                                                                                                                                                (flatten)
                                                                                                                                                (("2"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("3"
                                                                                                                      (lemma
                                                                                                                       "partition_strictly_sort")
                                                                                                                      (("3"
                                                                                                                        (inst
                                                                                                                         -
                                                                                                                         "a"
                                                                                                                         "b")
                                                                                                                        (("3"
                                                                                                                          (assert)
                                                                                                                          (("3"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "P")
                                                                                                                            (("3"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (lemma
                                                                                                                 "partition_strictly_sort")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "a"
                                                                                                                   "b")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "P")
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (lemma
                                                                                     "partition_strictly_sort")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "a"
                                                                                       "b")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "P")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide (-1 2))
                                                        (("2"
                                                          (typepred
                                                           "sig")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (case
                                                               "strictly_sort(P)`length >= 1")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (replace
                                                                   "sspname")
                                                                  (("1"
                                                                    (inst-cp
                                                                     -
                                                                     "ssp`length-2")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "ssp`length-1")
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (case
                                                                             "NOT sig(ssp`length-2) = P`length-1")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (replace
                                                                               -1)
                                                                              (("2"
                                                                                (typepred
                                                                                 "ssp")
                                                                                (("2"
                                                                                  (expand
                                                                                   "strictly_increasing?")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "ssp`length-2"
                                                                                     "ssp`length-1")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil)
                                                                                     ("2"
                                                                                      (lemma
                                                                                       "partition_strictly_sort")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "a"
                                                                                         "b")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "P")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (lemma
                                                                       "partition_strictly_sort")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "a"
                                                                         "b")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "P")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (lemma
                                                                 "partition_strictly_sort")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "a"
                                                                   "b")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "P")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (lemma
                                                         "partition_strictly_sort")
                                                        (("3"
                                                          (inst
                                                           -
                                                           "a"
                                                           "b")
                                                          (("3"
                                                            (assert)
                                                            (("3"
                                                              (inst
                                                               -
                                                               "P")
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma
                                                     "partition_strictly_sort")
                                                    (("2"
                                                      (inst - "a" "b")
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (inst - "P")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (lemma
                                             "partition_strictly_sort")
                                            (("2"
                                              (inst - "a" "b")
                                              (("2"
                                                (assert)
                                                (("1"
                                                  (inst - "P")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (lemma
                                                   "partition_strictly_sort")
                                                  (("2"
                                                    (expand "ssp")
                                                    (("2"
                                                      (typepred
                                                       "strictly_sort(P)")
                                                      (("2"
                                                        (inst-cp - "a")
                                                        (("2"
                                                          (inst - "b")
                                                          (("2"
                                                            (case
                                                             "member(b,P) and member(a,P)")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (replace
                                                                   -2)
                                                                  (("1"
                                                                    (hide
                                                                     -1)
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (expand
                                                                         "member")
                                                                        (("1"
                                                                          (skosimp*)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (split)
                                                                  (("1"
                                                                    (inst
                                                                     +
                                                                     "P`length-1")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (inst
                                                                     +
                                                                     "0")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2)
                                          (("2"
                                            (label "altb" -3)
                                            (("2"
                                              (induct "mm")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (expand "sigma")
                                                  (("1"
                                                    (expand
                                                     "sigma"
                                                     1
                                                     1)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lift-if)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (case
                                                             "sigma(0, sig(0) - 1,
                                                                                                                                                                                                    LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                      f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                       f(xis`seq(n)) * g(P`seq(n))) = 0")
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (typepred
                                                                   "sig")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "0")
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (replace
                                                                           "sspname")
                                                                          (("1"
                                                                            (replace
                                                                             -2
                                                                             :dir
                                                                             rl)
                                                                            (("1"
                                                                              (replace
                                                                               -3
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (expand
                                                                                 "yis")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (rewrite
                                                                 "sigma_restrict_eq_0")
                                                                (("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (skeep)
                                                                    (("2"
                                                                      (typepred
                                                                       "i")
                                                                      (("2"
                                                                        (case
                                                                         "P`seq(1+i) = P`seq(i)")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (typepred
                                                                             "sig")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "0")
                                                                              (("2"
                                                                                (hide
                                                                                 -1)
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (hide
                                                                                       -2)
                                                                                      (("2"
                                                                                        (case
                                                                                         "P`seq(sig(0)) = a")
                                                                                        (("1"
                                                                                          (typepred
                                                                                           "P")
                                                                                          (("1"
                                                                                            (copy
                                                                                             -4)
                                                                                            (("1"
                                                                                              (case
                                                                                               "P`seq(i) = a AND P`seq(1+i) = a")
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (split
                                                                                                   +)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "increasing?"
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (inst-cp
                                                                                                       -
                                                                                                       "0"
                                                                                                       "i")
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "i"
                                                                                                         "sig(0)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (expand
                                                                                                     "increasing?"
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (inst-cp
                                                                                                       -
                                                                                                       "0"
                                                                                                       "1+i")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "1+i"
                                                                                                         "sig(0)")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (lemma
                                                                                           "partition_strictly_sort")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "a"
                                                                                             "b")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -
                                                                                                 "P")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (skolem 1 "mm")
                                                (("2"
                                                  (assert)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (expand
                                                       "sigma"
                                                       1
                                                       1)
                                                      (("1"
                                                        (replace -2)
                                                        (("1"
                                                          (lemma
                                                           "strictly_sort_map_increasing")
                                                          (("1"
                                                            (expand
                                                             "sigma"
                                                             1
                                                             2)
                                                            (("1"
                                                              (lift-if)
                                                              (("1"
                                                                (ground)
                                                                (("1"
                                                                  (expand
                                                                   "yis"
                                                                   +)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (replace
                                                                       "signame")
                                                                      (("1"
                                                                        (case
                                                                         "f(xis`seq(sig(1 + mm))) * g(ssp`seq(2 + mm))
                                                                                                                                                                                                                    - f(xis`seq(sig(1 + mm))) * g(ssp`seq(1 + mm)) = f(xis`seq(sig(1 + mm))) * g(P`seq(1 + sig(1 + mm)))
                                                                                                                                                                                                                     - f(xis`seq(sig(1 + mm))) * g(P`seq(sig(1 + mm))) AND sigma[below(P`length - 1)]
                                                                                                                                                                                                                       (0, sig(mm),
                                                                                                                                                                                                                        LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                          f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n))) = sigma(0, sig(1 + mm) - 1,
                                                                                                                                                                                                                          LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                            f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                             f(xis`seq(n)) * g(P`seq(n)))")
                                                                        (("1"
                                                                          (flatten)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           3)
                                                                          (("2"
                                                                            (split
                                                                             +)
                                                                            (("1"
                                                                              (typepred
                                                                               "sig")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "1+mm")
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (lemma
                                                                               "sigma_split[below(P`length-1)]")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "(LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                 f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                  f(xis`seq(n)) * g(P`seq(n)))"
                                                                                 "sig(1+mm)-1"
                                                                                 "0"
                                                                                 "sig(mm)")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (split
                                                                                     -)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -1)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("1"
                                                                                          (case
                                                                                           "sigma(1 + sig(mm), sig(1 + mm) - 1,
                                                                                                                                                                                                                                                                                             (LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                                                                                f(xis`seq(n)) * g(P`seq(1 + n)) -
                                                                                                                                                                                                                                                                                                 f(xis`seq(n)) * g(P`seq(n)))) = 0")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide
                                                                                             2)
                                                                                            (("2"
                                                                                              (rewrite
                                                                                               "sigma_restrict_eq_0")
                                                                                              (("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (hide
                                                                                                     -2)
                                                                                                    (("2"
                                                                                                      (skeep)
                                                                                                      (("2"
                                                                                                        (typepred
                                                                                                         "i")
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "P`seq(i) = P`seq(1+i)")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("2"
                                                                                                              (lemma
                                                                                                               "strictly_sort_map_between")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "P")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (replace
                                                                                                                     "signame")
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "mm")
                                                                                                                      (("2"
                                                                                                                        (inst-cp
                                                                                                                         -
                                                                                                                         "i")
                                                                                                                        (("2"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "1+i")
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (inst
                                                                                       -
                                                                                       "P")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "mm"
                                                                                           "1+mm")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (replace -2)
                                                      (("2"
                                                        (case
                                                         "ssp`length >= 2")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (lemma
                                                             "partition_strictly_sort")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "a"
                                                               "b")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (hide 2)
                                                (("3"
                                                  (skeep)
                                                  (("3"
                                                    (case "mm < 0")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      (("2"
                                                        (typepred
                                                         "sig(mm)")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (case
                                                             "NOT sig(mm) = P`length-1")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (typepred
                                                               "sig")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "mm")
                                                                (("2"
                                                                  (replace
                                                                   "sspname")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (typepred
                                                                         "sig")
                                                                        (("2"
                                                                          (hide
                                                                           -1)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "ssp`length-1")
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (typepred
                                                                                   "ssp")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "strictly_increasing?")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "mm"
                                                                                       "ssp`length-1")
                                                                                      (("2"
                                                                                        (ground)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("4"
                                                (skosimp*)
                                                (("4"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("5"
                                                (skosimp*)
                                                (("5"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("6"
                                                (skosimp*)
                                                (("6"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("7"
                                                (lemma
                                                 "partition_strictly_sort")
                                                (("7"
                                                  (inst - "a" "b")
                                                  (("7"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (hide 2)
                                          (("3"
                                            (skeep)
                                            (("3"
                                              (case "mm < 0")
                                              (("1" (assertnil nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (typepred "sig(mm)")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (case
                                                       "NOT sig(mm) = P`length-1")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (typepred
                                                         "sig")
                                                        (("2"
                                                          (inst - "mm")
                                                          (("2"
                                                            (replace
                                                             -6)
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (typepred
                                                                   "sig")
                                                                  (("2"
                                                                    (hide
                                                                     -1)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "ssp`length-1")
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (typepred
                                                                             "ssp")
                                                                            (("2"
                                                                              (expand
                                                                               "strictly_increasing?")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "mm"
                                                                                 "ssp`length-1")
                                                                                (("2"
                                                                                  (ground)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("4"
                                          (skosimp*)
                                          (("4" (assertnil nil))
                                          nil)
                                         ("5"
                                          (skosimp*)
                                          (("5" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (skeep)
                          (("2" (hide -2) (("2" (ground) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (hide -1)
              (("3" (skeep)
                (("3" (assert)
                  (("3" (hide 2)
                    (("3" (split +)
                      (("1" (skeep)
                        (("1" (expand "XISfun")
                          (("1" (lift-if) (("1" (ground) nil nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (expand "XISfun")
                          (("2" (propax) nil nil)) nil))
                        nil)
                       ("3" (expand "XISfun") (("3" (propax) nil nil))
                        nil)
                       ("4" (expand "XISfun") (("4" (propax) nil nil))
                        nil)
                       ("5" (expand "XISfun")
                        (("5" (lemma "partition_strictly_sort")
                          (("5" (inst - "a" "b")
                            (("5" (assert)
                              (("5"
                                (inst - "P")
                                (("5" (ground) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("6" (expand "XISfun") (("6" (propax) nil nil))
                        nil)
                       ("7" (skeep)
                        (("7" (expand "XISfun")
                          (("7" (name "sig" "strictly_sort_map(P)")
                            (("7" (replace -1)
                              (("7"
                                (typepred "ii")
                                (("7"
                                  (typepred "sig")
                                  (("7"
                                    (inst - "ii")
                                    (("7"
                                      (flatten)
                                      (("7"
                                        (assert)
                                        (("7"
                                          (typepred "xis")
                                          (("7"
                                            (inst - "sig(ii)")
                                            (("1"
                                              (flatten)
                                              (("1" (assertnil nil))
                                              nil)
                                             ("2"
                                              (case
                                               "sig(ii) = P`length-1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (lemma
                                                     "strictly_sort_map_increasing")
                                                    (("1"
                                                      (inst - "P")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (inst
                                                           -
                                                           "ii"
                                                           "strictly_sort(P)`length-1")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("4" (hide 2)
              (("4" (skeep)
                (("4" (lemma "partition_strictly_sort")
                  (("4" (inst - "a" "b")
                    (("4" (assert) (("4" (inst - "P"nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil)
             ("5" (assertnil nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (skeep)
            (("2" (lemma "partition_strictly_sort")
              (("2" (inst - "a" "b") (("2" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (strictly_sort_map_increasing formula-decl nil sort_fseq
     "structures/")
    (fseq_length_zero formula-decl nil fseqs "structures/")
    (strictly_sort_map_between formula-decl nil sort_fseq
     "structures/")
    (sigma_split formula-decl nil sigma "reals/")
    (sigma_0_neg formula-decl nil sigma_below "reals/")
    (sigma def-decl "real" sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (increasing? const-decl "bool" sort_fseq "structures/")
    (strictly_increasing? const-decl "bool" sort_fseq "structures/")
    (member const-decl "bool" fseqs "structures/")
    (strictly_sort const-decl "{ss: fseq |
         strictly_increasing?(ss) AND
          (FORALL (x: T): member(x, s) IFF member(x, ss))}" sort_fseq
     "structures/")
    (strictly_sort_map const-decl
     "{sq: [below(strictly_sort(s)`length) -> below(s`length)] |
         LET sss = strictly_sort(s) IN
           (increasing?(s) AND sss`length >= 1 IMPLIES
             sq(sss`length - 1) = s`length - 1)
            AND
            (FORALL (ii: below(sss`length)):
               (sss`seq(ii) = s`seq(sq(ii)) AND
                 (increasing?(s) AND ii < sss`length - 1 IMPLIES
                   sss`seq(ii + 1) = s`seq(sq(ii) + 1))))}" sort_fseq
     "structures/")
    (default const-decl "T" fseqs "structures/"))
   nil)
  (Riemann_sum_strictly_sort-1 nil 3491668925
   ("" (skeep)
    (("" (skeep)
      (("" (typepred "RS")
        (("" (label "altb" -2)
          (("" (expand "Riemann_sum?")
            (("" (skeep -1)
              ((""
                (name "yis"
                      "(# length := strictly_sort(P)`length-1, seq := (LAMBDA (ii:nat): IF ii < strictly_sort(P)`length-1 THEN xis`seq(strictly_sort_map(P)(ii)) ELSE default[real] ENDIF) #)")
                (("1" (inst + "yis")
                  (("1" (hide -1)
                    (("1" (replace -1)
                      (("1" (hide -1)
                        (("1" (expand "Rie_sum")
                          (("1" (name "ssp" "strictly_sort(P)")
                            (("1" (label "sspname" -1)
                              (("1"
                                (replace "sspname")
                                (("1"
                                  (name "sig" "strictly_sort_map(P)")
                                  (("1"
                                    (label "signame" -1)
                                    (("1"
                                      (case
                                       "FORALL (mm:below(ssp`length-1)): sigma[below(strictly_sort(P)`length - 1)]
                      (0, mm,
                       LAMBDA (n: below(strictly_sort(P)`length - 1)):
                         f(yis`seq(n)) * g(ssp`seq(1 + n)) -
                          f(yis`seq(n)) * g(ssp`seq(n))) = sigma[below(P`length - 1)]
                     (0, sig(mm),
                      LAMBDA (n: below(P`length - 1)):
                        f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n)))")
                                      (("1"
                                        (inst - "ssp`length-2")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma
                                               "sigma_split[below(P`length-1)]")
                                              (("1"
                                                (inst
                                                 -
                                                 "LAMBDA (n: below(P`length - 1)):
                       f(xis`seq(n)) * g(P`seq(1 + n)) - f(xis`seq(n)) * g(P`seq(n))"
                                                 "P`length-2"
                                                 "0"
                                                 "sig(ssp`length - 2)")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (case
                                                     "sig(ssp`length-2) <= P`length-2")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (replace -2)
                                                        (("1"
                                                          (case
                                                           "sigma(1 + sig(ssp`length - 2), P`length - 2,
                                LAMBDA (n: below(P`length - 1)):
                                  f(xis`seq(n)) * g(P`seq(1 + n)) -
                                   f(xis`seq(n)) * g(P`seq(n))) = 0")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (hide -2)
                                                              (("2"
                                                                (rewrite
                                                                 "sigma_restrict_eq_0")
                                                                (("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (skeep)
                                                                    (("2"
                                                                      (typepred
                                                                       "i")
                                                                      (("2"
                                                                        (case
                                                                         "g(P`seq(1+i)) = g(P`seq(i))")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (typepred
                                                                             "sig")
                                                                            (("2"
                                                                              (hide
                                                                               -1)
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "ssp`length-2")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (name
                                                                                       "jj"
                                                                                       "ssp`length-2")
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("1"
                                                                                          (case
                                                                                           "ssp`length-1 = jj+1")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (case
                                                                                               "P`seq(1+i) = P`seq(i)")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (lemma
                                                                                                   "strictly_sort_map_between")
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "P")
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       "sspname")
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         "signame")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "jj")
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "i")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (case
                                                                                                                   "P`seq(sig(1+jj)) = P`seq(1+i)")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    (("1"
                                                                                                                      (case
                                                                                                                       "1+sig(jj) <= sig(jj+1)")
                                                                                                                      (("1"
                                                                                                                        (case
                                                                                                                         "sig(jj+1) = P`length-1")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (replace
                                                                                                                           -3
                                                                                                                           :dir
                                                                                                                           rl)
                                                                                                                          (("2"
                                                                                                                            (typepred
                                                                                                                             "sig")
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (case
                                                                                                                                 "NOT P`length = 0")
                                                                                                                                (("1"
                                                                                                                                  (lemma
                                                                                                                                   "fseq_length_zero")
                                                                                                                                  (("1"
--> --------------------

--> maximum size reached

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

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

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

*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.