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

Quelle  polynomial_pseudo_divide.prf

  Sprache: Lisp
 

(polynomial_pseudo_divide
 (pseudo_div_TCC1 0
  (pseudo_div_TCC1-1 nil 3582634590 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (pseudo_div_TCC2 0
  (pseudo_div_TCC2-1 nil 3582634590 ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil))
   nil))
 (pseudo_div_TCC3 0
  (pseudo_div_TCC3-1 nil 3582634590
   ("" (skeep)
    (("" (assert)
      (("" (hide 4) (("" (assert) (("" (grind) nil nil)) nil)) nil))
      nil))
    nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (length def-decl "nat" list_props nil)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (array2list_it def-decl
                   "{l: listn(n - i) | FORALL (j: subrange(i, n - 1)): a(j) = nth(l, j - i)}"
                   array2list "structures/")
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil))
   nil))
 (pseudo_div_TCC4 0
  (pseudo_div_TCC4-1 nil 3582651046
   ("" (skosimp*)
    (("" (assert)
      (("" (lift-if)
        (("" (split -)
          (("1" (flatten)
            (("1" (replace -2)
              (("1" (expand "make_divlisttype" +)
                (("1" (assertnil nil)) nil))
              nil))
            nil)
           ("2" (flatten)
            (("2" (typepred "v!1(g!1, n!1)(h!1, m!1)(1 + i!1)")
              (("2" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division 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)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (/= const-decl "boolean" notequal nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (pseudo_div_TCC5 0
  (pseudo_div_TCC5-1 nil 3582651046
   ("" (skosimp*)
    (("" (lift-if)
      (("" (ground)
        (("1" (replaces -2)
          (("1" (expand "make_divlisttype") (("1" (assertnil nil))
            nil))
          nil)
         ("2" (typepred "v!1(g!1, n!1)(h!1, m!1)(i!1 + 1)")
          (("1" (assertnil nil)
           ("2" (assert) (("2" (grind) nil nil)) nil))
          nil))
        nil))
      nil))
    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)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (pseudo_div_TCC6 0
  (pseudo_div_TCC6-1 nil 3582651046
   ("" (skosimp*)
    (("" (assert)
      (("" (lift-if)
        (("" (split -)
          (("1" (flatten)
            (("1" (replace -2)
              (("1" (expand "make_divlisttype")
                (("1" (assertnil nil)) nil))
              nil))
            nil)
           ("2" (flatten)
            (("2" (assert)
              (("2" (typepred "v!1(g!1, n!1)(h!1, m!1)(1 + i!1)")
                (("2" (replaces -2 :dir rl) (("2" (assertnil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (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 "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (list type-decl nil list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (every adt-def-decl "boolean" list_adt nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (pseudo_div_TCC7 0
  (pseudo_div_TCC7-1 nil 3582881577
   ("" (skosimp*)
    (("" (assert)
      (("" (lift-if)
        (("" (split -)
          (("1" (flatten)
            (("1" (replace -2)
              (("1" (assert)
                (("1" (expand "make_divlisttype")
                  (("1" (assertnil nil)) nil))
                nil))
              nil))
            nil)
           ("2" (flatten)
            (("2" (typepred "v!1(g!1, n!1)(h!1, m!1)(1 + i!1)")
              (("2" (replaces -2 :dir rl) (("2" (assertnil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (/= const-decl "boolean" notequal nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (pseudo_div_TCC8 0
  (pseudo_div_TCC8-1 nil 3582881577 ("" (subtype-tcc) nil nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     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)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil))
   nil))
 (pseudo_div_TCC9 0
  (pseudo_div_TCC9-1 nil 3582881577 ("" (subtype-tcc) nil nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil))
 (pseudo_div_TCC10 0
  (pseudo_div_TCC10-1 nil 3591348813 ("" (subtype-tcc) nil nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (/= const-decl "boolean" notequal nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil))
 (pseudo_div_TCC11 0
  (pseudo_div_TCC11-1 nil 3591348813 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil))
 (pseudo_div_TCC12 0
  (pseudo_div_TCC12-1 nil 3591348813 ("" (subtype-tcc) nil nil)
   ((mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (/= const-decl "boolean" notequal nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(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))
   nil))
 (pseudo_div_lengths 0
  (pseudo_div_lengths-1 nil 3582908268
   (""
    (case "FORALL (g, h: [nat -> int], i, m, n: nat):
                                    h(m) /= 0 AND i <= n - m IMPLIES
                                     LET psd = pseudo_div(g, n)(h, m)(n-m-i),
                                         pd = poly_divide(g, n)(h, m)(n-m-i),
                                         qlength = length(psd`quotl),
                                         rlength = length(psd`reml)
                                       IN
                                       psd`qdegl = pd`qdeg AND
                                        psd`rdegl = pd`rdeg AND psd`rdegl = max(rlength - 1, 0) and qlength = (IF m = 0 THEN n - m + 1 ELSE i + 1 ENDIF)")
    (("1" (skeep)
      (("1" (case "i > n-m")
        (("1" (hide -2)
          (("1" (assert)
            (("1" (expand "pseudo_div")
              (("1" (expand "make_divlisttype")
                (("1" (expand "poly_divide")
                  (("1" (expand "make_divtype")
                    (("1" (expand "max")
                      (("1" (lift-if) (("1" (ground) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (inst - "g" "h" "n-m-i" "m" "n")
          (("1" (assertnil nil) ("2" (assertnil nil)) nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "i")
        (("1" (assertnil nil)
         ("2" (assert)
          (("2" (skeep)
            (("2" (expand "pseudo_div")
              (("2" (expand "poly_divide")
                (("2" (lift-if)
                  (("2" (expand "make_divtype")
                    (("2" (expand "make_divlisttype")
                      (("2" (assert)
                        (("2" (ground)
                          (("1" (grind) nil nil)
                           ("2" (expand "max") (("2" (assertnil nil))
                            nil)
                           ("3" (expand "length")
                            (("3" (expand "length")
                              (("3" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (assert)
          (("3" (expand "max")
            (("3" (assert)
              (("3" (skeep)
                (("3" (skeep)
                  (("3" (inst - "g" "h" "m" "n")
                    (("3" (assert)
                      (("3" (flatten)
                        (("3" (name "ii" "-1 - j - m + n")
                          (("3" (case "NOT -1 * j - m + n = ii+1")
                            (("1" (assertnil nil)
                             ("2" (replaces -1)
                              (("2"
                                (replace -1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (split +)
                                    (("1"
                                      (hide (-3 -4 -5))
                                      (("1"
                                        (expand "pseudo_div" +)
                                        (("1"
                                          (lift-if)
                                          (("1"
                                            (split +)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand
                                                 "poly_divide"
                                                 +)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand
                                                     "make_divlisttype")
                                                    (("1"
                                                      (expand
                                                       "make_divtype")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (expand
                                                 "make_divlisttype")
                                                (("2"
                                                  (expand
                                                   "poly_divide"
                                                   +)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "make_divtype")
                                                      (("2"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide (-2 -4 -5))
                                      (("2"
                                        (assert)
                                        (("2"
                                          (expand
                                           "pseudo_div"
                                           +)
                                          (("2"
                                            (lift-if)
                                            (("2"
                                              (split +)
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (expand
                                                   "poly_divide"
                                                   +)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand
                                                       "make_divlisttype")
                                                      (("1"
                                                        (expand
                                                         "make_divtype")
                                                        (("1"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (flatten)
                                                (("2"
                                                  (expand
                                                   "make_divlisttype")
                                                  (("2"
                                                    (expand
                                                     "poly_divide"
                                                     +)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "make_divtype")
                                                        (("2"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("3"
                                      (assert)
                                      (("3"
                                        (expand "pseudo_div" +)
                                        (("3"
                                          (lift-if)
                                          (("3"
                                            (split +)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand
                                                   "make_divlisttype")
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (expand
                                                 "make_divlisttype")
                                                (("2"
                                                  (invoke
                                                   (name "AA" "%1")
                                                   (! 2 2 1 1 1 1))
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (typepred "AA")
                                                      (("1"
                                                        (replace -2)
                                                        (("1"
                                                          (hide -)
                                                          (("1"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      (("3"
                                                        (replace -3)
                                                        (("3"
                                                          (hide 5)
                                                          (("3"
                                                            (ground)
                                                            (("3"
                                                              (replace
                                                               -2)
                                                              (("3"
                                                                (expand
                                                                 "pseudo_div"
                                                                 +)
                                                                (("3"
                                                                  (expand
                                                                   "make_divlisttype")
                                                                  (("3"
                                                                    (expand
                                                                     "length"
                                                                     3)
                                                                    (("3"
                                                                      (assert)
                                                                      (("3"
                                                                        (lift-if)
                                                                        (("3"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("4"
                                                    (hide 3)
                                                    (("4"
                                                      (skosimp*)
                                                      (("4"
                                                        (assert)
                                                        (("4"
                                                          (ground)
                                                          (("1"
                                                            (expand
                                                             "pseudo_div"
                                                             +)
                                                            (("1"
                                                              (expand
                                                               "make_divlisttype")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             -1
                                                             1
                                                             :dir
                                                             rl)
                                                            (("2"
                                                              (replace
                                                               -4)
                                                              (("2"
                                                                (expand
                                                                 "pseudo_div"
                                                                 4)
                                                                (("2"
                                                                  (expand
                                                                   "make_divlisttype")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("5"
                                                    (skosimp*)
                                                    (("5"
                                                      (assert)
                                                      (("5"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("4"
                                      (lift-if)
                                      (("4"
                                        (ground)
                                        (("1"
                                          (expand
                                           "pseudo_div"
                                           +)
                                          (("1"
                                            (expand "make_divlisttype")
                                            (("1" (assertnil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand
                                           "pseudo_div"
                                           +)
                                          (("2"
                                            (expand "make_divlisttype")
                                            (("2"
                                              (expand "length" +)
                                              (("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (expand
                                           "pseudo_div"
                                           +)
                                          (("3"
                                            (expand "make_divlisttype")
                                            (("3"
                                              (expand "length" +)
                                              (("3" (assertnil nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("4"
                                          (expand
                                           "pseudo_div"
                                           4)
                                          (("4"
                                            (expand "make_divlisttype")
                                            (("4"
                                              (expand "length" 4)
                                              (("4" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("4" (hide 2) (("4" (skosimp*) (("4" (assertnil nil)) nil))
          nil)
         ("5" (skosimp*) (("5" (assertnil nil)) nil))
        nil))
      nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil)
     ("4" (skosimp*) (("4" (assertnil nil)) nil))
    nil)
   ((- const-decl "[numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (listn type-eq-decl nil listn "structures/")
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (nth def-decl "T" list_props nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (array2list_it def-decl
                   "{l: listn(n - i) | FORALL (j: subrange(i, n - 1)): a(j) = nth(l, j - i)}"
                   array2list "structures/")
    (length_singleton formula-decl nil more_list_props "structures/")
    (max_npreal_0 formula-decl nil min_max "reals/")
    (length_null formula-decl nil more_list_props "structures/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (i skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (m skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (n skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (make_divtype const-decl "DivType" polynomial_division nil)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (list type-decl nil list_adt nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (PRED type-eq-decl nil defined_types nil)
    (every adt-def-decl "boolean" list_adt nil)
    (length def-decl "nat" list_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (DivType type-eq-decl nil polynomial_division nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (poly_divide def-decl "DivType" polynomial_division nil)
    (pseudo_div def-decl "{DT: DivListType |
         (m > n OR i > n - m AND length(DT`reml) = n + 1 AND DT`rdegl = n)
          OR
          (m = 0 AND length(DT`reml) = 0 AND DT`rdegl = 0) OR
           (m > 0 AND
             length(DT`reml) = m + i AND length(DT`reml) = DT`rdegl + 1)}"
                        polynomial_pseudo_divide nil))
   nil))
 (HHGGLEM 0
  (HHGGLEM-1 nil 3583580204 ("" (grind) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (GG const-decl "int" polynomial_pseudo_divide nil)
    (HH const-decl "int" polynomial_pseudo_divide nil)
    (/= const-decl "boolean" notequal nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (pseudo_div_def_TCC1 0
  (pseudo_div_def_TCC1-1 nil 3583595096
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_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)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (length def-decl "nat" list_props nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (> const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (pseudo_div_def_TCC2 0
  (pseudo_div_def_TCC2-1 nil 3583595096
   ("" (skeep)
    (("" (skeep)
      (("" (skeep)
        (("" (skeep)
          (("" (skeep)
            (("" (skeep)
              (("" (lemma "pseudo_div_lengths")
                (("" (inst?)
                  (("" (assert)
                    (("" (flatten)
                      ((""
                        (case "length(pseudo_div(g, n)(h, m)(i)`reml) - 1>=0")
                        (("1" (expand "max") (("1" (assertnil nil))
                          nil)
                         ("2" (expand "pseudo_div" 1)
                          (("2" (expand "make_divlisttype")
                            (("2" (assert)
                              (("2"
                                (lift-if)
                                (("2"
                                  (assert)
                                  (("2" (ground) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (length_null formula-decl nil more_list_props "structures/")
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (list type-decl nil list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (every adt-def-decl "boolean" list_adt nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (length def-decl "nat" list_props nil)
    (/= const-decl "boolean" notequal nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pseudo_div def-decl "{DT: DivListType |
         (m > n OR i > n - m AND length(DT`reml) = n + 1 AND DT`rdegl = n)
          OR
          (m = 0 AND length(DT`reml) = 0 AND DT`rdegl = 0) OR
           (m > 0 AND
             length(DT`reml) = m + i AND length(DT`reml) = DT`rdegl + 1)}"
                        polynomial_pseudo_divide nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_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_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (pseudo_div_lengths formula-decl nil
     polynomial_pseudo_divide nil))
   nil))
 (pseudo_div_def 0
  (pseudo_div_def-6 nil 3601033952
   (""
    (case "FORALL (R, T: nat, g, h: [nat -> int], i, m, n: nat):
                                                                                                   (h(m) /= 0 AND
                                                                                                     i <= n - m AND
                                                                                                      (FORALL (ii: nat): ii > n IMPLIES g(ii) = 0) AND
                                                                                                       (FORALL (ii: nat): ii > m IMPLIES h(ii) = 0))
                                                                                                    IMPLIES
                                                                                                    LET psd = pseudo_div(g, n)(h, m)(n-m-i),
                                                                                                        pd = poly_divide(g, n)(h, m)(n-m-i),
                                                                                                        qlength = length(psd`quotl),
                                                                                                        rlength = length(psd`reml)
                                                                                                      IN
                                                                                                      (pd`quot =
                                                                                                        (LAMBDA (k: nat): (1 / h(m)) ^ GG(k, n, m, n-m-i, R, T)) *
                                                                                                         (LAMBDA (k: nat):
                                                                                                            IF k <= pd`qdeg AND k >= pd`qdeg - qlength + 1
                                                                                                              THEN nth(psd`quotl, k - (pd`qdeg - qlength + 1))
                                                                                                            ELSE 0
                                                                                                            ENDIF))
                                                                                                       AND
                                                                                                       pd`rem =
                                                                                                        (LAMBDA (k: nat): (1 / h(m)) ^ HH(k, n, m, n-m-i, R, T)) *
                                                                                                         (LAMBDA (k: nat):
                                                                                                            IF k <= pd`rdeg AND m > 0 THEN nth(psd`reml, k)
                                                                                                            ELSE 0
                                                                                                            ENDIF)")
    (("1" (skeep)
      (("1" (case "i>n-m")
        (("1" (hide -2)
          (("1" (assert)
            (("1" (expand "poly_divide")
              (("1" (expand "pseudo_div")
                (("1" (expand "make_divtype")
                  (("1" (expand "make_divlisttype")
                    (("1" (expand "length")
                      (("1" (split)
                        (("1" (decompose-equality)
                          (("1" (expand "*")
                            (("1" (lift-if) (("1" (ground) nil nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil))
                          nil)
                         ("2" (decompose-equality)
                          (("1" (expand "*")
                            (("1" (expand "HH")
                              (("1"
                                (expand "^")
                                (("1"
                                  (expand "expt")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (ground)
                                        (("1"
                                          (typepred
                                           "array2list(1 + n)(g)")
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (inst - "x!1")
                                              (("1" (assertnil nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (inst - "x!1")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*)
                            (("2" (assert)
                              (("2"
                                (expand "*")
                                (("2"
                                  (expand "HH")
                                  (("2"
                                    (expand "^")
                                    (("2"
                                      (expand "expt")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (inst - "R" "T" "g" "h" "n-m-i" "m" "n")
          (("1" (assert)
            (("1" (replace -3)
              (("1" (replace -2) (("1" (propax) nil nil)) nil)) nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "i")
        (("1" (assertnil nil)
         ("2" (assert)
          (("2" (skeep)
            (("2" (assert)
              (("2" (split +)
                (("1" (assert)
                  (("1" (expand "pseudo_div")
                    (("1" (expand "poly_divide")
                      (("1" (lift-if)
                        (("1" (expand "make_divtype")
                          (("1" (expand "make_divlisttype")
                            (("1" (split +)
                              (("1"
                                (flatten)
                                (("1"
                                  (decompose-equality +)
                                  (("1"
                                    (expand "*")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (typepred "array2list(1+n)(g)")
                                        (("1"
                                          (hide -1)
                                          (("1"
                                            (replaces -1)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "GG")
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (ground)
                                                    (("1"
                                                      (inst - "m+x!1")
                                                      (("1"
                                                        (replaces
                                                         -2
                                                         :dir
                                                         rl)
                                                        (("1"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst -4 "x!1")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (skosimp*)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (expand "length")
                                  (("2"
                                    (assert)
                                    (("2"
                                      (expand "length")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (decompose-equality 2)
                                          (("1"
                                            (lift-if)
                                            (("1"
                                              (ground)
                                              (("1"
                                                (expand "nth" + 1)
                                                (("1"
                                                  (typepred
                                                   "array2list(1+n)(g)")
                                                  (("1"
                                                    (inst - "n")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand "*")
                                                        (("1"
                                                          (expand "GG")
                                                          (("1"
                                                            (rewrite
                                                             "expt_x1")
                                                            (("1"
                                                              (hide -1)
                                                              (("1"
                                                                (replaces
                                                                 -2
                                                                 :dir
                                                                 rl)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "*")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (lift-if)
                                                    (("2"
                                                      (ground)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "length")
                                                (("2"
                                                  (expand "length")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (decompose-equality +)
                  (("1" (expand "*")
                    (("1" (expand "poly_divide" +)
                      (("1" (expand "make_divtype")
                        (("1" (expand "pseudo_div")
                          (("1" (expand "make_divlisttype")
                            (("1" (assert)
                              (("1"
                                (lift-if)
                                (("1"
                                  (lift-if)
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (split +)
                                            (("1" (propax) nil nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (split +)
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split +)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (name
                                                             "AA"
                                                             "array2list[int](n)
                                                                (LAMBDA (j: nat):
                                                                   IF j > n THEN 0
                                                                   ELSIF j < n - m
                                                                     THEN h(m) * nth(array2list[int](1 + n)(g), j)
                                                                   ELSE h(m) * nth(array2list[int](1 + n)(g), j) -
                                                                         nth(array2list[int](1 + n)(g), n) * h(j - n + m)
                                                                   ENDIF)")
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (typepred
                                                                 "AA")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "x!1")
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (typepred
                                                                         "array2list(1+n)(g)")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "x!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -6
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (replace
                                                                                 -3
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (expand
                                                                                   "HH")
                                                                                  (("1"
                                                                                    (hide
                                                                                     -)
                                                                                    (("1"
                                                                                      (grind)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "HH"
                                                                     +)
                                                                    (("2"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (skosimp*)
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("4"
                                                              (skosimp*)
                                                              (("4"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("5"
                                                              (skosimp*)
                                                              (("5"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (ground)
                                                              (("2"
                                                                (name
                                                                 "AA"
                                                                 "array2list[int](n)
                                                                (LAMBDA (j: nat):
                                                                   IF j > n THEN 0
                                                                   ELSIF j < n - m
                                                                     THEN h(m) * nth(array2list[int](1 + n)(g), j)
                                                                   ELSE h(m) * nth(array2list[int](1 + n)(g), j) -
                                                                         nth(array2list[int](1 + n)(g), n) * h(j - n + m)
                                                                   ENDIF)")
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (typepred
                                                                     "AA")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (replace
                                                                           -3
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (typepred
                                                                             "array2list(1+n)(g)")
                                                                            (("1"
                                                                              (inst-cp
                                                                               -
                                                                               "x!1")
                                                                              (("1"
                                                                                (replace
                                                                                 -4
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "n")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -3
                                                                                     :dir
                                                                                     rl)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "HH"
                                                                                       +)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -)
                                                                                        (("1"
                                                                                          (grind)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (skosimp*)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("3"
                                                                  (skosimp*)
                                                                  (("3"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("4"
                                                                  (skosimp*)
                                                                  (("4"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("5"
                                                                  (skosimp*)
                                                                  (("5"
                                                                    (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)
                   ("2" (skeep)
                    (("2" (assert)
                      (("2" (expand "pseudo_div")
                        (("2" (expand "make_divlisttype")
                          (("2" (expand "poly_divide")
                            (("2" (expand "make_divtype")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (skeep)
          (("3" (skeep)
            (("3" (inst - "R" "T" "g" "h" "m" "n")
              (("3" (assert)
                (("3" (replace -3)
                  (("3" (replace -4)
                    (("3" (flatten)
                      (("3" (name "ii" "-1 - j - m + n")
                        (("3" (replace -1)
                          (("3" (case "NOT n-m-j = ii+1")
                            (("1" (assertnil nil)
                             ("2" (replace -1)
                              (("2"
                                (assert)
                                (("2"
                                  (case "m = 0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "poly_divide" +)
                                          (("1"
                                            (expand "*")
                                            (("1"
                                              (expand "make_divtype")
                                              (("1"
                                                (expand
                                                 "pseudo_div"
                                                 +)
                                                (("1"
                                                  (expand
                                                   "make_divlisttype")
                                                  (("1"
                                                    (decompose-equality
                                                     2)
                                                    (("1"
                                                      (expand "GG" +)
                                                      (("1"
                                                        (typepred
                                                         "array2list(1+n)(g)")
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (split
                                                                   +)
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (replace
                                                                           -3
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (hide
                                                                             -)
                                                                            (("1"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     -2)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (assert)
                                    (("2"
                                      (split +)
                                      (("1"
                                        (lemma "poly_divide_lengths")
                                        (("1"
                                          (inst - "g" "h" "ii" "m" "n")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (lemma
                                                 "pseudo_div_lengths")
                                                (("1"
                                                  (inst
                                                   -
                                                   "g"
                                                   "h"
                                                   "ii"
                                                   "m"
                                                   "n")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (replace -4)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide
                                                             (-1
                                                              -2
                                                              -3
                                                              -4))
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "poly_divide"
                                                                   1)
                                                                  (("1"
                                                                    (expand
                                                                     "make_divtype")
                                                                    (("1"
                                                                      (lemma
                                                                       "poly_divide_lengths")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "g"
                                                                         "h"
                                                                         "ii+1"
                                                                         "m"
                                                                         "n")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (replaces
                                                                               -1)
                                                                              (("1"
                                                                                (replaces
                                                                                 -1)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "pseudo_div_lengths")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "g"
                                                                                     "h"
                                                                                     "ii+1"
                                                                                     "m"
                                                                                     "n")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (replaces
                                                                                           -4)
                                                                                          (("1"
                                                                                            (hide
                                                                                             (-1
                                                                                              -2
                                                                                              -3))
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "*")
                                                                                                (("1"
                                                                                                  (decompose-equality
                                                                                                   +)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -6)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (replace
                                                                                                         -5)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (lift-if)
                                                                                                            (("1"
                                                                                                              (lift-if)
                                                                                                              (("1"
                                                                                                                (lift-if)
                                                                                                                (("1"
                                                                                                                  (lift-if)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    (("1"
                                                                                                                      (ground)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "pseudo_div"
                                                                                                                         +
                                                                                                                         2)
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (expand
                                                                                                                             "make_divlisttype")
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "nth"
                                                                                                                               +
                                                                                                                               2)
                                                                                                                              (("1"
                                                                                                                                (lemma
                                                                                                                                 "pseudo_div_lengths")
                                                                                                                                (("1"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "g"
                                                                                                                                   "h"
                                                                                                                                   "ii+1"
                                                                                                                                   "m"
                                                                                                                                   "n")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    (("1"
                                                                                                                                      (flatten)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -2
                                                                                                                                         +)
                                                                                                                                        (("1"
                                                                                                                                          (lemma
                                                                                                                                           "poly_divide_lengths")
                                                                                                                                          (("1"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "g"
                                                                                                                                             "h"
                                                                                                                                             "ii+1"
                                                                                                                                             "m"
                                                                                                                                             "n")
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              (("1"
                                                                                                                                                (flatten)
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (replace
                                                                                                                                                     -2)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      (("1"
                                                                                                                                                        (expand
                                                                                                                                                         "HH")
                                                                                                                                                        (("1"
                                                                                                                                                          (expand
                                                                                                                                                           "GG")
                                                                                                                                                          (("1"
                                                                                                                                                            (hide
                                                                                                                                                             -)
                                                                                                                                                            (("1"
                                                                                                                                                              (grind
                                                                                                                                                               :exclude
                                                                                                                                                               ("nth"
                                                                                                                                                                "pseudo_div"))
                                                                                                                                                              nil
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (expand
                                                                                                                         "GG")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "pseudo_div"
                                                                                                                             +
                                                                                                                             2)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (expand
                                                                                                                                 "make_divlisttype")
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "nth"
                                                                                                                                   +
                                                                                                                                   2)
                                                                                                                                  (("2"
                                                                                                                                    (lift-if)
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (skosimp*)
                                                                                                    (("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)
                                       ("2"
                                        (assert)
                                        (("2"
                                          (lemma "poly_divide_lengths")
                                          (("2"
                                            (inst
                                             -
                                             "g"
                                             "h"
                                             "ii"
                                             "m"
                                             "n")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (lemma
                                                   "pseudo_div_lengths")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "g"
                                                     "h"
                                                     "ii"
                                                     "m"
                                                     "n")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (flatten)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (hide
                                                             (-1
                                                              -2
                                                              -3
                                                              -4))
                                                            (("2"
                                                              (replace
                                                               -2)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "poly_divide"
                                                                   1)
                                                                  (("2"
                                                                    (expand
                                                                     "make_divtype")
                                                                    (("2"
                                                                      (lemma
                                                                       "poly_divide_lengths")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "g"
                                                                         "h"
                                                                         "ii+1"
                                                                         "m"
                                                                         "n")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (replaces
                                                                               -1)
                                                                              (("2"
                                                                                (replaces
                                                                                 -1)
                                                                                (("2"
                                                                                  (lemma
                                                                                   "pseudo_div_lengths")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "g"
                                                                                     "h"
                                                                                     "ii+1"
                                                                                     "m"
                                                                                     "n")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (flatten)
                                                                                        (("2"
                                                                                          (replaces
                                                                                           -4)
                                                                                          (("2"
                                                                                            (hide
                                                                                             (-1
                                                                                              -2
                                                                                              -3))
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "*")
                                                                                                (("2"
                                                                                                  (decompose-equality
                                                                                                   +)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -6)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (lift-if)
                                                                                                          (("1"
                                                                                                            (lift-if)
                                                                                                            (("1"
                                                                                                              (lift-if)
                                                                                                              (("1"
                                                                                                                (lift-if)
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (ground)
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "pseudo_div"
                                                                                                                       +
                                                                                                                       2)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "make_divlisttype")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (invoke
                                                                                                                             (name
                                                                                                                              "AA"
                                                                                                                              "%1")
                                                                                                                             (!
                                                                                                                              1
                                                                                                                              2
                                                                                                                              2
                                                                                                                              1))
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (hide
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (typepred
                                                                                                                                   "AA")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "x!1")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -3
                                                                                                                                         :dir
                                                                                                                                         rl)
                                                                                                                                        (("1"
                                                                                                                                          (expand
                                                                                                                                           "HH")
                                                                                                                                          (("1"
                                                                                                                                            (lift-if)
                                                                                                                                            (("1"
                                                                                                                                              (ground)
                                                                                                                                              (("1"
                                                                                                                                                (expand
                                                                                                                                                 "^")
                                                                                                                                                (("1"
                                                                                                                                                  (expand
                                                                                                                                                   "expt"
                                                                                                                                                   +
                                                                                                                                                   2)
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (expand
                                                                                                                                                 "^")
                                                                                                                                                (("2"
                                                                                                                                                  (expand
                                                                                                                                                   "expt"
                                                                                                                                                   +
                                                                                                                                                   2)
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (skosimp*)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("3"
                                                                                                                                (skeep)
                                                                                                                                (("3"
                                                                                                                                  (assert)
                                                                                                                                  (("3"
                                                                                                                                    (lemma
                                                                                                                                     "pseudo_div_lengths")
                                                                                                                                    (("3"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "g"
                                                                                                                                       "h"
                                                                                                                                       "1+ii"
                                                                                                                                       "m"
                                                                                                                                       "n")
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        (("3"
                                                                                                                                          (flatten)
                                                                                                                                          (("3"
                                                                                                                                            (replace
                                                                                                                                             -3
                                                                                                                                             +)
                                                                                                                                            (("3"
                                                                                                                                              (expand
                                                                                                                                               "max"
                                                                                                                                               +)
                                                                                                                                              (("3"
                                                                                                                                                (lift-if)
                                                                                                                                                (("3"
                                                                                                                                                  (assert)
                                                                                                                                                  (("3"
                                                                                                                                                    (ground)
                                                                                                                                                    (("3"
                                                                                                                                                      (hide-all-but
                                                                                                                                                       (-1
                                                                                                                                                        +))
                                                                                                                                                      (("3"
                                                                                                                                                        (expand
                                                                                                                                                         "pseudo_div")
                                                                                                                                                        (("3"
                                                                                                                                                          (expand
                                                                                                                                                           "make_divlisttype")
                                                                                                                                                          (("3"
                                                                                                                                                            (assert)
                                                                                                                                                            nil
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("4"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("4"
                                                                                                                                (hide
                                                                                                                                 (-6
                                                                                                                                  -7))
                                                                                                                                (("4"
                                                                                                                                  (skosimp*)
                                                                                                                                  (("4"
                                                                                                                                    (assert)
                                                                                                                                    (("4"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("4"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("4"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("5"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("5"
                                                                                                                                (skosimp*)
                                                                                                                                (("5"
                                                                                                                                  (assert)
                                                                                                                                  (("5"
                                                                                                                                    (hide
                                                                                                                                     (-7
                                                                                                                                      -8))
                                                                                                                                    (("5"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("5"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("5"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (expand
                                                                                                                       "pseudo_div"
                                                                                                                       +
                                                                                                                       3)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "make_divlisttype")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (invoke
                                                                                                                             (name
                                                                                                                              "AA"
                                                                                                                              "%1")
                                                                                                                             (!
                                                                                                                              1
                                                                                                                              2
                                                                                                                              2
                                                                                                                              1))
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (hide
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (typepred
                                                                                                                                   "AA")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "x!1")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -3
                                                                                                                                         +
                                                                                                                                         :dir
                                                                                                                                         rl)
                                                                                                                                        (("1"
                                                                                                                                          (hide
                                                                                                                                           -1)
                                                                                                                                          (("1"
                                                                                                                                            (hide
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (lemma
                                                                                                                                               "pseudo_div_lengths")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "g"
                                                                                                                                                 "h"
                                                                                                                                                 "ii+1"
                                                                                                                                                 "m"
                                                                                                                                                 "n")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (flatten)
                                                                                                                                                    (("1"
                                                                                                                                                      (replace
                                                                                                                                                       -2)
                                                                                                                                                      (("1"
                                                                                                                                                        (replace
                                                                                                                                                         -3)
                                                                                                                                                        (("1"
                                                                                                                                                          (case
                                                                                                                                                           "length(pseudo_div(g, n)(h, m)(1 + ii)`reml) - 1>=0")
                                                                                                                                                          (("1"
                                                                                                                                                            (expand
                                                                                                                                                             "max")
                                                                                                                                                            (("1"
                                                                                                                                                              (assert)
                                                                                                                                                              (("1"
                                                                                                                                                                (expand
                                                                                                                                                                 "pseudo_div"
                                                                                                                                                                 +
                                                                                                                                                                 5)
                                                                                                                                                                (("1"
                                                                                                                                                                  (expand
                                                                                                                                                                   "make_divlisttype")
                                                                                                                                                                  (("1"
                                                                                                                                                                    (replaces
                                                                                                                                                                     -1)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (name
                                                                                                                                                                       "AB"
                                                                                                                                                                       "array2list[int](1 + ii + m)
                                                                                (LAMBDA (j: nat):
                                                                                   IF j > 1 + ii + m THEN 0
                                                                                   ELSIF j < 1 + ii
                                                                                     THEN h(m)
                                                                                          *
                                                                                          nth
                                                                                          (IF 1 + ii = n - m
                                                                                           THEN array2list[int](1 + n)(g)
                                                                                           ELSE pseudo_div
                                                                                                (g, n)(h, m)(2 + ii)`reml
                                                                                           ENDIF,
                                                                                           j)
                                                                                   ELSE h(m)
                                                                                        *
                                                                                        nth
                                                                                        (IF 1 + ii = n - m
                                                                                         THEN array2list[int](1 + n)(g)
                                                                                         ELSE pseudo_div
                                                                                              (g, n)(h, m)(2 + ii)`reml
                                                                                         ENDIF,
                                                                                         j)
                                                                                        -
                                                                                        nth
                                                                                        (IF 1 + ii = n - m
                                                                                         THEN array2list[int](1 + n)(g)
                                                                                         ELSE pseudo_div
                                                                                              (g, n)(h, m)(2 + ii)`reml
                                                                                         ENDIF,
                                                                                         IF 1 + ii = n - m
                                                                                         THEN n
                                                                                         ELSE pseudo_div
                                                                                              (g, n)(h, m)(2 + ii)`rdegl
                                                                                         ENDIF)
                                                                                        *
                                                                                        h(j - 1 - ii)
                                                                                   ENDIF)")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (replaces
                                                                                                                                                                         -1)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (typepred
                                                                                                                                                                           "AB")
                                                                                                                                                                          (("1"
                                                                                                                                                                            (replaces
                                                                                                                                                                             -2)
                                                                                                                                                                            (("1"
                                                                                                                                                                              (hide
                                                                                                                                                                               -3)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (assert)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (hide
                                                                                                                                                                                   (-1
                                                                                                                                                                                    -2
                                                                                                                                                                                    -3
                                                                                                                                                                                    -4
                                                                                                                                                                                    -5
                                                                                                                                                                                    -6
                                                                                                                                                                                    -7))
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "HH")
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (assert)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (lift-if)
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (split
                                                                                                                                                                                           +)
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (flatten)
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              (("1"
                                                                                                                                                                                                (expand
                                                                                                                                                                                                 "^")
                                                                                                                                                                                                (("1"
                                                                                                                                                                                                  (expand
                                                                                                                                                                                                   "expt"
                                                                                                                                                                                                   +
                                                                                                                                                                                                   3)
                                                                                                                                                                                                  (("1"
                                                                                                                                                                                                    (expand
                                                                                                                                                                                                     "expt"
                                                                                                                                                                                                     +
                                                                                                                                                                                                     4)
                                                                                                                                                                                                    (("1"
                                                                                                                                                                                                      (assert)
                                                                                                                                                                                                      nil
                                                                                                                                                                                                      nil))
                                                                                                                                                                                                    nil))
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil)
                                                                                                                                                                                           ("2"
                                                                                                                                                                                            (flatten)
                                                                                                                                                                                            (("2"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              (("2"
                                                                                                                                                                                                (expand
                                                                                                                                                                                                 "^")
                                                                                                                                                                                                (("2"
                                                                                                                                                                                                  (expand
                                                                                                                                                                                                   "expt"
                                                                                                                                                                                                   +
                                                                                                                                                                                                   3)
                                                                                                                                                                                                  (("2"
                                                                                                                                                                                                    (expand
                                                                                                                                                                                                     "expt"
                                                                                                                                                                                                     +
                                                                                                                                                                                                     4)
                                                                                                                                                                                                    (("2"
                                                                                                                                                                                                      (assert)
                                                                                                                                                                                                      nil
                                                                                                                                                                                                      nil))
                                                                                                                                                                                                    nil))
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil))
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("2"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("2"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("2"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("3"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("3"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("3"
                                                                                                                                                                            (assert)
                                                                                                                                                                            (("3"
                                                                                                                                                                              (hide
                                                                                                                                                                               -)
                                                                                                                                                                              (("3"
                                                                                                                                                                                (expand
                                                                                                                                                                                 "pseudo_div")
                                                                                                                                                                                (("3"
                                                                                                                                                                                  (expand
                                                                                                                                                                                   "make_divlisttype")
                                                                                                                                                                                  (("3"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("4"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("4"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("4"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("5"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("5"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("5"
                                                                                                                                                                            (assert)
                                                                                                                                                                            (("5"
                                                                                                                                                                              (lift-if)
                                                                                                                                                                              (("5"
                                                                                                                                                                                (hide
                                                                                                                                                                                 -)
                                                                                                                                                                                (("5"
                                                                                                                                                                                  (expand
                                                                                                                                                                                   "pseudo_div")
                                                                                                                                                                                  (("5"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "make_divlisttype")
                                                                                                                                                                                    (("5"
                                                                                                                                                                                      (ground)
                                                                                                                                                                                      nil
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("6"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("6"
                                                                                                                                                                          (skeep)
                                                                                                                                                                          (("6"
                                                                                                                                                                            (assert)
                                                                                                                                                                            (("6"
                                                                                                                                                                              (lift-if)
                                                                                                                                                                              (("6"
                                                                                                                                                                                (split
                                                                                                                                                                                 +)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (flatten)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil)
                                                                                                                                                                                 ("2"
                                                                                                                                                                                  (flatten)
                                                                                                                                                                                  (("2"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    (("2"
                                                                                                                                                                                      (expand
                                                                                                                                                                                       "pseudo_div"
                                                                                                                                                                                       +)
                                                                                                                                                                                      (("2"
                                                                                                                                                                                        (expand
                                                                                                                                                                                         "make_divlisttype")
                                                                                                                                                                                        (("2"
                                                                                                                                                                                          (assert)
                                                                                                                                                                                          nil
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil)
                                                                                                                                                           ("2"
                                                                                                                                                            (hide
                                                                                                                                                             2)
                                                                                                                                                            (("2"
                                                                                                                                                              (assert)
                                                                                                                                                              (("2"
                                                                                                                                                                (hide
                                                                                                                                                                 -)
                                                                                                                                                                (("2"
                                                                                                                                                                  (expand
                                                                                                                                                                   "pseudo_div")
                                                                                                                                                                  (("2"
                                                                                                                                                                    (expand
                                                                                                                                                                     "make_divlisttype")
                                                                                                                                                                    (("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"
                                                                                                                                (skosimp*)
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("3"
                                                                                                                                (skosimp*)
                                                                                                                                (("3"
                                                                                                                                  (hide
                                                                                                                                   -)
                                                                                                                                  (("3"
                                                                                                                                    (assert)
                                                                                                                                    (("3"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("3"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("3"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("4"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("4"
                                                                                                                                (skosimp*)
                                                                                                                                (("4"
                                                                                                                                  (assert)
                                                                                                                                  (("4"
                                                                                                                                    (hide
                                                                                                                                     -)
                                                                                                                                    (("4"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("4"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("4"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("5"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("5"
                                                                                                                                (skosimp*)
                                                                                                                                (("5"
                                                                                                                                  (assert)
                                                                                                                                  (("5"
                                                                                                                                    (hide
                                                                                                                                     -)
                                                                                                                                    (("5"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("5"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("5"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("3"
                                                                                                                      (assert)
                                                                                                                      (("3"
                                                                                                                        (case
                                                                                                                         "NOT x!1=ii+m")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (case
                                                                                                                             "FORALL (kn:nat): kn>ii-1+m AND kn<=ii+m IMPLIES kn = ii+m")
                                                                                                                            (("1"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "x!1")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (hide-all-but
                                                                                                                               1)
                                                                                                                              (("2"
                                                                                                                                (skeep)
                                                                                                                                (("2"
                                                                                                                                  (case
                                                                                                                                   "kn>=ii+m")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (hide-all-but
                                                                                                                                       (-1
                                                                                                                                        1))
                                                                                                                                      (("2"
                                                                                                                                        (case
                                                                                                                                         "FORALL (a1,a2:nat): a1>a2-1 IMPLIES a1>=a2")
                                                                                                                                        (("1"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           "kn"
                                                                                                                                           "ii+m")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (hide-all-but
                                                                                                                                           1)
                                                                                                                                          (("2"
                                                                                                                                            (grind)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (replaces
                                                                                                                           -1)
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (skosimp*)
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (hide-all-but
                                                                                                         (-1
                                                                                                          +))
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "pseudo_div")
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "make_divlisttype")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("3"
                                                                                                    (skosimp*)
                                                                                                    (("3"
                                                                                                      (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))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("4" (hide 2)
          (("4" (skeep)
            (("4" (skeep)
              (("4" (skeep)
                (("4" (skeep)
                  (("4" (skeep)
                    (("4" (skeep)
                      (("4" (lemma "pseudo_div_lengths")
                        (("4" (inst - "g" "h" "n-m-i" "m" "n")
                          (("1" (assert)
                            (("1" (flatten)
                              (("1"
                                (assert)
                                (("1"
                                  (replace -8 :dir rl)
                                  (("1"
                                    (case "length(psd`reml)-1>=0")
                                    (("1"
                                      (expand "max")
                                      (("1" (assertnil nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (replace -8 1)
                                        (("2"
                                          (expand
                                           "pseudo_div"
                                           +)
                                          (("2"
                                            (expand "make_divlisttype")
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assertnil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("5" (hide 2) (("5" (skosimp*) (("5" (assertnil nil)) nil))
          nil)
         ("6" (hide 2) (("6" (skosimp*) (("6" (assertnil nil)) nil))
          nil)
         ("7" (hide 2) (("7" (skosimp*) (("7" (assertnil nil)) nil))
          nil)
         ("8" (hide 2) (("8" (skosimp*) (("8" (assertnil nil)) nil))
          nil)
         ("9" (hide 2) (("9" (skosimp*) (("9" (assertnil nil)) nil))
          nil))
        nil))
      nil)
     ("3" (hide 2)
      (("3" (skeep)
        (("3" (skeep)
          (("3" (skeep)
            (("3" (skeep)
              (("3" (skeep)
                (("3" (skeep)
                  (("3" (lemma "pseudo_div_lengths")
                    (("3" (inst - "g" "h" "n-m-i" "m" "n")
                      (("1" (assert)
                        (("1" (flatten)
                          (("1" (assert)
                            (("1" (replace -8 :dir rl)
                              (("1"
                                (case "length(psd`reml)-1>=0")
                                (("1"
                                  (expand "max")
                                  (("1" (assertnil nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (replace -8 1)
                                    (("2"
                                      (expand "pseudo_div" +)
                                      (("2"
                                        (expand "make_divlisttype")
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("4" (hide 2) (("4" (skosimp*) (("4" (assertnil nil)) nil)) nil)
     ("5" (hide 2)
      (("5" (skeep)
        (("5" (skeep)
          (("5" (skeep)
            (("5" (skeep)
              (("5" (skeep)
                (("5" (skeep) (("5" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("6" (hide 2) (("6" (skosimp*) (("6" (assertnil nil)) nil)) nil)
     ("7" (hide 2) (("7" (skosimp*) (("7" (assertnil nil)) nil)) nil)
     ("8" (hide 2) (("8" (skosimp*) (("8" (assertnil nil)) nil))
      nil))
    nil)
   ((i skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (m skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (n skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (i skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (m skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (n skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (x!1 skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (g skolem-const-decl "[nat -> int]" polynomial_pseudo_divide nil)
    (n skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (m skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (ii skolem-const-decl "int" polynomial_pseudo_divide nil)
    (h skolem-const-decl "[nat -> int]" polynomial_pseudo_divide nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (pseudo_div_lengths formula-decl nil
     polynomial_pseudo_divide nil)
    (poly_divide_lengths formula-decl nil polynomial_division nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (max_npreal_0 formula-decl nil min_max "reals/")
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (h skolem-const-decl "[nat -> int]" polynomial_pseudo_divide nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (x!1 skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (array2list_it def-decl
                   "{l: listn(n - i) | FORALL (j: subrange(i, n - 1)): a(j) = nth(l, j - i)}"
                   array2list "structures/")
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (n skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (m skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (g skolem-const-decl "[nat -> int]" polynomial_pseudo_divide nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (rat_expt application-judgement "rat" exponentiation nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (cons adt-constructor-decl "[[T, list] -> (cons?)]" list_adt nil)
    (cons? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (length_singleton formula-decl nil more_list_props "structures/")
    (expt_x1 formula-decl nil exponentiation nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (make_divtype const-decl "DivType" polynomial_division nil)
    (n skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (listn type-eq-decl nil listn "structures/")
    (below type-eq-decl nil naturalnumbers nil)
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (g skolem-const-decl "[nat -> int]" polynomial_pseudo_divide nil)
    (h skolem-const-decl "[nat -> int]" polynomial_pseudo_divide nil)
    (m skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (i skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (R skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (T skolem-const-decl "nat" polynomial_pseudo_divide nil)
    (expt def-decl "real" exponentiation nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (listn_0 name-judgement "listn[int](0)" polynomial_pseudo_divide
     nil)
    (listn_0 name-judgement "listn[real](0)" polynomial_division nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (null adt-constructor-decl "(null?)" list_adt nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (length_null formula-decl nil more_list_props "structures/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (make_divlisttype const-decl "DivListType" polynomial_pseudo_divide
                      nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (list type-decl nil list_adt nil)
    (DivListType type-eq-decl nil polynomial_pseudo_divide nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (PRED type-eq-decl nil defined_types nil)
    (every adt-def-decl "boolean" list_adt nil)
    (length def-decl "nat" list_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (DivType type-eq-decl nil polynomial_division nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (^ const-decl "real" exponentiation nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (GG const-decl "int" polynomial_pseudo_divide nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (HH const-decl "int" polynomial_pseudo_divide nil)
    (poly_divide def-decl "DivType" polynomial_division nil)
    (pseudo_div def-decl "{DT: DivListType |
         (m > n OR i > n - m AND length(DT`reml) = n + 1 AND DT`rdegl = n)
          OR
          (m = 0 AND length(DT`reml) = 0 AND DT`rdegl = 0) OR
           (m > 0 AND
             length(DT`reml) = m + i AND length(DT`reml) = DT`rdegl + 1)}"
                        polynomial_pseudo_divide nil))
   nil)
  (pseudo_div_def-5 nil 3593447223
   (""
    (case "FORALL (R, T: nat, g, h: [nat -> int], i, m, n: nat):
                                                                                     (h(m) /= 0 AND
                                                                                       i <= n - m AND
                                                                                        (FORALL (ii: nat): ii > n IMPLIES g(ii) = 0) AND
                                                                                         (FORALL (ii: nat): ii > m IMPLIES h(ii) = 0))
                                                                                      IMPLIES
                                                                                      LET psd = pseudo_div(g, n)(h, m)(n-m-i),
                                                                                          pd = poly_divide(g, n)(h, m)(n-m-i),
                                                                                          qlength = length(psd`quotl),
                                                                                          rlength = length(psd`reml)
                                                                                        IN
                                                                                        (pd`quot =
                                                                                          (LAMBDA (k: nat): (1 / h(m)) ^ GG(k, n, m, n-m-i, R, T)) *
                                                                                           (LAMBDA (k: nat):
                                                                                              IF k <= pd`qdeg AND k >= pd`qdeg - qlength + 1
                                                                                                THEN nth(psd`quotl, k - (pd`qdeg - qlength + 1))
                                                                                              ELSE 0
                                                                                              ENDIF))
                                                                                         AND
                                                                                         pd`rem =
                                                                                          (LAMBDA (k: nat): (1 / h(m)) ^ HH(k, n, m, n-m-i, R, T)) *
                                                                                           (LAMBDA (k: nat):
                                                                                              IF k <= pd`rdeg AND m > 0 THEN nth(psd`reml, k)
                                                                                              ELSE 0
                                                                                              ENDIF)")
    (("1" (skeep)
      (("1" (inst - "R" "T" "g" "h" "n-m-i" "m" "n")
        (("1" (assert)
          (("1" (replace -3)
            (("1" (replace -4) (("1" (propax) nil nil)) nil)) nil))
          nil)
         ("2" (assertnil nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "i")
        (("1" (assertnil nil)
         ("2" (assert)
          (("2" (skeep)
            (("2" (assert)
              (("2" (split +)
                (("1" (assert)
                  (("1" (expand "pseudo_div")
                    (("1" (expand "poly_divide")
                      (("1" (lift-if)
                        (("1" (expand "make_divtype")
                          (("1" (expand "make_divlisttype")
                            (("1" (split +)
                              (("1"
                                (flatten)
                                (("1"
                                  (decompose-equality +)
                                  (("1"
                                    (expand "*")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (typepred "array2list(1+n)(g)")
                                        (("1"
                                          (hide -1)
                                          (("1"
                                            (replaces -1)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "GG")
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (ground)
                                                    (("1"
                                                      (inst - "m+x!1")
                                                      (("1"
                                                        (replaces
                                                         -2
                                                         :dir
                                                         rl)
                                                        (("1"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst -4 "x!1")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (skosimp*)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (assert)
                                  (("2"
                                    (decompose-equality 2)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (ground)
                                        (("1"
                                          (expand "nth" + 1)
                                          (("1"
                                            (typepred
                                             "array2list(1+n)(g)")
                                            (("1"
                                              (inst - "n")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "length" +)
                                                  (("1"
                                                    (expand "*")
                                                    (("1"
                                                      (expand
                                                       "nth"
                                                       +
                                                       1)
                                                      (("1"
                                                        (replace
                                                         -3
                                                         :dir
                                                         rl)
                                                        (("1"
                                                          (expand "GG")
                                                          (("1"
                                                            (hide -)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand "*")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (expand "length" +)
                                              (("2"
                                                (lift-if)
                                                (("2"
                                                  (ground)
                                                  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))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (decompose-equality +)
                  (("1" (expand "*")
                    (("1" (expand "poly_divide" +)
                      (("1" (expand "make_divtype")
                        (("1" (expand "pseudo_div")
                          (("1" (expand "make_divlisttype")
                            (("1" (assert)
                              (("1"
                                (lift-if)
                                (("1"
                                  (lift-if)
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (split +)
                                            (("1" (propax) nil nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (split +)
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split +)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (name
                                                             "AA"
                                                             "array2list[int](n)
                      (LAMBDA (j: nat):
                         IF j > n THEN 0
                         ELSIF j < n - m
                           THEN h(m) * nth(array2list[int](1 + n)(g), j)
                         ELSE h(m) * nth(array2list[int](1 + n)(g), j) -
                               nth(array2list[int](1 + n)(g), n) * h(j - n + m)
                         ENDIF)")
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (typepred
                                                                 "AA")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "x!1")
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (typepred
                                                                         "array2list(1+n)(g)")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "x!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -6
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (replace
                                                                                 -3
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (expand
                                                                                   "HH")
                                                                                  (("1"
                                                                                    (hide
                                                                                     -)
                                                                                    (("1"
                                                                                      (grind)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "HH"
                                                                     +)
                                                                    (("2"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (skosimp*)
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("4"
                                                              (skosimp*)
                                                              (("4"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("5"
                                                              (skosimp*)
                                                              (("5"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (ground)
                                                              (("2"
                                                                (name
                                                                 "AA"
                                                                 "array2list[int](n)
                      (LAMBDA (j: nat):
                         IF j > n THEN 0
                         ELSIF j < n - m
                           THEN h(m) * nth(array2list[int](1 + n)(g), j)
                         ELSE h(m) * nth(array2list[int](1 + n)(g), j) -
                               nth(array2list[int](1 + n)(g), n) * h(j - n + m)
                         ENDIF)")
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (typepred
                                                                     "AA")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (replace
                                                                           -3
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (typepred
                                                                             "array2list(1+n)(g)")
                                                                            (("1"
                                                                              (inst-cp
                                                                               -
                                                                               "x!1")
                                                                              (("1"
                                                                                (replace
                                                                                 -4
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "n")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -3
                                                                                     :dir
                                                                                     rl)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "HH"
                                                                                       +)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -)
                                                                                        (("1"
                                                                                          (grind)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (skosimp*)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("3"
                                                                  (skosimp*)
                                                                  (("3"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("4"
                                                                  (skosimp*)
                                                                  (("4"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("5"
                                                                  (skosimp*)
                                                                  (("5"
                                                                    (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)
                   ("2" (skeep)
                    (("2" (assert)
                      (("2" (expand "pseudo_div")
                        (("2" (expand "make_divlisttype")
                          (("2" (expand "poly_divide")
                            (("2" (expand "make_divtype")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (skeep)
          (("3" (skeep)
            (("3" (inst - "R" "T" "g" "h" "m" "n")
              (("3" (assert)
                (("3" (replace -3)
                  (("3" (replace -4)
                    (("3" (flatten)
                      (("3" (name "ii" "-1 - j - m + n")
                        (("3" (replace -1)
                          (("3" (case "NOT n-m-j = ii+1")
                            (("1" (assertnil nil)
                             ("2" (replace -1)
                              (("2"
                                (assert)
                                (("2"
                                  (case "m = 0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "poly_divide" +)
                                          (("1"
                                            (expand "*")
                                            (("1"
                                              (expand "make_divtype")
                                              (("1"
                                                (expand
                                                 "pseudo_div"
                                                 +)
                                                (("1"
                                                  (expand
                                                   "make_divlisttype")
                                                  (("1"
                                                    (decompose-equality
                                                     2)
                                                    (("1"
                                                      (expand "GG" +)
                                                      (("1"
                                                        (typepred
                                                         "array2list(1+n)(g)")
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (split
                                                                   +)
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (replace
                                                                           -3
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (hide
                                                                             -)
                                                                            (("1"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     -2)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (assert)
                                    (("2"
                                      (split +)
                                      (("1"
                                        (lemma "poly_divide_lengths")
                                        (("1"
                                          (inst - "g" "h" "ii" "m" "n")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (lemma
                                                 "pseudo_div_lengths")
                                                (("1"
                                                  (inst
                                                   -
                                                   "g"
                                                   "h"
                                                   "ii"
                                                   "m"
                                                   "n")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (replace -4)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide
                                                             (-1
                                                              -2
                                                              -3
                                                              -4))
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "poly_divide"
                                                                   1)
                                                                  (("1"
                                                                    (expand
                                                                     "make_divtype")
                                                                    (("1"
                                                                      (lemma
                                                                       "poly_divide_lengths")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "g"
                                                                         "h"
                                                                         "ii+1"
                                                                         "m"
                                                                         "n")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (replaces
                                                                               -1)
                                                                              (("1"
                                                                                (replaces
                                                                                 -1)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "pseudo_div_lengths")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "g"
                                                                                     "h"
                                                                                     "ii+1"
                                                                                     "m"
                                                                                     "n")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (replaces
                                                                                           -4)
                                                                                          (("1"
                                                                                            (hide
                                                                                             (-1
                                                                                              -2
                                                                                              -3))
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "*")
                                                                                                (("1"
                                                                                                  (decompose-equality
                                                                                                   +)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -6)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (replace
                                                                                                         -5)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (lift-if)
                                                                                                            (("1"
                                                                                                              (lift-if)
                                                                                                              (("1"
                                                                                                                (lift-if)
                                                                                                                (("1"
                                                                                                                  (lift-if)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    (("1"
                                                                                                                      (ground)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "pseudo_div"
                                                                                                                         +
                                                                                                                         2)
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (expand
                                                                                                                             "make_divlisttype")
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "nth"
                                                                                                                               +
                                                                                                                               2)
                                                                                                                              (("1"
                                                                                                                                (lemma
                                                                                                                                 "pseudo_div_lengths")
                                                                                                                                (("1"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "g"
                                                                                                                                   "h"
                                                                                                                                   "ii+1"
                                                                                                                                   "m"
                                                                                                                                   "n")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    (("1"
                                                                                                                                      (flatten)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -2
                                                                                                                                         +)
                                                                                                                                        (("1"
                                                                                                                                          (lemma
                                                                                                                                           "poly_divide_lengths")
                                                                                                                                          (("1"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "g"
                                                                                                                                             "h"
                                                                                                                                             "ii+1"
                                                                                                                                             "m"
                                                                                                                                             "n")
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              (("1"
                                                                                                                                                (flatten)
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (replace
                                                                                                                                                     -2)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      (("1"
                                                                                                                                                        (expand
                                                                                                                                                         "HH")
                                                                                                                                                        (("1"
                                                                                                                                                          (expand
                                                                                                                                                           "GG")
                                                                                                                                                          (("1"
                                                                                                                                                            (hide
                                                                                                                                                             -)
                                                                                                                                                            (("1"
                                                                                                                                                              (grind
                                                                                                                                                               :exclude
                                                                                                                                                               ("nth"
                                                                                                                                                                "pseudo_div"))
                                                                                                                                                              nil
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (expand
                                                                                                                         "GG")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "pseudo_div"
                                                                                                                             +
                                                                                                                             2)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (expand
                                                                                                                                 "make_divlisttype")
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "nth"
                                                                                                                                   +
                                                                                                                                   2)
                                                                                                                                  (("2"
                                                                                                                                    (lift-if)
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (skosimp*)
                                                                                                    (("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)
                                       ("2"
                                        (assert)
                                        (("2"
                                          (lemma "poly_divide_lengths")
                                          (("2"
                                            (inst
                                             -
                                             "g"
                                             "h"
                                             "ii"
                                             "m"
                                             "n")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (lemma
                                                   "pseudo_div_lengths")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "g"
                                                     "h"
                                                     "ii"
                                                     "m"
                                                     "n")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (flatten)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (hide
                                                             (-1
                                                              -2
                                                              -3
                                                              -4))
                                                            (("2"
                                                              (replace
                                                               -2)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "poly_divide"
                                                                   1)
                                                                  (("2"
                                                                    (expand
                                                                     "make_divtype")
                                                                    (("2"
                                                                      (lemma
                                                                       "poly_divide_lengths")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "g"
                                                                         "h"
                                                                         "ii+1"
                                                                         "m"
                                                                         "n")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (replaces
                                                                               -1)
                                                                              (("2"
                                                                                (replaces
                                                                                 -1)
                                                                                (("2"
                                                                                  (lemma
                                                                                   "pseudo_div_lengths")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "g"
                                                                                     "h"
                                                                                     "ii+1"
                                                                                     "m"
                                                                                     "n")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (flatten)
                                                                                        (("2"
                                                                                          (replaces
                                                                                           -4)
                                                                                          (("2"
                                                                                            (hide
                                                                                             (-1
                                                                                              -2
                                                                                              -3))
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "*")
                                                                                                (("2"
                                                                                                  (decompose-equality
                                                                                                   +)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -6)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (lift-if)
                                                                                                          (("1"
                                                                                                            (lift-if)
                                                                                                            (("1"
                                                                                                              (lift-if)
                                                                                                              (("1"
                                                                                                                (lift-if)
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (ground)
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "pseudo_div"
                                                                                                                       +
                                                                                                                       2)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "make_divlisttype")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (invoke
                                                                                                                             (name
                                                                                                                              "AA"
                                                                                                                              "%1")
                                                                                                                             (!
                                                                                                                              1
                                                                                                                              2
                                                                                                                              2
                                                                                                                              1))
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (hide
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (typepred
                                                                                                                                   "AA")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "x!1")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -3
                                                                                                                                         :dir
                                                                                                                                         rl)
                                                                                                                                        (("1"
                                                                                                                                          (expand
                                                                                                                                           "HH")
                                                                                                                                          (("1"
                                                                                                                                            (lift-if)
                                                                                                                                            (("1"
                                                                                                                                              (ground)
                                                                                                                                              (("1"
                                                                                                                                                (expand
                                                                                                                                                 "^")
                                                                                                                                                (("1"
                                                                                                                                                  (expand
                                                                                                                                                   "expt"
                                                                                                                                                   +
                                                                                                                                                   2)
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (expand
                                                                                                                                                 "^")
                                                                                                                                                (("2"
                                                                                                                                                  (expand
                                                                                                                                                   "expt"
                                                                                                                                                   +
                                                                                                                                                   2)
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (skosimp*)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("3"
                                                                                                                                (skeep)
                                                                                                                                (("3"
                                                                                                                                  (assert)
                                                                                                                                  (("3"
                                                                                                                                    (lemma
                                                                                                                                     "pseudo_div_lengths")
                                                                                                                                    (("3"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "g"
                                                                                                                                       "h"
                                                                                                                                       "1+ii"
                                                                                                                                       "m"
                                                                                                                                       "n")
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        (("3"
                                                                                                                                          (flatten)
                                                                                                                                          (("3"
                                                                                                                                            (replace
                                                                                                                                             -3
                                                                                                                                             +)
                                                                                                                                            (("3"
                                                                                                                                              (expand
                                                                                                                                               "max"
                                                                                                                                               +)
                                                                                                                                              (("3"
                                                                                                                                                (lift-if)
                                                                                                                                                (("3"
                                                                                                                                                  (assert)
                                                                                                                                                  (("3"
                                                                                                                                                    (ground)
                                                                                                                                                    (("3"
                                                                                                                                                      (hide-all-but
                                                                                                                                                       (-1
                                                                                                                                                        +))
                                                                                                                                                      (("3"
                                                                                                                                                        (expand
                                                                                                                                                         "pseudo_div")
                                                                                                                                                        (("3"
                                                                                                                                                          (expand
                                                                                                                                                           "make_divlisttype")
                                                                                                                                                          (("3"
                                                                                                                                                            (assert)
                                                                                                                                                            nil
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("4"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("4"
                                                                                                                                (hide
                                                                                                                                 (-6
                                                                                                                                  -7))
                                                                                                                                (("4"
                                                                                                                                  (skosimp*)
                                                                                                                                  (("4"
                                                                                                                                    (assert)
                                                                                                                                    (("4"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("4"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("4"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("5"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("5"
                                                                                                                                (skosimp*)
                                                                                                                                (("5"
                                                                                                                                  (assert)
                                                                                                                                  (("5"
                                                                                                                                    (hide
                                                                                                                                     (-7
                                                                                                                                      -8))
                                                                                                                                    (("5"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("5"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("5"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (expand
                                                                                                                       "pseudo_div"
                                                                                                                       +
                                                                                                                       3)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "make_divlisttype")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (invoke
                                                                                                                             (name
                                                                                                                              "AA"
                                                                                                                              "%1")
                                                                                                                             (!
                                                                                                                              1
                                                                                                                              2
                                                                                                                              2
                                                                                                                              1))
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (hide
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (typepred
                                                                                                                                   "AA")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "x!1")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -3
                                                                                                                                         +
                                                                                                                                         :dir
                                                                                                                                         rl)
                                                                                                                                        (("1"
                                                                                                                                          (hide
                                                                                                                                           -1)
                                                                                                                                          (("1"
                                                                                                                                            (hide
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (lemma
                                                                                                                                               "pseudo_div_lengths")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "g"
                                                                                                                                                 "h"
                                                                                                                                                 "ii+1"
                                                                                                                                                 "m"
                                                                                                                                                 "n")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (flatten)
                                                                                                                                                    (("1"
                                                                                                                                                      (replace
                                                                                                                                                       -2)
                                                                                                                                                      (("1"
                                                                                                                                                        (replace
                                                                                                                                                         -3)
                                                                                                                                                        (("1"
                                                                                                                                                          (case
                                                                                                                                                           "length(pseudo_div(g, n)(h, m)(1 + ii)`reml) - 1>=0")
                                                                                                                                                          (("1"
                                                                                                                                                            (expand
                                                                                                                                                             "max")
                                                                                                                                                            (("1"
                                                                                                                                                              (assert)
                                                                                                                                                              (("1"
                                                                                                                                                                (expand
                                                                                                                                                                 "pseudo_div"
                                                                                                                                                                 +
                                                                                                                                                                 5)
                                                                                                                                                                (("1"
                                                                                                                                                                  (expand
                                                                                                                                                                   "make_divlisttype")
                                                                                                                                                                  (("1"
                                                                                                                                                                    (replaces
                                                                                                                                                                     -1)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (name
                                                                                                                                                                       "AB"
                                                                                                                                                                       "array2list[int](1 + ii + m)
                              (LAMBDA (j: nat):
                                 IF j > 1 + ii + m THEN 0
                                 ELSIF j < 1 + ii
                                   THEN h(m)
                                        *
                                        nth
                                        (IF 1 + ii = n - m
                                         THEN array2list[int](1 + n)(g)
                                         ELSE pseudo_div
                                              (g, n)(h, m)(2 + ii)`reml
                                         ENDIF,
                                         j)
                                 ELSE h(m)
                                      *
                                      nth
                                      (IF 1 + ii = n - m
                                       THEN array2list[int](1 + n)(g)
                                       ELSE pseudo_div
                                            (g, n)(h, m)(2 + ii)`reml
                                       ENDIF,
                                       j)
                                      -
                                      nth
                                      (IF 1 + ii = n - m
                                       THEN array2list[int](1 + n)(g)
                                       ELSE pseudo_div
                                            (g, n)(h, m)(2 + ii)`reml
                                       ENDIF,
                                       IF 1 + ii = n - m
                                       THEN n
                                       ELSE pseudo_div
                                            (g, n)(h, m)(2 + ii)`rdegl
                                       ENDIF)
                                      *
                                      h(j - 1 - ii)
                                 ENDIF)")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (replaces
                                                                                                                                                                         -1)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (typepred
                                                                                                                                                                           "AB")
                                                                                                                                                                          (("1"
                                                                                                                                                                            (replaces
                                                                                                                                                                             -2)
                                                                                                                                                                            (("1"
                                                                                                                                                                              (hide
                                                                                                                                                                               -3)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (assert)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (hide
                                                                                                                                                                                   (-1
                                                                                                                                                                                    -2
                                                                                                                                                                                    -3
                                                                                                                                                                                    -4
                                                                                                                                                                                    -5
                                                                                                                                                                                    -6
                                                                                                                                                                                    -7))
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "HH")
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (assert)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (lift-if)
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (split
                                                                                                                                                                                           +)
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (flatten)
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              (("1"
                                                                                                                                                                                                (expand
                                                                                                                                                                                                 "^")
                                                                                                                                                                                                (("1"
                                                                                                                                                                                                  (expand
                                                                                                                                                                                                   "expt"
                                                                                                                                                                                                   +
                                                                                                                                                                                                   3)
                                                                                                                                                                                                  (("1"
                                                                                                                                                                                                    (expand
                                                                                                                                                                                                     "expt"
                                                                                                                                                                                                     +
                                                                                                                                                                                                     4)
                                                                                                                                                                                                    (("1"
                                                                                                                                                                                                      (assert)
                                                                                                                                                                                                      nil
                                                                                                                                                                                                      nil))
                                                                                                                                                                                                    nil))
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil)
                                                                                                                                                                                           ("2"
                                                                                                                                                                                            (flatten)
                                                                                                                                                                                            (("2"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              (("2"
                                                                                                                                                                                                (expand
                                                                                                                                                                                                 "^")
                                                                                                                                                                                                (("2"
                                                                                                                                                                                                  (expand
                                                                                                                                                                                                   "expt"
                                                                                                                                                                                                   +
                                                                                                                                                                                                   3)
                                                                                                                                                                                                  (("2"
                                                                                                                                                                                                    (expand
                                                                                                                                                                                                     "expt"
                                                                                                                                                                                                     +
                                                                                                                                                                                                     4)
                                                                                                                                                                                                    (("2"
                                                                                                                                                                                                      (assert)
                                                                                                                                                                                                      nil
                                                                                                                                                                                                      nil))
                                                                                                                                                                                                    nil))
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil))
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("2"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("2"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("2"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("3"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("3"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("3"
                                                                                                                                                                            (assert)
                                                                                                                                                                            (("3"
                                                                                                                                                                              (hide
                                                                                                                                                                               -)
                                                                                                                                                                              (("3"
                                                                                                                                                                                (expand
                                                                                                                                                                                 "pseudo_div")
                                                                                                                                                                                (("3"
                                                                                                                                                                                  (expand
                                                                                                                                                                                   "make_divlisttype")
                                                                                                                                                                                  (("3"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("4"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("4"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("4"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("5"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("5"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("5"
                                                                                                                                                                            (assert)
                                                                                                                                                                            (("5"
                                                                                                                                                                              (lift-if)
                                                                                                                                                                              (("5"
                                                                                                                                                                                (hide
                                                                                                                                                                                 -)
                                                                                                                                                                                (("5"
                                                                                                                                                                                  (expand
                                                                                                                                                                                   "pseudo_div")
                                                                                                                                                                                  (("5"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "make_divlisttype")
                                                                                                                                                                                    (("5"
                                                                                                                                                                                      (ground)
                                                                                                                                                                                      nil
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("6"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("6"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("6"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("7"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("7"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("7"
                                                                                                                                                                            (assert)
                                                                                                                                                                            (("7"
                                                                                                                                                                              (hide
                                                                                                                                                                               -)
                                                                                                                                                                              (("7"
                                                                                                                                                                                (lift-if)
                                                                                                                                                                                (("7"
                                                                                                                                                                                  (ground)
                                                                                                                                                                                  (("7"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "pseudo_div")
                                                                                                                                                                                    (("7"
                                                                                                                                                                                      (expand
                                                                                                                                                                                       "make_divlisttype")
                                                                                                                                                                                      (("7"
                                                                                                                                                                                        (assert)
                                                                                                                                                                                        nil
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("8"
                                                                                                                                                                        (hide
                                                                                                                                                                         2)
                                                                                                                                                                        (("8"
                                                                                                                                                                          (skosimp*)
                                                                                                                                                                          (("8"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil)
                                                                                                                                                           ("2"
                                                                                                                                                            (hide
                                                                                                                                                             2)
                                                                                                                                                            (("2"
                                                                                                                                                              (assert)
                                                                                                                                                              (("2"
                                                                                                                                                                (hide
                                                                                                                                                                 -)
                                                                                                                                                                (("2"
                                                                                                                                                                  (expand
                                                                                                                                                                   "pseudo_div")
                                                                                                                                                                  (("2"
                                                                                                                                                                    (expand
                                                                                                                                                                     "make_divlisttype")
                                                                                                                                                                    (("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"
                                                                                                                                (skosimp*)
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("3"
                                                                                                                                (skosimp*)
                                                                                                                                (("3"
                                                                                                                                  (hide
                                                                                                                                   -)
                                                                                                                                  (("3"
                                                                                                                                    (assert)
                                                                                                                                    (("3"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("3"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("3"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("4"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("4"
                                                                                                                                (skosimp*)
                                                                                                                                (("4"
                                                                                                                                  (assert)
                                                                                                                                  (("4"
                                                                                                                                    (hide
                                                                                                                                     -)
                                                                                                                                    (("4"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("4"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("4"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("5"
                                                                                                                              (hide
                                                                                                                               2)
                                                                                                                              (("5"
                                                                                                                                (skosimp*)
                                                                                                                                (("5"
                                                                                                                                  (assert)
                                                                                                                                  (("5"
                                                                                                                                    (hide
                                                                                                                                     -)
                                                                                                                                    (("5"
                                                                                                                                      (expand
                                                                                                                                       "pseudo_div")
                                                                                                                                      (("5"
                                                                                                                                        (expand
                                                                                                                                         "make_divlisttype")
                                                                                                                                        (("5"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("3"
                                                                                                                      (assert)
                                                                                                                      (("3"
                                                                                                                        (case
                                                                                                                         "NOT x!1=ii+m")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (case
                                                                                                                             "FORALL (kn:nat): kn>ii-1+m AND kn<=ii+m IMPLIES kn = ii+m")
                                                                                                                            (("1"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "x!1")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (hide-all-but
                                                                                                                               1)
                                                                                                                              (("2"
                                                                                                                                (skeep)
                                                                                                                                (("2"
                                                                                                                                  (case
                                                                                                                                   "kn>=ii+m")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (hide-all-but
                                                                                                                                       (-1
                                                                                                                                        1))
                                                                                                                                      (("2"
                                                                                                                                        (case
                                                                                                                                         "FORALL (a1,a2:nat): a1>a2-1 IMPLIES a1>=a2")
                                                                                                                                        (("1"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           "kn"
                                                                                                                                           "ii+m")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (hide-all-but
                                                                                                                                           1)
                                                                                                                                          (("2"
                                                                                                                                            (grind)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (replaces
                                                                                                                           -1)
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (skosimp*)
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (hide-all-but
                                                                                                         (-1
                                                                                                          +))
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "pseudo_div")
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "make_divlisttype")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("3"
                                                                                                    (skosimp*)
                                                                                                    (("3"
                                                                                                      (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))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("4" (hide 2)
          (("4" (skeep)
            (("4" (skeep)
              (("4" (skeep)
                (("4" (skeep)
                  (("4" (skeep)
                    (("4" (skeep)
                      (("4" (lemma "pseudo_div_lengths")
                        (("4" (inst - "g" "h" "n-m-i" "m" "n")
                          (("1" (assert)
                            (("1" (flatten)
                              (("1"
                                (assert)
                                (("1"
                                  (replace -8 :dir rl)
                                  (("1"
                                    (case "length(psd`reml)-1>=0")
                                    (("1"
                                      (expand "max")
                                      (("1" (assertnil nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (replace -8 1)
                                        (("2"
                                          (expand
                                           "pseudo_div"
                                           +)
                                          (("2"
                                            (expand "make_divlisttype")
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assertnil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("5" (hide 2) (("5" (skosimp*) (("5" (assertnil nil)) nil))
          nil)
         ("6" (hide 2) (("6" (skosimp*) (("6" (assertnil nil)) nil))
          nil)
         ("7" (hide 2) (("7" (skosimp*) (("7" (assertnil nil)) nil))
          nil)
         ("8" (hide 2) (("8" (skosimp*) (("8" (assertnil nil)) nil))
          nil)
         ("9" (hide 2) (("9" (skosimp*) (("9" (assertnil nil)) nil))
          nil))
        nil))
      nil)
     ("3" (hide 2)
      (("3" (skeep)
        (("3" (skeep)
          (("3" (skeep)
            (("3" (skeep)
              (("3" (skeep)
                (("3" (skeep)
                  (("3" (lemma "pseudo_div_lengths")
                    (("3" (inst - "g" "h" "n-m-i" "m" "n")
                      (("1" (assert)
                        (("1" (flatten)
                          (("1" (assert)
                            (("1" (replace -8 :dir rl)
                              (("1"
                                (case "length(psd`reml)-1>=0")
                                (("1"
                                  (expand "max")
                                  (("1" (assertnil nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (replace -8 1)
                                    (("2"
                                      (expand "pseudo_div" +)
                                      (("2"
                                        (expand "make_divlisttype")
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("4" (hide 2) (("4" (skosimp*) (("4" (assertnil nil)) nil)) nil)
     ("5" (hide 2)
      (("5" (skeep)
        (("5" (skeep)
          (("5" (skeep)
            (("5" (skeep)
              (("5" (skeep)
                (("5" (skeep) (("5" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("6" (hide 2) (("6" (skosimp*) (("6" (assertnil nil)) nil)) nil)
     ("7" (hide 2) (("7" (skosimp*) (("7" (assertnil nil)) nil)) nil)
     ("8" (hide 2) (("8" (skosimp*) (("8" (assertnil nil)) nil))
      nil))
    nil)
   ((poly_divide_lengths formula-decl nil polynomial_division nil)
    (array2list_it def-decl
                   "{l: listn(n - i) | FORALL (j: subrange(i, n - 1)): a(j) = nth(l, j - i)}"
                   array2list "structures/")
    (make_divtype const-decl "DivType" polynomial_division nil)
    (listn type-eq-decl nil listn "structures/")
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (null adt-constructor-decl "(null?)" list_adt nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (cons adt-constructor-decl "[[T, list] -> (cons?)]" list_adt nil)
    (cons? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (list type-decl nil list_adt nil)
    (DivType type-eq-decl nil polynomial_division nil)
    (poly_divide def-decl "DivType" polynomial_division nil))
   nil)
  (pseudo_div_def-4 nil 3583833143
   (""
    (case "FORALL (R, T: nat, g, h: [nat -> real], i, m, n: nat):
                                                                       (h(m) /= 0 AND
                                                                         i <= n - m AND
                                                                          (FORALL (ii: nat): ii > n IMPLIES g(ii) = 0) AND
                                                                           (FORALL (ii: nat): ii > m IMPLIES h(ii) = 0))
                                                                        IMPLIES
                                                                        LET psd = pseudo_div(g, n)(h, m)(n-m-i),
                                                                            pd = poly_divide(g, n)(h, m)(n-m-i),
                                                                            qlength = length(psd`quotl),
                                                                            rlength = length(psd`reml)
                                                                          IN
                                                                          (pd`quot =
                                                                            (LAMBDA (k: nat): (1 / h(m)) ^ GG(k, n, m, n-m-i, R, T)) *
                                                                             (LAMBDA (k: nat):
                                                                                IF k <= pd`qdeg AND k >= pd`qdeg - qlength + 1
                                                                                  THEN nth(psd`quotl, k - (pd`qdeg - qlength + 1))
                                                                                ELSE 0
                                                                                ENDIF))
                                                                           AND
                                                                           pd`rem =
                                                                            (LAMBDA (k: nat): (1 / h(m)) ^ HH(k, n, m, n-m-i, R, T)) *
                                                                             (LAMBDA (k: nat):
                                                                                IF k <= pd`rdeg AND m > 0 THEN nth(psd`reml, k)
                                                                                ELSE 0
                                                                                ENDIF)")
    (("1" (skeep)
      (("1" (inst - "R" "T" "g" "h" "n-m-i" "m" "n")
        (("1" (assert)
          (("1" (replace -3)
            (("1" (replace -4) (("1" (propax) nil)))))))
         ("2" (assertnil)))))
     ("2" (hide 2)
      (("2" (induct "i")
        (("1" (assertnil)
         ("2" (assert)
          (("2" (skeep)
            (("2" (assert)
              (("2" (split +)
                (("1" (assert)
                  (("1" (expand "pseudo_div")
                    (("1" (expand "poly_divide")
                      (("1" (lift-if)
                        (("1" (expand "make_divtype")
                          (("1" (expand "make_divlisttype")
                            (("1" (split +)
                              (("1"
                                (flatten)
                                (("1"
                                  (decompose-equality +)
                                  (("1"
                                    (expand "*")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (typepred "array2list(1+n)(g)")
                                        (("1"
                                          (hide -1)
                                          (("1"
                                            (replaces -1)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "GG")
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (ground)
                                                    (("1"
                                                      (inst - "m+x!1")
                                                      (("1"
                                                        (replaces
                                                         -2
                                                         :dir
                                                         rl)
                                                        (("1"
                                                          (grind)
                                                          nil)))))
                                                     ("2"
                                                      (inst -4 "x!1")
                                                      (("2"
                                                        (assert)
                                                        nil)))))))))))))))))))))
                                   ("2"
                                    (skosimp*)
                                    (("2" (assertnil)))))))
                               ("2"
                                (flatten)
                                (("2"
                                  (assert)
                                  (("2"
                                    (decompose-equality 2)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (ground)
                                        (("1"
                                          (expand "nth" + 1)
                                          (("1"
                                            (typepred
                                             "array2list(1+n)(g)")
                                            (("1"
                                              (inst - "n")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "length" +)
                                                  (("1"
                                                    (expand "*")
                                                    (("1"
                                                      (expand
                                                       "nth"
                                                       +
                                                       1)
                                                      (("1"
                                                        (replace
                                                         -3
                                                         :dir
                                                         rl)
                                                        (("1"
                                                          (expand "GG")
                                                          (("1"
                                                            (hide -)
                                                            (("1"
                                                              (grind)
                                                              nil)))))))))))))))))))))
                                         ("2"
                                          (expand "*")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (expand "length" +)
                                              (("2"
                                                (lift-if)
                                                (("2"
                                                  (ground)
                                                  nil)))))))))))))
                                     ("2"
                                      (skosimp*)
                                      (("2" (assertnil)))
                                     ("3"
                                      (skosimp*)
                                      (("3" (assertnil)))
                                     ("4"
                                      (skosimp*)
                                      (("4"
                                        (assert)
                                        nil)))))))))))))))))))))))
                 ("2" (decompose-equality +)
                  (("1" (expand "*")
                    (("1" (expand "poly_divide" +)
                      (("1" (expand "make_divtype")
                        (("1" (expand "pseudo_div")
                          (("1" (expand "make_divlisttype")
                            (("1" (assert)
                              (("1"
                                (lift-if)
                                (("1"
                                  (lift-if)
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (split +)
                                            (("1" (propax) nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (split +)
                                                  (("1" (propax) nil)
                                                   ("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split +)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (invoke
                                                             (name
                                                              "AA"
                                                              "%1")
                                                             (!
                                                              1
                                                              2
                                                              2
                                                              1))
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (typepred
                                                                 "AA")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "x!1")
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (typepred
                                                                         "array2list(1+n)(g)")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "x!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -6
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (replace
                                                                                 -3
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (expand
                                                                                   "HH")
                                                                                  (("1"
                                                                                    (hide
                                                                                     -)
                                                                                    (("1"
                                                                                      (grind)
                                                                                      nil)))))))))))))))))))
                                                                   ("2"
                                                                    (expand
                                                                     "HH"
                                                                     +)
                                                                    (("2"
                                                                      (grind)
                                                                      nil)))))))))
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (assert)
                                                                nil)))
                                                             ("3"
                                                              (skosimp*)
                                                              (("3"
                                                                (assert)
                                                                nil)))
                                                             ("4"
                                                              (skosimp*)
                                                              (("4"
                                                                (assert)
                                                                nil)))
                                                             ("5"
                                                              (skosimp*)
                                                              (("5"
                                                                (assert)
                                                                nil)))))))
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (ground)
                                                              (("2"
                                                                (invoke
                                                                 (name
                                                                  "AA"
                                                                  "%1")
                                                                 (!
                                                                  1
                                                                  2
                                                                  2
                                                                  1))
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (typepred
                                                                     "AA")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (replace
                                                                           -3
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (typepred
                                                                             "array2list(1+n)(g)")
                                                                            (("1"
                                                                              (inst-cp
                                                                               -
                                                                               "x!1")
                                                                              (("1"
                                                                                (replace
                                                                                 -4
                                                                                 :dir
                                                                                 rl)
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "n")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -3
                                                                                     :dir
                                                                                     rl)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "HH"
                                                                                       +)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -)
                                                                                        (("1"
                                                                                          (grind)
                                                                                          nil)))))))))))))))))))))))))
                                                                 ("2"
                                                                  (skosimp*)
                                                                  (("2"
                                                                    (assert)
                                                                    nil)))
                                                                 ("3"
                                                                  (skosimp*)
                                                                  (("3"
                                                                    (assert)
                                                                    nil)))
                                                                 ("4"
                                                                  (skosimp*)
                                                                  (("4"
                                                                    (assert)
                                                                    nil)))
                                                                 ("5"
                                                                  (skosimp*)
                                                                  (("5"
                                                                    (assert)
                                                                    nil)))))))))))))))))))))))))))))))))))))))))))))))))
                   ("2" (skeep)
                    (("2" (assert)
                      (("2" (expand "pseudo_div")
                        (("2" (expand "make_divlisttype")
                          (("2" (expand "poly_divide")
                            (("2" (expand "make_divtype")
                              (("2" (assertnil)))))))))))))))))))))))
         ("3" (skeep)
          (("3" (skeep)
            (("3" (inst - "R" "T" "g" "h" "m" "n")
              (("3" (assert)
                (("3" (replace -3)
                  (("3" (replace -4)
                    (("3" (flatten)
                      (("3" (name "ii" "-1 - j - m + n")
                        (("3" (replace -1)
                          (("3" (case "NOT n-m-j = ii+1")
                            (("1" (assertnil)
                             ("2" (replace -1)
                              (("2"
                                (assert)
                                (("2"
                                  (case "m = 0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "poly_divide" +)
                                          (("1"
                                            (expand "*")
                                            (("1"
                                              (expand "make_divtype")
                                              (("1"
                                                (expand
                                                 "pseudo_div"
                                                 +)
                                                (("1"
                                                  (expand
                                                   "make_divlisttype")
                                                  (("1"
                                                    (decompose-equality
                                                     2)
                                                    (("1"
                                                      (expand "GG" +)
                                                      (("1"
                                                        (typepred
                                                         "array2list(1+n)(g)")
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (split
                                                                   +)
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "x!1")
                                                                      (("1"
--> --------------------

--> maximum size reached

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

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

¤ 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.0.770Bemerkung:  (vorverarbeitet am  2026-04-30) ¤

*Bot Zugriff






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.