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


Quelle  matrix_det.prf

  Sprache: Lisp
 

(matrix_det
 (Esr_TCC1 0
  (Esr_TCC1-1 nil 3615028556
   ("" (skeep)
    (("" (assert)
      (("" (split)
        (("1" (rewrite "rows_form_matrix"nil nil)
         ("2" (lemma "columns_form_matrix")
          (("2" (assert)
            (("2" (inst?)
              (("2" (assert)
                (("2" (rewrite "rows_form_matrix")
                  (("2" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (rewrite "rows_form_matrix") (("3" (assertnil nil))
          nil)
         ("4" (lemma "columns_form_matrix")
          (("4" (inst?) (("4" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (columns_form_matrix formula-decl nil matrices nil)
    (rows_form_matrix formula-decl nil matrices 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (entry_Esr 0
  (entry_Esr-1 nil 3615030016
   ("" (skeep)
    (("" (expand "Esr")
      (("" (rewrite "entry_form_matrix")
        (("" (lift-if)
          (("" (lift-if)
            (("" (lift-if)
              (("" (lift-if)
                (("" (lift-if) (("" (ground) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (real_ge_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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (/= const-decl "boolean" notequal nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (entry_form_matrix formula-decl nil matrices nil))
   shostak))
 (rows_Esr 0
  (rows_Esr-1 nil 3615028664
   ("" (skeep)
    (("" (expand "Esr") (("" (rewrite "rows_form_matrix"nil nil))
      nil))
    nil)
   ((Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (/= const-decl "boolean" notequal nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (rows_form_matrix formula-decl nil matrices nil))
   shostak))
 (columns_Esr 0
  (columns_Esr-1 nil 3615028700
   ("" (skeep)
    (("" (expand "Esr")
      (("" (lemma "columns_form_matrix")
        (("" (inst?) (("" (assertnil nil)) nil)) nil))
      nil))
    nil)
   ((Esr const-decl "SquareMatrix(pn)" matrix_det 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (/= const-decl "boolean" notequal nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (columns_form_matrix formula-decl nil matrices nil))
   shostak))
 (det_Esr 0
  (det_Esr-1 nil 3615047615
   ("" (skeep)
    (("" (lemma "det_replace_row_scal")
      (("" (inst - "Id(pn)" "i" "r" "row(Id(pn))(i)")
        (("" (assert)
          (("" (split -)
            (("1" (rewrite "replace_row_id")
              (("1" (rewrite "det_Id")
                (("1" (assert)
                  (("1"
                    (case "replace_row(i, r * row(Id(pn))(i))(Id(pn)) = Esr(pn)(i,r)")
                    (("1" (assertnil nil)
                     ("2" (hide (-1 2))
                      (("2" (rewrite "full_matrix_eq")
                        (("2" (skosimp*)
                          (("2" (rewrite "entry_replace_row")
                            (("1" (rewrite "entry_Esr")
                              (("1"
                                (rewrite "entry_Id")
                                (("1"
                                  (rewrite "access_scal")
                                  (("1"
                                    (lemma "entry_Id")
                                    (("1"
                                      (inst - "i" "j!1" "pn")
                                      (("1"
                                        (expand "entry" -1)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (replaces -1)
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (lift-if)
                                                    (("1"
                                                      (ground)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (rewrite "columns_Id")
                              (("2"
                                (typepred "r*row(Id(pn))(i)")
                                (("2"
                                  (replaces -2)
                                  (("2"
                                    (rewrite "length_row")
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (rewrite "length_row"nil nil)
             ("3" (assertnil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((det_replace_row_scal formula-decl nil matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (replace_row_id formula-decl nil matrix_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (columns_Id formula-decl nil matrices nil)
    (length_row formula-decl nil matrix_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (entry_Esr formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (access_scal formula-decl nil matrices nil)
    (entry_Id formula-decl nil matrices nil)
    (entry_replace_row formula-decl nil matrix_props nil)
    (full_matrix_eq formula-decl nil matrices nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (replace_row def-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (j):
              row(PFM)(j) =
               IF j < rows(D) AND j = i THEN v ELSE row(D)(j) ENDIF)
            AND
            (FORALL (j, k):
               entry(PFM)(j, k) =
                IF j < rows(D) AND j = i THEN access(v)(k)
                ELSE entry(D)(j, k)
                ENDIF)}" matrix_props nil)
    (access const-decl "real" matrices nil)
    (det_Id formula-decl nil matrix_props nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (entry const-decl "real" matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals 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)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (real nonempty-type-from-decl nil reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices 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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (transpose_Esr 0
  (transpose_Esr-1 nil 3615817279
   ("" (skeep)
    (("" (rewrite "full_matrix_eq")
      (("" (split)
        (("1" (rewrite "rows_transpose") (("1" (assertnil nil)) nil)
         ("2" (rewrite "columns_transpose" +) (("2" (assertnil nil))
          nil)
         ("3" (skosimp*)
          (("3" (rewrite "entry_transpose")
            (("3" (rewrite "entry_Esr")
              (("3" (rewrite "entry_Esr")
                (("3" (lift-if)
                  (("3" (lift-if)
                    (("3" (lift-if)
                      (("3" (lift-if) (("3" (ground) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((full_matrix_eq formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (transpose const-decl "PosFullMatrix" matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (entry_Esr formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_transpose formula-decl nil matrices nil)
    (columns_transpose formula-decl nil matrices nil)
    (rows_transpose formula-decl nil matrices nil))
   shostak))
 (mult_Esr_left_TCC1 0
  (mult_Esr_left_TCC1-1 nil 3615028556
   ("" (skeep)
    (("" (typepred "r*row(D)(i)")
      (("" (replace -2)
        (("" (rewrite "length_row" 1)
          (("" (assert)
            (("" (lift-if)
              (("" (ground) (("" (postpone) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (row const-decl "Vector" matrices nil)
    (Matrix type-eq-decl nil matrices nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (length def-decl "nat" list_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Vector type-eq-decl nil matrices 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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (list type-decl nil list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (length_row formula-decl nil matrix_props nil)
    (real_ge_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))
   nil))
 (mult_Esr_left 0
  (mult_Esr_left-1 nil 3615028557
   ("" (skeep)
    (("" (rewrite "full_matrix_eq")
      (("" (split)
        (("1" (rewrite "rows_mult")
          (("1" (rewrite "rows_Esr")
            (("1" (rewrite "rows_replace_row") (("1" (assertnil nil))
              nil))
            nil))
          nil)
         ("2" (lemma "columns_mult")
          (("2" (inst?)
            (("2" (assert) (("2" (hide 1) (("2" (grind) nil nil)) nil))
              nil))
            nil))
          nil)
         ("3" (skosimp*)
          (("3" (rewrite "entry_mult")
            (("3" (assert)
              (("3" (expand "*" + 1)
                (("3" (lift-if)
                  (("3" (ground)
                    (("1" (lemma "rows_Esr")
                      (("1" (inst?)
                        (("1" (rewrite "entry_replace_row")
                          (("1" (lift-if)
                            (("1" (ground)
                              (("1"
                                (rewrite "dot_eq_sigma")
                                (("1"
                                  (rewrite "length_row")
                                  (("1"
                                    (rewrite "length_col")
                                    (("1"
                                      (rewrite "columns_Esr")
                                      (("1"
                                        (expand "min")
                                        (("1"
                                          (lemma "sigma_eq_one_arg")
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (inst - "i!1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (split -)
                                                  (("1"
                                                    (replaces -1)
                                                    (("1"
                                                      (rewrite
                                                       "access_scal")
                                                      (("1"
                                                        (lemma
                                                         "entry_Esr")
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "i!1"
                                                             "i!1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "entry"
                                                                 -1)
                                                                (("1"
                                                                  (replaces
                                                                   -1)
                                                                  (("1"
                                                                    (rewrite
                                                                     "access_col")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (hide 2)
                                                      (("2"
                                                        (lemma
                                                         "entry_Esr")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "i"
                                                           "i!2"
                                                           "i!1"
                                                           "pn"
                                                           "r")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (expand
                                                               "entry"
                                                               -1)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (hide 2)
                                                    (("3"
                                                      (skosimp*)
                                                      (("3"
                                                        (lemma
                                                         "entry_Esr")
                                                        (("3"
                                                          (inst
                                                           -
                                                           "i"
                                                           "i!2"
                                                           "i!1"
                                                           "pn"
                                                           "r")
                                                          (("3"
                                                            (assert)
                                                            (("3"
                                                              (expand
                                                               "entry"
                                                               -1)
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (rewrite "dot_eq_sigma")
                                (("2"
                                  (rewrite "length_row")
                                  (("2"
                                    (rewrite "length_col")
                                    (("2"
                                      (rewrite "columns_Esr")
                                      (("2"
                                        (replace -4)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (expand "min")
                                            (("2"
                                              (lemma
                                               "sigma_eq_one_arg")
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (inst - "i!1")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (split -)
                                                      (("1"
                                                        (replaces -1)
                                                        (("1"
                                                          (lemma
                                                           "entry_Esr")
                                                          (("1"
                                                            (inst?)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "i!1"
                                                               "i!1")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "entry"
                                                                   -1)
                                                                  (("1"
                                                                    (replaces
                                                                     -1)
                                                                    (("1"
                                                                      (rewrite
                                                                       "access_col")
                                                                      (("1"
                                                                        (expand
                                                                         "entry")
                                                                        (("1"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 3)
                                                        (("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (lemma
                                                             "entry_Esr")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "i"
                                                               "i!2"
                                                               "i!1"
                                                               "pn"
                                                               "r")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "entry")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (hide 3)
                                                        (("3"
                                                          (skosimp*)
                                                          (("3"
                                                            (lemma
                                                             "entry_Esr")
                                                            (("3"
                                                              (inst
                                                               -
                                                               "i"
                                                               "i!2"
                                                               "i!1"
                                                               "pn"
                                                               "r")
                                                              (("3"
                                                                (assert)
                                                                (("3"
                                                                  (expand
                                                                   "entry")
                                                                  (("3"
                                                                    (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" (typepred "r*row(D)(i)")
                              (("2"
                                (replaces -2)
                                (("2" (rewrite "length_row"nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (rewrite "rows_Esr")
                      (("2" (rewrite "entry_replace_row")
                        (("1" (expand "entry")
                          (("1" (expand "row")
                            (("1" (lift-if)
                              (("1"
                                (ground)
                                (("1"
                                  (expand "rows")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "access")
                                      (("1"
                                        (lift-if)
                                        (("1" (grind) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "rows")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (typepred "r*row(D)(i)")
                          (("2" (replace -2)
                            (("2" (rewrite "length_row"nil nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("3" (typepred "j!1")
                      (("3" (lemma "columns_mult")
                        (("3" (inst?)
                          (("3" (assert)
                            (("3" (typepred "Esr(pn)(i,r)")
                              (("3"
                                (expand "rows")
                                (("3"
                                  (expand "length")
                                  (("3" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_full application-judgement "FullMatrix" matrices nil)
    (full_matrix_eq formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (entry const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (access const-decl "real" matrices nil)
    (replace_row def-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (j):
              row(PFM)(j) =
               IF j < rows(D) AND j = i THEN v ELSE row(D)(j) ENDIF)
            AND
            (FORALL (j, k):
               entry(PFM)(j, k) =
                IF j < rows(D) AND j = i THEN access(v)(k)
                ELSE entry(D)(j, k)
                ENDIF)}" matrix_props nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (entry_replace_row formula-decl nil matrix_props nil)
    (length_row formula-decl nil matrix_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (columns_Esr formula-decl nil matrix_det nil)
    (sigma_eq_one_arg formula-decl nil sigma "reals/")
    (access_scal formula-decl nil matrices nil)
    (access_col formula-decl nil matrix_props nil)
    (entry_Esr formula-decl nil matrix_det nil)
    (subrange type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_high type-eq-decl nil sigma "reals/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_low type-eq-decl nil sigma "reals/")
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (length_col formula-decl nil matrices nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (dot_eq_sigma formula-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (entry_mult formula-decl nil matrices nil)
    (columns_mult formula-decl nil matrices nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (/= const-decl "boolean" notequal nil)
    (array2list_it def-decl
                   "{l: listn(n - i) | FORALL (j: subrange(i, n - 1)): a(j) = nth(l, j - i)}"
                   array2list "structures/")
    (array2list const-decl
                "{l: listn(n) | FORALL (i: below(n)): a(i) = nth(l, i)}"
                array2list "structures/")
    (form_matrix const-decl "{M: MatrixMN(m, n) |
         FORALL (i: below(m), j: below(n)): nth(row(M)(i), j) = F(i, j)}"
                 matrices nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (rows_mult formula-decl nil matrices nil)
    (rows_replace_row formula-decl nil matrix_props nil)
    (rows_Esr formula-decl nil matrix_det nil))
   shostak))
 (mult_Esr_Esr_inv 0
  (mult_Esr_Esr_inv-1 nil 3615053212
   ("" (skeep)
    (("" (rewrite "mult_Esr_left")
      (("" (rewrite "full_matrix_eq")
        (("" (split)
          (("1" (rewrite "rows_replace_row")
            (("1" (rewrite "rows_Esr")
              (("1" (rewrite "rows_Id"nil nil)) nil))
            nil)
           ("2" (rewrite "columns_replace_row")
            (("2" (rewrite "columns_Esr")
              (("2" (rewrite "columns_Id"nil nil)) nil))
            nil)
           ("3" (skosimp*)
            (("3" (rewrite "entry_replace_row")
              (("1" (rewrite "entry_Id")
                (("1" (rewrite "access_scal")
                  (("1" (lemma "entry_Esr")
                    (("1" (inst - "i" "j!1" "i" "pn" "1/r")
                      (("1" (assert)
                        (("1" (expand "entry" -1)
                          (("1" (replaces -1)
                            (("1" (rewrite "entry_Esr")
                              (("1"
                                (lift-if)
                                (("1"
                                  (lift-if)
                                  (("1"
                                    (lift-if)
                                    (("1" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (rewrite "columns_Esr")
                (("2" (typepred "r * row(Esr(pn)(i, 1 / r))(i)")
                  (("2" (replace -2)
                    (("2" (rewrite "length_row")
                      (("2" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (mult_Esr_left formula-decl nil matrix_det nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (rows_Esr formula-decl nil matrix_det nil)
    (rows_Id formula-decl nil matrices nil)
    (rows_replace_row formula-decl nil matrix_props nil)
    (columns_Esr formula-decl nil matrix_det nil)
    (columns_Id formula-decl nil matrices nil)
    (columns_replace_row formula-decl nil matrix_props nil)
    (entry_replace_row formula-decl nil matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (access_scal formula-decl nil matrices nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (r skolem-const-decl "real" matrix_det nil)
    (entry_Esr formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_Id formula-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (length_row formula-decl nil matrix_props nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "real" matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (replace_row def-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (j):
              row(PFM)(j) =
               IF j < rows(D) AND j = i THEN v ELSE row(D)(j) ENDIF)
            AND
            (FORALL (j, k):
               entry(PFM)(j, k) =
                IF j < rows(D) AND j = i THEN access(v)(k)
                ELSE entry(D)(j, k)
                ENDIF)}" matrix_props nil)
    (access const-decl "real" matrices nil)
    (entry const-decl "real" matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (full_matrix_eq formula-decl nil matrices nil))
   shostak))
 (Ers_TCC1 0
  (Ers_TCC1-1 nil 3615034417
   ("" (skeep)
    ((""
      (name "FM" "form_matrix(LAMBDA (k, p: nat):
                                         IF k = i AND p = j THEN 1
                                         ELSIF k = j AND p = i THEN 1
                                         ELSIF k /= i AND k /= j AND k = p THEN 1
                                         ELSE 0
                                         ENDIF,
                                       pn, pn)")
      (("" (replace -1)
        (("" (split)
          (("1" (rewrite "full_matrix_eq")
            (("1" (split)
              (("1" (expand "FM" 1)
                (("1" (rewrite "rows_form_matrix")
                  (("1" (assertnil nil)) nil))
                nil)
               ("2" (expand "FM" 1)
                (("2" (lemma "columns_form_matrix")
                  (("2" (inst?) (("2" (assertnil nil)) nil)) nil))
                nil)
               ("3" (skosimp*)
                (("3" (expand "FM" 1)
                  (("3" (rewrite "entry_form_matrix")
                    (("3" (rewrite "entry_swap")
                      (("3" (expand "swap")
                        (("3" (lift-if)
                          (("3" (lift-if)
                            (("3" (lift-if)
                              (("3"
                                (lift-if)
                                (("3"
                                  (lift-if)
                                  (("3"
                                    (lift-if)
                                    (("3"
                                      (assert)
                                      (("3"
                                        (expand "Id" +)
                                        (("3"
                                          (rewrite -1)
                                          (("3"
                                            (rewrite
                                             "entry_form_matrix")
                                            (("3"
                                              (rewrite
                                               "entry_form_matrix")
                                              (("3"
                                                (rewrite
                                                 "entry_form_matrix")
                                                (("3"
                                                  (assert)
                                                  (("3"
                                                    (rewrite
                                                     "rows_form_matrix")
                                                    (("3"
                                                      (lemma
                                                       "columns_form_matrix")
                                                      (("3"
                                                        (inst?)
                                                        (("3"
                                                          (assert)
                                                          (("3"
                                                            (replaces
                                                             -1)
                                                            (("3"
                                                              (lift-if)
                                                              (("3"
                                                                (lift-if)
                                                                (("3"
                                                                  (lift-if)
                                                                  (("3"
                                                                    (lift-if)
                                                                    (("3"
                                                                      (lift-if)
                                                                      (("3"
                                                                        (lift-if)
                                                                        (("3"
                                                                          (assert)
                                                                          (("3"
                                                                            (ground)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "FM")
            (("2" (rewrite "rows_form_matrix"nil nil)) nil)
           ("3" (assert)
            (("3" (expand "FM")
              (("3" (rewrite "rows_form_matrix")
                (("3" (lemma "columns_form_matrix")
                  (("3" (inst?) (("3" (assertnil nil)) nil)) nil))
                nil))
              nil))
            nil)
           ("4" (expand "FM" 1)
            (("4" (rewrite "rows_form_matrix") (("4" (assertnil nil))
              nil))
            nil)
           ("5" (expand "FM" 1)
            (("5" (lemma "columns_form_matrix")
              (("5" (inst?) (("5" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (/= const-decl "boolean" notequal nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (form_matrix const-decl "{M: MatrixMN(m, n) |
         FORALL (i: below(m), j: below(n)): nth(row(M)(i), j) = F(i, j)}"
                 matrices nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (rows_form_matrix formula-decl nil matrices nil)
    (FM skolem-const-decl "{M: MatrixMN(pn, pn) |
         FORALL (i_1: below(pn), j_1: below(pn)):
           nth(row(M)(i_1), j_1) =
            IF i_1 = i AND j_1 = j THEN 1
            ELSIF i_1 = j AND j_1 = i THEN 1
            ELSIF i_1 /= i AND i_1 /= j AND i_1 = j_1 THEN 1
            ELSE 0
            ENDIF}" matrix_det nil)
    (columns_form_matrix formula-decl nil matrices nil)
    (entry_swap formula-decl nil matrix_props nil)
    (swap const-decl "real" matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (entry_form_matrix formula-decl nil matrices nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (swap const-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (k, p):
              i < rows(D) AND j < rows(D) IMPLIES
               entry(PFM)(k, p) =
                (IF k = i THEN entry(D)(j, p)
                 ELSIF k = j THEN entry(D)(i, p)
                 ELSE entry(D)(k, p)
                 ENDIF))}" matrix_props nil)
    (entry const-decl "real" matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (full_matrix_eq formula-decl nil matrices nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (entry_Ers 0
  (entry_Ers-1 nil 3615034417
   ("" (skeep)
    (("" (expand "Ers")
      (("" (rewrite "entry_form_matrix")
        (("" (lift-if)
          (("" (lift-if)
            (("" (lift-if)
              (("" (lift-if)
                (("" (lift-if)
                  (("" (assert) (("" (ground) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (real_ge_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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (entry_form_matrix formula-decl nil matrices nil))
   shostak))
 (rows_Ers 0
  (rows_Ers-1 nil 3615034488
   ("" (skeep)
    (("" (expand "Ers") (("" (rewrite "rows_form_matrix"nil nil))
      nil))
    nil)
   ((Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (rows_form_matrix formula-decl nil matrices nil))
   shostak))
 (columns_Ers 0
  (columns_Ers-1 nil 3615034519
   ("" (skeep)
    (("" (lemma "columns_form_matrix")
      (("" (expand "Ers") (("" (inst?) (("" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((columns_form_matrix formula-decl nil matrices 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil))
   shostak))
 (mult_Ers_left 0
  (mult_Ers_left-1 nil 3615034641
   ("" (skeep)
    (("" (rewrite "full_matrix_eq")
      (("" (split)
        (("1" (assert)
          (("1" (rewrite "rows_mult")
            (("1" (rewrite "rows_Ers") (("1" (assertnil nil)) nil))
            nil))
          nil)
         ("2" (lemma "columns_mult")
          (("2" (inst?) (("2" (assert) (("2" (grind) nil nil)) nil))
            nil))
          nil)
         ("3" (skosimp*)
          (("3" (rewrite "entry_mult")
            (("3" (lift-if)
              (("3" (ground)
                (("1" (rewrite "entry_swap")
                  (("1" (expand "swap")
                    (("1" (lift-if)
                      (("1" (ground)
                        (("1" (expand "*")
                          (("1" (rewrite "dot_eq_sigma")
                            (("1" (rewrite "length_row")
                              (("1"
                                (rewrite "length_col")
                                (("1"
                                  (rewrite "columns_Ers")
                                  (("1"
                                    (replace -4)
                                    (("1"
                                      (expand "min")
                                      (("1"
                                        (lemma "sigma_eq_one_arg")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (inst - "j")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (split -)
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (rewrite
                                                     "access_col")
                                                    (("1"
                                                      (expand
                                                       "entry"
                                                       +)
                                                      (("1"
                                                        (replace -2)
                                                        (("1"
                                                          (lemma
                                                           "entry_Ers")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "i"
                                                             "j"
                                                             "i"
                                                             "j"
                                                             "pn")
                                                            (("1"
                                                              (expand
                                                               "entry"
                                                               -1)
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (ground)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (lemma
                                                       "entry_Ers")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "i"
                                                         "j"
                                                         "i!1"
                                                         "i!2"
                                                         "pn")
                                                        (("2"
                                                          (expand
                                                           "entry"
                                                           -1)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (replace
                                                               -1)
                                                              (("2"
                                                                (lift-if)
                                                                (("2"
                                                                  (ground)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (hide 2)
                                                  (("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (lemma
                                                       "entry_Ers")
                                                      (("3"
                                                        (inst
                                                         -
                                                         "i"
                                                         "j"
                                                         "i!1"
                                                         "i!2"
                                                         "pn")
                                                        (("3"
                                                          (expand
                                                           "entry"
                                                           -1)
                                                          (("3"
                                                            (replace
                                                             -1)
                                                            (("3"
                                                              (lift-if)
                                                              (("3"
                                                                (ground)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "*")
                          (("2" (rewrite "dot_eq_sigma")
                            (("2" (rewrite "length_row")
                              (("2"
                                (rewrite "length_col")
                                (("2"
                                  (rewrite "columns_Ers")
                                  (("2"
                                    (replace -4)
                                    (("2"
                                      (expand "min")
                                      (("2"
                                        (lemma "sigma_eq_one_arg")
                                        (("2"
                                          (inst?)
                                          (("2"
                                            (inst - "i")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (split -)
                                                (("1"
                                                  (replaces -1)
                                                  (("1"
                                                    (lemma "entry_Ers")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "i"
                                                       "j"
                                                       "i!1"
                                                       "i"
                                                       "pn")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "entry"
                                                           -1)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (expand
                                                                 "entry"
                                                                 1)
                                                                (("1"
                                                                  (rewrite
                                                                   "access_col")
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (lemma
                                                       "entry_Ers")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "i"
                                                         "j"
                                                         "i!1"
                                                         "i!2"
                                                         "pn")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (expand
                                                             "entry"
                                                             -1)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (hide 2)
                                                  (("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (lemma
                                                       "entry_Ers")
                                                      (("3"
                                                        (inst
                                                         -
                                                         "i"
                                                         "j"
                                                         "i!1"
                                                         "i!2"
                                                         "pn")
                                                        (("3"
                                                          (assert)
                                                          (("3"
                                                            (expand
                                                             "entry"
                                                             -1)
                                                            (("3"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("3" (expand "*")
                          (("3" (rewrite "dot_eq_sigma")
                            (("3" (rewrite "length_row")
                              (("3"
                                (rewrite "length_col")
                                (("3"
                                  (rewrite "columns_Ers")
                                  (("3"
                                    (expand "min")
                                    (("3"
                                      (assert)
                                      (("3"
                                        (lemma "sigma_eq_one_arg")
                                        (("3"
                                          (inst?)
                                          (("3"
                                            (inst - "i!1")
                                            (("3"
                                              (assert)
                                              (("3"
                                                (split -)
                                                (("1"
                                                  (replaces -1)
                                                  (("1"
                                                    (lemma "entry_Ers")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "i"
                                                       "j"
                                                       "i!1"
                                                       "i!1"
                                                       "pn")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "entry"
                                                           -1)
                                                          (("1"
                                                            (replaces
                                                             -1)
                                                            (("1"
                                                              (rewrite
                                                               "access_col")
                                                              (("1"
                                                                (expand
                                                                 "entry")
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide 3)
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (lemma
                                                       "entry_Ers")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "i"
                                                         "j"
                                                         "i!1"
                                                         "i!2"
                                                         "pn")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (expand
                                                             "entry"
                                                             -1)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (hide 3)
                                                  (("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (lemma
                                                       "entry_Ers")
                                                      (("3"
                                                        (inst
                                                         -
                                                         "i"
                                                         "j"
                                                         "i!1"
                                                         "i!2"
                                                         "pn")
                                                        (("3"
                                                          (assert)
                                                          (("3"
                                                            (expand
                                                             "entry"
                                                             -1)
                                                            (("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)
                 ("2" (typepred "i!1")
                  (("2" (rewrite "rows_mult"nil nil)) nil)
                 ("3" (typepred "j!1")
                  (("3" (lemma "columns_mult")
                    (("3" (inst?)
                      (("3" (assert)
                        (("3" (typepred "Ers(pn)(i,j)")
                          (("3" (expand "rows")
                            (("3" (expand "length")
                              (("3" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_full application-judgement "FullMatrix" matrices nil)
    (full_matrix_eq formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (entry const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (swap const-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (k, p):
              i < rows(D) AND j < rows(D) IMPLIES
               entry(PFM)(k, p) =
                (IF k = i THEN entry(D)(j, p)
                 ELSIF k = j THEN entry(D)(i, p)
                 ELSE entry(D)(k, p)
                 ENDIF))}" matrix_props nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (entry_swap formula-decl nil matrix_props nil)
    (length_row formula-decl nil matrix_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (columns_Ers formula-decl nil matrix_det nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (T_low type-eq-decl nil sigma "reals/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_high type-eq-decl nil sigma "reals/")
    (access const-decl "real" matrices nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (subrange type-eq-decl nil integers nil)
    (entry_Ers formula-decl nil matrix_det nil)
    (access_col formula-decl nil matrix_props nil)
    (sigma_eq_one_arg formula-decl nil sigma "reals/")
    (length_col formula-decl nil matrices nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (dot_eq_sigma formula-decl nil matrices nil)
    (swap const-decl "real" matrix_props nil)
    (entry_mult formula-decl nil matrices nil)
    (columns_mult formula-decl nil matrices nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (form_matrix const-decl "{M: MatrixMN(m, n) |
         FORALL (i: below(m), j: below(n)): nth(row(M)(i), j) = F(i, j)}"
                 matrices 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/")
    (/= const-decl "boolean" notequal nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rows_Ers formula-decl nil matrix_det nil)
    (rows_mult formula-decl nil matrices nil))
   shostak))
 (transpose_Ers 0
  (transpose_Ers-1 nil 3615817501
   ("" (skeep)
    (("" (rewrite "full_matrix_eq")
      (("" (split)
        (("1" (rewrite "rows_transpose") (("1" (assertnil nil)) nil)
         ("2" (rewrite "columns_transpose") (("2" (assertnil nil))
          nil)
         ("3" (skosimp*)
          (("3" (rewrite "entry_transpose")
            (("3" (rewrite "entry_Ers")
              (("3" (rewrite "entry_Ers")
                (("3" (lift-if)
                  (("3" (lift-if)
                    (("3" (lift-if)
                      (("3" (lift-if)
                        (("3" (assert)
                          (("3" (lift-if)
                            (("3" (assert) (("3" (ground) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((full_matrix_eq formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (transpose const-decl "PosFullMatrix" matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (entry const-decl "real" matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (swap const-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (k, p):
              i < rows(D) AND j < rows(D) IMPLIES
               entry(PFM)(k, p) =
                (IF k = i THEN entry(D)(j, p)
                 ELSIF k = j THEN entry(D)(i, p)
                 ELSE entry(D)(k, p)
                 ENDIF))}" matrix_props nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (entry_Ers formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_transpose formula-decl nil matrices nil)
    (columns_transpose formula-decl nil matrices nil)
    (rows_transpose formula-decl nil matrices nil))
   nil))
 (det_Ers 0
  (det_Ers-1 nil 3615049919
   ("" (skeep)
    (("" (lift-if)
      (("" (ground)
        (("1" (replaces -1)
          (("1" (assert)
            (("1" (typepred "Ers(pn)(j,j)")
              (("1" (replaces -7)
                (("1" (rewrite "swap_id")
                  (("1" (rewrite "det_Id"nil nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (typepred "Ers(pn)(i,j)")
          (("2" (replaces -7)
            (("2" (rewrite "det_swap")
              (("2" (rewrite "det_Id"nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((det_swap formula-decl nil matrix_props nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (swap const-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (k, p):
              i < rows(D) AND j < rows(D) IMPLIES
               entry(PFM)(k, p) =
                (IF k = i THEN entry(D)(j, p)
                 ELSIF k = j THEN entry(D)(i, p)
                 ELSE entry(D)(k, p)
                 ENDIF))}" matrix_props nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (entry const-decl "real" matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (swap_id formula-decl nil matrix_props nil)
    (det_Id formula-decl nil matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   shostak))
 (mult_Ers_Ers_inv 0
  (mult_Ers_Ers_inv-1 nil 3615053454
   ("" (skeep)
    (("" (rewrite "mult_Ers_left")
      (("" (rewrite "full_matrix_eq")
        (("" (split)
          (("1" (rewrite "rows_swap")
            (("1" (rewrite "rows_Ers")
              (("1" (rewrite "rows_Id"nil nil)) nil))
            nil)
           ("2" (rewrite "columns_swap")
            (("2" (rewrite "columns_Ers")
              (("2" (rewrite "columns_Id"nil nil)) nil))
            nil)
           ("3" (skosimp*)
            (("3" (rewrite "entry_swap")
              (("3" (rewrite "entry_Id")
                (("3" (expand "swap")
                  (("3" (rewrite "entry_Ers")
                    (("3" (rewrite "entry_Ers")
                      (("3" (rewrite "entry_Ers")
                        (("3" (lift-if)
                          (("3" (lift-if)
                            (("3" (lift-if) (("3" (assertnil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_Ers_left formula-decl nil matrix_det nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (entry const-decl "real" matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (swap const-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (k, p):
              i < rows(D) AND j < rows(D) IMPLIES
               entry(PFM)(k, p) =
                (IF k = i THEN entry(D)(j, p)
                 ELSIF k = j THEN entry(D)(i, p)
                 ELSE entry(D)(k, p)
                 ENDIF))}" matrix_props nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (rows_Ers formula-decl nil matrix_det nil)
    (rows_Id formula-decl nil matrices nil)
    (rows_swap formula-decl nil matrix_props nil)
    (columns_Ers formula-decl nil matrix_det nil)
    (columns_Id formula-decl nil matrices nil)
    (columns_swap formula-decl nil matrix_props nil)
    (entry_swap formula-decl nil matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (swap const-decl "real" matrix_props nil)
    (entry_Ers formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_Id formula-decl nil matrices nil)
    (full_matrix_eq formula-decl nil matrices nil))
   shostak))
 (Easr_TCC1 0
  (Easr_TCC1-1 nil 3615041385
   ("" (skeep)
    ((""
      (name "FM" "form_matrix(LAMBDA (k, p: nat):
                                     IF k = i
                                       THEN (IF j = i AND p = i
                                             THEN 1 + r
                                             ELSIF p = i
                                             THEN 1
                                             ELSIF p = j
                                             THEN r
                                             ELSE 0
                                             ENDIF)
                                     ELSIF k = p THEN 1
                                     ELSE 0
                                     ENDIF,
                                   pn, pn)")
      (("" (replace -1)
        (("" (split +)
          (("1" (expand "FM" 1)
            (("1" (rewrite "rows_form_matrix"nil nil)) nil)
           ("2" (assert)
            (("2" (expand "FM" 1)
              (("2" (rewrite "rows_form_matrix")
                (("2" (lemma "columns_form_matrix")
                  (("2" (inst?) (("2" (assertnil nil)) nil)) nil))
                nil))
              nil))
            nil)
           ("3" (expand "FM" 1)
            (("3" (rewrite "rows_form_matrix") (("3" (assertnil nil))
              nil))
            nil)
           ("4" (lemma "columns_form_matrix")
            (("4" (expand "FM" 1)
              (("4" (inst?) (("4" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (form_matrix const-decl "{M: MatrixMN(m, n) |
         FORALL (i: below(m), j: below(n)): nth(row(M)(i), j) = F(i, j)}"
                 matrices nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (rows_form_matrix formula-decl nil matrices nil)
    (FM skolem-const-decl "{M: MatrixMN(pn, pn) |
         FORALL (i_1: below(pn), j_1: below(pn)):
           nth(row(M)(i_1), j_1) =
            IF i_1 = i
              THEN (IF j = i AND j_1 = i THEN 1 + r
                    ELSIF j_1 = i THEN 1
                    ELSIF j_1 = j THEN r
                    ELSE 0
                    ENDIF)
            ELSIF i_1 = j_1 THEN 1
            ELSE 0
            ENDIF}" matrix_det nil)
    (columns_form_matrix formula-decl nil matrices nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (entry_Easr 0
  (entry_Easr-1 nil 3615041737
   ("" (skeep)
    (("" (expand "Easr")
      (("" (rewrite "entry_form_matrix")
        (("" (lift-if)
          (("" (assert)
            (("" (lift-if)
              (("" (assert)
                (("" (lift-if)
                  (("" (assert) (("" (ground) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (real_ge_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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (entry_form_matrix formula-decl nil matrices nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (rows_Easr 0
  (rows_Easr-1 nil 3615046841
   ("" (skeep)
    (("" (expand "Easr") (("" (rewrite "rows_form_matrix"nil nil))
      nil))
    nil)
   ((Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (rows_form_matrix formula-decl nil matrices nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (columns_Easr 0
  (columns_Easr-1 nil 3615043220
   ("" (skeep)
    (("" (expand "Easr")
      (("" (lemma "columns_form_matrix")
        (("" (inst?) (("" (assertnil nil)) nil)) nil))
      nil))
    nil)
   ((Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (real_plus_real_is_real application-judgement "real" reals 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (columns_form_matrix formula-decl nil matrices nil))
   shostak))
 (mult_Easr_left_TCC1 0
  (mult_Easr_left_TCC1-1 nil 3615043439
   ("" (skeep)
    (("" (typepred "row(D)(i)+r*row(D)(j)")
      (("" (replaces -2)
        (("" (expand "max")
          (("" (lift-if)
            (("" (ground)
              (("1" (typepred "r*row(D)(j)")
                (("1" (rewrite "length_row") (("1" (assertnil nil))
                  nil))
                nil)
               ("2" (rewrite "length_row"nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((* const-decl "VectorN(length(v2))" matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (row const-decl "Vector" matrices nil)
    (Matrix type-eq-decl nil matrices nil)
    (+ const-decl "VectorN(max(length(v1), length(v2)))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (length def-decl "nat" list_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real nonempty-type-from-decl nil reals nil)
    (Vector type-eq-decl nil matrices 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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (list type-decl nil list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (length_row formula-decl nil matrix_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (mult_Easr_left 0
  (mult_Easr_left-1 nil 3615043440
   ("" (skeep)
    (("" (rewrite "full_matrix_eq")
      (("" (split)
        (("1" (rewrite "rows_mult")
          (("1" (rewrite "rows_Easr")
            (("1" (rewrite "rows_replace_row") (("1" (assertnil nil))
              nil))
            nil))
          nil)
         ("2" (lemma "columns_mult")
          (("2" (inst?)
            (("2" (assert)
              (("2" (lemma "rows_Easr")
                (("2" (inst?)
                  (("2" (assert)
                    (("2" (expand "rows")
                      (("2" (expand "length") (("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (skosimp*)
          (("3" (rewrite "entry_mult")
            (("3" (rewrite "rows_Easr")
              (("3" (rewrite "entry_replace_row")
                (("1" (lift-if)
                  (("1" (lift-if)
                    (("1" (lift-if)
                      (("1" (assert)
                        (("1" (ground)
                          (("1" (expand "*" + 1)
                            (("1" (rewrite "dot_eq_sigma")
                              (("1"
                                (rewrite "length_row")
                                (("1"
                                  (rewrite "columns_Easr")
                                  (("1"
                                    (rewrite "length_col")
                                    (("1"
                                      (expand "min")
                                      (("1"
                                        (case "i = j")
                                        (("1"
                                          (lemma "sigma_eq_one_arg2")
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (inst - "i")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (split -)
                                                  (("1"
                                                    (replaces -1)
                                                    (("1"
                                                      (lemma
                                                       "entry_Easr")
                                                      (("1"
                                                        (inst?)
                                                        (("1"
                                                          (inst
                                                           -
                                                           "i!1"
                                                           "i")
                                                          (("1"
                                                            (replace
                                                             -3)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "entry"
                                                                 -1)
                                                                (("1"
                                                                  (replaces
                                                                   -1)
                                                                  (("1"
                                                                    (rewrite
                                                                     "access_sum")
                                                                    (("1"
                                                                      (rewrite
                                                                       "access_scal")
                                                                      (("1"
                                                                        (rewrite
                                                                         "access_col")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (lemma
                                                         "entry_Easr")
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "i!1"
                                                             "i!2")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (expand
                                                                 "entry"
                                                                 -1)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (lemma "sigma_eq_two_args")
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (inst - "i" "j")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (replaces -1)
                                                    (("1"
                                                      (lemma
                                                       "entry_Easr")
                                                      (("1"
                                                        (replace -2)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (inst-cp
                                                             -
                                                             "i"
                                                             "i")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "i"
                                                                 "j")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "entry")
                                                                    (("1"
                                                                      (replaces
                                                                       -1)
                                                                      (("1"
                                                                        (replaces
                                                                         -1)
                                                                        (("1"
                                                                          (rewrite
                                                                           "access_sum")
                                                                          (("1"
                                                                            (rewrite
                                                                             "access_scal")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (rewrite
                                                                                 "access_col")
                                                                                (("1"
                                                                                  (rewrite
                                                                                   "access_col")
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 3)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (lemma
                                                           "entry_Easr")
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "i!1"
                                                               "i!2")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "entry")
                                                                  (("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" (expand "*")
                            (("2" (rewrite "dot_eq_sigma")
                              (("2"
                                (rewrite "length_row")
                                (("2"
                                  (rewrite "columns_Easr")
                                  (("2"
                                    (rewrite "length_col")
                                    (("2"
                                      (expand "min")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (lemma "sigma_eq_one_arg2")
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (inst - "i!1")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split -)
                                                    (("1"
                                                      (replaces -1)
                                                      (("1"
                                                        (lemma
                                                         "entry_Easr")
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "i!1"
                                                             "i!1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "entry")
                                                                (("1"
                                                                  (replaces
                                                                   -1)
                                                                  (("1"
                                                                    (rewrite
                                                                     "access_col")
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 3)
                                                      (("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (lemma
                                                           "entry_Easr")
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "i!1"
                                                               "i!2")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "entry")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (rewrite "entry_eq_0"nil nil)
                           ("4" (rewrite "entry_eq_0"nil nil)
                           ("5" (expand "access")
                            (("5" (lift-if)
                              (("5"
                                (ground)
                                (("5"
                                  (typepred "row(D)(i)+r*row(D)(j)")
                                  (("5"
                                    (replaces -2)
                                    (("5"
                                      (expand "max")
                                      (("5"
                                        (assert)
                                        (("5"
                                          (lift-if)
                                          (("5"
                                            (ground)
                                            (("1"
                                              (typepred "r*row(D)(j)")
                                              (("1"
                                                (rewrite "length_row")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (rewrite "length_row")
                                              nil
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("6" (rewrite "entry_eq_0"nil nil)
                           ("7" (rewrite "entry_eq_0"nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide 2)
                  (("2" (typepred "row(D)(i)+r*row(D)(j)")
                    (("2" (replace -2)
                      (("2" (expand "max")
                        (("2" (lift-if)
                          (("2" (ground)
                            (("1" (typepred "r*row(D)(j)")
                              (("1"
                                (rewrite "length_row")
                                (("1" (assertnil nil))
                                nil))
                              nil)
                             ("2" (rewrite "length_row"nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_full application-judgement "FullMatrix" matrices nil)
    (full_matrix_eq formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (entry const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (access const-decl "real" matrices nil)
    (replace_row def-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (j):
              row(PFM)(j) =
               IF j < rows(D) AND j = i THEN v ELSE row(D)(j) ENDIF)
            AND
            (FORALL (j, k):
               entry(PFM)(j, k) =
                IF j < rows(D) AND j = i THEN access(v)(k)
                ELSE entry(D)(j, k)
                ENDIF)}" matrix_props nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (+ const-decl "VectorN(max(length(v1), length(v2)))" matrices nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (dot_eq_sigma formula-decl nil matrices nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (columns_Easr formula-decl nil matrix_det nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (sigma_eq_two_args formula-decl nil sigma "reals/")
    (sigma_eq_one_arg2 formula-decl nil sigma "reals/")
    (entry_Easr formula-decl nil matrix_det nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (access_scal formula-decl nil matrices nil)
    (access_col formula-decl nil matrix_props nil)
    (access_sum formula-decl nil matrices nil)
    (subrange type-eq-decl nil integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_high type-eq-decl nil sigma "reals/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_low type-eq-decl nil sigma "reals/")
    (length_col formula-decl nil matrices nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (length_row formula-decl nil matrix_props nil)
    (entry_eq_0 formula-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (entry_replace_row formula-decl nil matrix_props nil)
    (entry_mult formula-decl nil matrices nil)
    (columns_mult formula-decl nil matrices nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rows_mult formula-decl nil matrices nil)
    (rows_replace_row formula-decl nil matrix_props nil)
    (rows_Easr formula-decl nil matrix_det nil))
   shostak))
 (transpose_Easr 0
  (transpose_Easr-1 nil 3615817605
   ("" (skeep)
    (("" (rewrite "full_matrix_eq")
      (("" (split)
        (("1" (rewrite "rows_transpose") (("1" (assertnil nil)) nil)
         ("2" (rewrite "columns_transpose") (("2" (assertnil nil))
          nil)
         ("3" (skosimp*)
          (("3" (rewrite "entry_transpose")
            (("3" (rewrite "entry_Easr")
              (("3" (rewrite "entry_Easr")
                (("3" (lift-if)
                  (("3" (assert)
                    (("3" (lift-if)
                      (("3" (assert)
                        (("3" (lift-if)
                          (("3" (assert)
                            (("3" (lift-if)
                              (("3"
                                (assert)
                                (("3" (ground) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((full_matrix_eq formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (transpose const-decl "PosFullMatrix" matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (entry_Easr formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_transpose formula-decl nil matrices nil)
    (columns_transpose formula-decl nil matrices nil)
    (rows_transpose formula-decl nil matrices nil))
   shostak))
 (det_Easr 0
  (det_Easr-1 nil 3615050470
   ("" (skeep)
    (("" (lift-if)
      (("" (ground)
        (("1" (case "Easr(pn)(i,j,r)=Esr(pn)(i,1+r)")
          (("1" (replaces -1) (("1" (rewrite "det_Esr"nil nil)) nil)
           ("2" (hide 2)
            (("2" (rewrite "full_matrix_eq")
              (("2" (split)
                (("1" (rewrite "rows_Easr")
                  (("1" (rewrite "rows_Esr"nil nil)) nil)
                 ("2" (rewrite "columns_Easr")
                  (("2" (rewrite "columns_Esr"nil nil)) nil)
                 ("3" (skosimp*)
                  (("3" (rewrite "entry_Easr")
                    (("3" (rewrite "entry_Esr")
                      (("3" (lift-if)
                        (("3" (lift-if)
                          (("3" (lift-if)
                            (("3" (lift-if)
                              (("3"
                                (lift-if)
                                (("3" (ground) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (lemma "det_replace_row_sum_scal")
          (("2" (inst - "Id(pn)" "i" "j" "r")
            (("2" (assert)
              (("2" (rewrite "rows_Id")
                (("2" (assert)
                  (("2" (rewrite "det_Id")
                    (("2"
                      (case "Easr(pn)(i,j,r)=replace_row(i, row(Id(pn))(i) + r * row(Id(pn))(j))(Id(pn))")
                      (("1" (assertnil nil)
                       ("2" (hide (-1 3))
                        (("2" (rewrite "full_matrix_eq")
                          (("2" (split)
                            (("1" (rewrite "rows_Easr")
                              (("1"
                                (rewrite "rows_replace_row")
                                (("1" (rewrite "rows_Id"nil nil))
                                nil))
                              nil)
                             ("2" (rewrite "columns_Easr")
                              (("2"
                                (rewrite "columns_replace_row")
                                (("2" (rewrite "columns_Id"nil nil))
                                nil))
                              nil)
                             ("3" (skosimp*)
                              (("3"
                                (rewrite "entry_Easr")
                                (("3"
                                  (rewrite "entry_replace_row")
                                  (("1"
                                    (rewrite "access_sum")
                                    (("1"
                                      (rewrite "access_scal")
                                      (("1"
                                        (rewrite "entry_Id")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (lemma "entry_Id")
                                            (("1"
                                              (inst-cp
                                               -
                                               "i"
                                               "j!1"
                                               "pn")
                                              (("1"
                                                (inst - "j" "j!1" "pn")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "entry")
                                                    (("1"
                                                      (replaces -1)
                                                      (("1"
                                                        (replaces -1)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lift-if)
                                                            (("1"
                                                              (lift-if)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (lift-if)
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (lift-if)
                                                                          (("1"
                                                                            (lift-if)
                                                                            (("1"
                                                                              (lift-if)
                                                                              (("1"
                                                                                (lift-if)
                                                                                (("1"
                                                                                  (lift-if)
                                                                                  (("1"
                                                                                    (ground)
                                                                                    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"
                                    (hide 2)
                                    (("2"
                                      (rewrite "columns_Id")
                                      (("2"
                                        (typepred
                                         "row(Id(pn))(i) + r * row(Id(pn))(j)")
                                        (("2"
                                          (replaces -2)
                                          (("2"
                                            (rewrite "length_row")
                                            (("2"
                                              (typepred
                                               "r*row(Id(pn))(j)")
                                              (("2"
                                                (replaces -2)
                                                (("2"
                                                  (rewrite
                                                   "length_row")
                                                  (("2"
                                                    (expand "max")
                                                    (("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)
   ((det_replace_row_sum_scal formula-decl nil matrix_props nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (+ const-decl "VectorN(max(length(v1), length(v2)))" matrices nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (replace_row def-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (j):
              row(PFM)(j) =
               IF j < rows(D) AND j = i THEN v ELSE row(D)(j) ENDIF)
            AND
            (FORALL (j, k):
               entry(PFM)(j, k) =
                IF j < rows(D) AND j = i THEN access(v)(k)
                ELSE entry(D)(j, k)
                ENDIF)}" matrix_props nil)
    (access const-decl "real" matrices nil)
    (entry_replace_row formula-decl nil matrix_props nil)
    (access_scal formula-decl nil matrices nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (entry_Id formula-decl nil matrices nil)
    (access_sum formula-decl nil matrices nil)
    (length_row formula-decl nil matrix_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (columns_Id formula-decl nil matrices nil)
    (columns_replace_row formula-decl nil matrix_props nil)
    (rows_replace_row formula-decl nil matrix_props nil)
    (det_Id formula-decl nil matrix_props nil)
    (rows_Id formula-decl nil matrices nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (entry const-decl "real" matrices nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (det_Esr formula-decl nil matrix_det nil)
    (full_matrix_eq formula-decl nil matrices nil)
    (entry_Esr formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_Easr formula-decl nil matrix_det nil)
    (columns_Easr formula-decl nil matrix_det nil)
    (columns_Esr formula-decl nil matrix_det nil)
    (rows_Easr formula-decl nil matrix_det nil)
    (rows_Esr formula-decl nil matrix_det nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (mult_Easr_Easr_inv 0
  (mult_Easr_Easr_inv-1 nil 3615053746
   ("" (skeep)
    (("" (rewrite "mult_Easr_left")
      (("" (rewrite "full_matrix_eq")
        (("" (split)
          (("1" (rewrite "rows_replace_row")
            (("1" (rewrite "rows_Easr")
              (("1" (rewrite "rows_Id"nil nil)) nil))
            nil)
           ("2" (rewrite "columns_replace_row")
            (("2" (rewrite "columns_Easr")
              (("2" (rewrite "columns_Id"nil nil)) nil))
            nil)
           ("3" (skosimp*)
            (("3" (rewrite "entry_replace_row")
              (("1" (rewrite "entry_Id")
                (("1" (rewrite "entry_Easr")
                  (("1" (lemma "entry_Easr")
                    (("1" (rewrite "access_sum")
                      (("1" (rewrite "access_scal")
                        (("1" (inst-cp - "i" "j" "i" "j!1" "pn" "-r")
                          (("1" (inst-cp - "i" "j" "j" "j!1" "pn" "-r")
                            (("1" (hide -1)
                              (("1"
                                (expand "entry" -)
                                (("1"
                                  (assert)
                                  (("1"
                                    (replaces -1)
                                    (("1"
                                      (replaces -1)
                                      (("1"
                                        (lift-if)
                                        (("1"
                                          (lift-if)
                                          (("1"
                                            (lift-if)
                                            (("1" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (rewrite "columns_Easr")
                (("2" (invoke (typepred "%1") (! 1 2 1))
                  (("2" (replaces -2)
                    (("2" (rewrite "length_row")
                      (("2" (invoke (typepred "%1") (! 1 2 2 1))
                        (("2" (replace -2)
                          (("2" (rewrite "length_row" +)
                            (("2" (expand "max")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((minus_real_is_real application-judgement "real" reals nil)
    (mult_Easr_left formula-decl nil matrix_det nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (rows_Easr formula-decl nil matrix_det nil)
    (rows_Id formula-decl nil matrices nil)
    (rows_replace_row formula-decl nil matrix_props nil)
    (columns_Easr formula-decl nil matrix_det nil)
    (columns_Id formula-decl nil matrices nil)
    (columns_replace_row formula-decl nil matrix_props nil)
    (entry_replace_row formula-decl nil matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (entry_Easr formula-decl nil matrix_det nil)
    (access_sum formula-decl nil matrices nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (access_scal formula-decl nil matrices nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (entry_Id formula-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (length_row formula-decl nil matrix_props nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "real" matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (* const-decl "VectorN(length(v2))" matrices nil)
    (+ const-decl "VectorN(max(length(v1), length(v2)))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (replace_row def-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (j):
              row(PFM)(j) =
               IF j < rows(D) AND j = i THEN v ELSE row(D)(j) ENDIF)
            AND
            (FORALL (j, k):
               entry(PFM)(j, k) =
                IF j < rows(D) AND j = i THEN access(v)(k)
                ELSE entry(D)(j, k)
                ENDIF)}" matrix_props nil)
    (access const-decl "real" matrices nil)
    (entry const-decl "real" matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (full_matrix_eq formula-decl nil matrices nil))
   shostak))
 (ZERO_TCC1 0
  (ZERO_TCC1-1 nil 3615110328
   ("" (skeep)
    (("" (name "FM" "form_matrix(LAMbDA (i,j): 0,pn,pn)")
      (("" (replaces -1)
        (("" (split +)
          (("1" (expand "FM")
            (("1" (rewrite "rows_form_matrix"nil nil)) nil)
           ("2" (assert)
            (("2" (expand "FM")
              (("2" (rewrite "rows_form_matrix")
                (("2" (lemma "columns_form_matrix")
                  (("2" (inst?) (("2" (assertnil nil)) nil)) nil))
                nil))
              nil))
            nil)
           ("3" (expand "FM")
            (("3" (rewrite "rows_form_matrix") (("3" (assertnil nil))
              nil))
            nil)
           ("4" (expand "FM")
            (("4" (lemma "columns_form_matrix")
              (("4" (inst?) (("4" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (form_matrix const-decl "{M: MatrixMN(m, n) |
         FORALL (i: below(m), j: below(n)): nth(row(M)(i), j) = F(i, j)}"
                 matrices nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (rows_form_matrix formula-decl nil matrices nil)
    (FM skolem-const-decl "{M: MatrixMN(pn, pn) |
         FORALL (i_1: below(pn), j_1: below(pn)): nth(row(M)(i_1), j_1) = 0}"
     matrix_det nil)
    (columns_form_matrix formula-decl nil matrices nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (prod_diag_TCC1 0
  (prod_diag_TCC1-1 nil 3615635548 ("" (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)
    (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)
    (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)
    (Matrix type-eq-decl nil matrices 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)
    (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)
    (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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rows const-decl "nat" matrices nil))
   nil))
 (prod_diag_TCC2 0
  (prod_diag_TCC2-1 nil 3615635548 ("" (termination-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (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)
    (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)
    (Matrix type-eq-decl nil matrices 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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rows const-decl "nat" matrices nil))
   nil))
 (prod_diag_TCC3 0
  (prod_diag_TCC3-1 nil 3615636043 ("" (termination-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (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)
    (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)
    (Matrix type-eq-decl nil matrices 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)
    (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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rows const-decl "nat" matrices nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (prod_diag_remove_0_0_TCC1 0
  (prod_diag_remove_0_0_TCC1-1 nil 3615638149
   ("" (skeep)
    (("" (rewrite "rows_remove") (("" (assertnil nil)) nil)) nil)
   ((rows_remove formula-decl nil matrix_props nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (prod_diag_remove_0_0 0
  (prod_diag_remove_0_0-1 nil 3615636723
   (""
    (case " FORALL (S: Square, k: nat):
        k + 1 < rows(S) AND rows(S)-k-2>=0 IMPLIES
         prod_diag(remove(S, 0, 0), rows(S)-k-2) = prod_diag(S, rows(S)-k-1)")
    (("1" (skeep)
      (("1" (inst - "S" "rows(S)-k-2")
        (("1" (assertnil nil) ("2" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "k")
        (("1" (skeep)
          (("1" (assert)
            (("1" (expand "prod_diag")
              (("1" (rewrite "rows_remove")
                (("1" (assert) (("1" (rewrite "entry_remove"nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (assert)
            (("2" (skeep)
              (("2" (assert)
                (("2" (expand "prod_diag" +)
                  (("2" (assert)
                    (("2" (lift-if)
                      (("2" (rewrite "rows_remove")
                        (("2" (assert)
                          (("2" (inst - "S")
                            (("2" (assert)
                              (("2"
                                (replaces -1)
                                (("2"
                                  (rewrite "entry_remove")
                                  nil
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (hide 2) (("3" (skosimp*) (("3" (assertnil nil)) nil))
          nil)
         ("4" (skosimp*)
          (("4" (rewrite "rows_remove") (("4" (assertnil nil)) nil))
          nil))
        nil))
      nil)
     ("3" (hide 2) (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil)
     ("4" (hide 2)
      (("4" (skeep)
        (("4" (rewrite "rows_remove") (("4" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (entry_remove formula-decl nil matrix_props nil)
    (rows_remove formula-decl nil matrix_props nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types 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)
    (k skolem-const-decl "nat" matrix_det nil)
    (S skolem-const-decl "Square" matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (remove_posfullmatrix application-judgement "FullMatrix"
     matrix_props nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (IMPLIES 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)
    (prod_diag def-decl "real" matrix_det nil)
    (entry const-decl "real" matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (remove const-decl "{N |
         (rows(M) > 1 AND columns(M) > 1 IMPLIES
           (rows(N) = rows(M) - 1 AND columns(N) = columns(M) - 1))
          AND
          (FORALL (m, n):
             LET newm = IF m >= i OR i >= rows(M) THEN m + 1 ELSE m ENDIF,
                 newn =
                   IF n >= j OR j >= columns(M) THEN n + 1 ELSE n ENDIF
               IN entry(N)(m, n) = entry(M)(newm, newn))}"
      matrix_props nil))
   shostak))
 (diagonal_upper_triangular 0
  (diagonal_upper_triangular-1 nil 3615903333
   ("" (skeep)
    (("" (expand "upper_triangular?")
      (("" (expand "diagonal?")
        (("" (skeep)
          (("" (inst - "i" "j") (("" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((upper_triangular? const-decl "bool" matrix_det 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (diagonal? const-decl "bool" matrix_det nil))
   shostak))
 (det_upper_triangular 0
  (det_upper_triangular-1 nil 3615635548
   (""
    (case "FORALL (S: Square,k:nat):rows(S)=k+1 AND
                      upper_triangular?(S) IMPLIES det(S) = prod_diag(S, 0)")
    (("1" (skeep)
      (("1" (inst - "S" "rows(S)-1") (("1" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "k")
        (("1" (assert)
          (("1" (skeep)
            (("1" (expand "det")
              (("1" (assert)
                (("1" (lift-if)
                  (("1" (ground)
                    (("1" (expand "rows")
                      (("1" (expand "length") (("1" (assertnil nil))
                        nil))
                      nil)
                     ("2" (expand "prod_diag") (("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (assert)
              (("2" (expand "det" + 1)
                (("2" (lift-if)
                  (("2" (ground)
                    (("1" (expand "rows")
                      (("1" (expand "length") (("1" (assertnil nil))
                        nil))
                      nil)
                     ("2" (lemma "sigma_eq_one_arg2")
                      (("2" (inst?)
                        (("2" (inst - "0")
                          (("2" (assert)
                            (("2" (split -)
                              (("1"
                                (replaces -1)
                                (("1"
                                  (inst - "remove(S,0,0)")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (split -1)
                                      (("1"
                                        (replaces -1)
                                        (("1"
                                          (expand "^")
                                          (("1"
                                            (expand "expt")
                                            (("1"
                                              (expand "prod_diag" + 2)
                                              (("1"
                                                (rewrite
                                                 "prod_diag_remove_0_0")
                                                nil
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (rewrite "rows_remove")
                                        (("2" (assertnil nil))
                                        nil)
                                       ("3"
                                        (hide 3)
                                        (("3"
                                          (expand "upper_triangular?")
                                          (("3"
                                            (skeep)
                                            (("3"
                                              (rewrite "rows_remove")
                                              (("3"
                                                (rewrite
                                                 "entry_remove")
                                                (("3"
                                                  (inst?)
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (rewrite "rows_remove")
                                    (("2"
                                      (rewrite "columns_remove")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (skeep)
                                    (("2"
                                      (lemma "det_first_column_zero")
                                      (("2"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (skosimp*)
                                            (("1"
                                              (rewrite "rows_remove")
                                              (("1"
                                                (rewrite
                                                 "entry_remove")
                                                (("1"
                                                  (expand
                                                   "upper_triangular?")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (rewrite "rows_remove")
                                          (("2"
                                            (rewrite "columns_remove")
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (sigma_eq_one_arg2 formula-decl nil sigma "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (remove_posfullmatrix application-judgement "FullMatrix"
     matrix_props nil)
    (S skolem-const-decl "Square" matrix_det nil)
    (prod_diag_remove_0_0 formula-decl nil matrix_det nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (expt def-decl "real" exponentiation nil)
    (rows_remove formula-decl nil matrix_props nil)
    (entry_remove formula-decl nil matrix_props nil)
    (columns_remove formula-decl nil matrix_props nil)
    (det_first_column_zero formula-decl nil matrix_props nil)
    (i skolem-const-decl "subrange(0, columns(S) - 1)" matrix_det nil)
    (subrange type-eq-decl nil integers nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (entry const-decl "real" matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (remove const-decl "{N |
         (rows(M) > 1 AND columns(M) > 1 IMPLIES
           (rows(N) = rows(M) - 1 AND columns(N) = columns(M) - 1))
          AND
          (FORALL (m, n):
             LET newm = IF m >= i OR i >= rows(M) THEN m + 1 ELSE m ENDIF,
                 newn =
                   IF n >= j OR j >= columns(M) THEN n + 1 ELSE n ENDIF
               IN entry(N)(m, n) = entry(M)(newm, newn))}"
      matrix_props nil)
    (/= const-decl "boolean" notequal nil)
    (^ const-decl "real" exponentiation nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (int_exp application-judgement "int" exponentiation nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (upper_triangular? const-decl "bool" matrix_det nil)
    (det def-decl "real" matrix_props nil)
    (prod_diag def-decl "real" matrix_det nil))
   shostak))
 (det_upper_triangular_zero 0
  (det_upper_triangular_zero-1 nil 3615637395
   ("" (skeep)
    (("" (lemma "det_upper_triangular")
      (("" (inst?)
        (("" (assert)
          (("" (replaces -1)
            ((""
              (case "FORALL (k:nat): rows(S)-1-k>=0 IMPLIES (prod_diag(S, rows(S)-1-k) = 0 IFF
        (EXISTS (i): i <=k AND entry(S)(rows(S)-1-i,rows(S)-1-i) = 0))")
              (("1" (inst - "rows(S)-1")
                (("1" (assert)
                  (("1" (replaces -1)
                    (("1" (ground)
                      (("1" (skeep)
                        (("1" (inst?)
                          (("1" (assertnil nil)
                           ("2" (assertnil nil))
                          nil))
                        nil)
                       ("2" (skeep)
                        (("2" (inst + "rows(S)-1-i")
                          (("1" (assertnil nil)
                           ("2" (assertnil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (induct "k")
                  (("1" (assert)
                    (("1" (expand "prod_diag")
                      (("1" (ground)
                        (("1" (inst + "0") (("1" (assertnil nil))
                          nil)
                         ("2" (skosimp*) (("2" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skeep)
                    (("2" (assert)
                      (("2" (expand "prod_diag" +)
                        (("2" (assert)
                          (("2" (ground)
                            (("1" (skosimp*)
                              (("1"
                                (inst + "i!1")
                                (("1" (assertnil nil))
                                nil))
                              nil)
                             ("2"
                              (lemma "nzreal_times_nzreal_is_nzreal")
                              (("2"
                                (inst?)
                                (("1" (assertnil nil)
                                 ("2"
                                  (flatten)
                                  (("2"
                                    (hide -2)
                                    (("2"
                                      (inst + "j+1")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("3" (skosimp*)
                              (("3"
                                (inst + "i!1")
                                (("3" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil)
               ("3" (skosimp*) (("3" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((det_upper_triangular formula-decl nil matrix_det nil)
    (entry const-decl "real" matrices nil)
    (prod_diag def-decl "real" matrix_det nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (S skolem-const-decl "Square" matrix_det nil)
    (i skolem-const-decl "nat" matrix_det 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)
    (i skolem-const-decl "nat" matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (nzreal_times_nzreal_is_nzreal judgement-tcc nil real_types nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (j skolem-const-decl "nat" matrix_det nil)
    (/= const-decl "boolean" notequal nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals 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)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (real nonempty-type-from-decl nil reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices 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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (upper_triangular_mult 0
  (upper_triangular_mult-1 nil 3615886750
   ("" (skeep)
    (("" (expand "upper_triangular?")
      (("" (skeep)
        (("" (rewrite "entry_mult")
          (("" (lift-if)
            (("" (ground)
              (("" (expand "*" 1)
                (("" (rewrite "dot_eq_sigma")
                  (("" (rewrite "length_row")
                    (("" (rewrite "length_col")
                      (("" (rewrite "sigma_restrict_eq_0")
                        (("" (hide 2)
                          (("" (skosimp*)
                            (("" (rewrite "access_row")
                              ((""
                                (rewrite "access_col")
                                ((""
                                  (rewrite "access_row")
                                  ((""
                                    (inst - "i" "i!1")
                                    ((""
                                      (inst - "i!1" "j")
                                      (("" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((upper_triangular? const-decl "bool" matrix_det nil)
    (entry_mult formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices 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)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (dot_eq_sigma formula-decl nil matrices nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (length_col formula-decl nil matrices nil)
    (subrange type-eq-decl nil integers nil)
    (access_row formula-decl nil matrices nil)
    (access_col formula-decl nil matrix_props nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (access const-decl "real" matrices nil)
    (T_high type-eq-decl nil sigma "reals/")
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_low type-eq-decl nil sigma "reals/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (length_row formula-decl nil matrix_props nil)
    (* const-decl "real" matrices nil))
   shostak))
 (lower_triangular_mult 0
  (lower_triangular_mult-1 nil 3615887148
   ("" (skeep)
    (("" (expand "lower_triangular?")
      (("" (skeep)
        (("" (rewrite "entry_mult")
          (("" (lift-if)
            (("" (ground)
              (("" (expand "*" 1)
                (("" (rewrite "dot_eq_sigma")
                  (("" (rewrite "length_row")
                    (("" (rewrite "length_col")
                      (("" (rewrite "sigma_restrict_eq_0")
                        (("" (hide 2)
                          (("" (skosimp*)
                            (("" (rewrite "access_row")
                              ((""
                                (rewrite "access_col")
                                ((""
                                  (rewrite "access_row")
                                  ((""
                                    (inst - "i" "i!1")
                                    ((""
                                      (inst - "i!1" "j")
                                      (("" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lower_triangular? const-decl "bool" matrix_det nil)
    (entry_mult formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (dot_eq_sigma formula-decl nil matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (length_col formula-decl nil matrices nil)
    (subrange type-eq-decl nil integers nil)
    (access_row formula-decl nil matrices nil)
    (access_col formula-decl nil matrix_props nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (access const-decl "real" matrices nil)
    (T_high type-eq-decl nil sigma "reals/")
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_low type-eq-decl nil sigma "reals/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (length_row formula-decl nil matrix_props nil)
    (* const-decl "real" matrices nil))
   nil))
 (upper_triangular_Id 0
  (upper_triangular_Id-1 nil 3615887393
   ("" (skeep)
    (("" (expand "upper_triangular?")
      (("" (skeep)
        (("" (rewrite "entry_Id")
          (("" (lift-if) (("" (ground) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((upper_triangular? const-decl "bool" matrix_det nil)
    (entry_Id formula-decl nil matrices 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil 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))
   shostak))
 (lower_triangular_Id 0
  (lower_triangular_Id-1 nil 3615887410
   ("" (skeep)
    (("" (expand "lower_triangular?")
      (("" (skosimp*)
        (("" (rewrite "entry_Id")
          (("" (lift-if) (("" (ground) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((lower_triangular? const-decl "bool" matrix_det nil)
    (entry_Id formula-decl nil matrices 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_ge_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))
   shostak))
 (upper_triangular_Easr 0
  (upper_triangular_Easr-1 nil 3615887935
   ("" (skeep)
    (("" (expand "upper_triangular?")
      (("" (skosimp*)
        (("" (rewrite "entry_Easr")
          (("" (lift-if)
            (("" (lift-if)
              (("" (lift-if)
                (("" (lift-if) (("" (ground) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((upper_triangular? const-decl "bool" matrix_det nil)
    (entry_Easr formula-decl nil matrix_det 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_ge_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)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (lower_triangular_Easr 0
  (lower_triangular_Easr-1 nil 3615887969
   ("" (skeep)
    (("" (expand "lower_triangular?")
      (("" (skosimp*)
        (("" (rewrite "entry_Easr")
          (("" (lift-if)
            (("" (lift-if)
              (("" (lift-if)
                (("" (lift-if) (("" (ground) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lower_triangular? const-decl "bool" matrix_det nil)
    (entry_Easr formula-decl nil matrix_det 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil 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)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (prod_mat_TCC1 0
  (prod_mat_TCC1-1 nil 3615822839 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (prod_mat_TCC2 0
  (prod_mat_TCC2-1 nil 3615822839 ("" (termination-tcc) nil nilnil
   nil))
 (prod_mat_TCC3 0
  (prod_mat_TCC3-1 nil 3615822839
   ("" (skeep)
    (("" (name "GG" "v(pn)(FM,k-1)")
      (("1" (replace -1)
        (("1" (hide -1)
          (("1" (typepred "GG")
            (("1" (rewrite "rows_mult" +)
              (("1" (rewrite "columns_mult" +)
                (("1" (assertnil nil)
                 ("2" (expand "rows")
                  (("2" (expand "length") (("2" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (assertnil nil))
      nil))
    nil)
   ((- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (rows_mult formula-decl nil matrices nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (columns_mult formula-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil))
   nil))
 (prod_mat_eq 0
  (prod_mat_eq-1 nil 3615823903
   ("" (induct "k")
    (("1" (grind) nil nil)
     ("2" (skeep)
      (("2" (skeep)
        (("2" (inst - "pn" "FM" "GM")
          (("2" (assert)
            (("2" (split -)
              (("1" (expand "prod_mat" +)
                (("1" (inst - "1+j") (("1" (assertnil nil)) nil))
                nil)
               ("2" (skeep)
                (("2" (inst - "i") (("2" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (mult_prod_mat_TCC1 0
  (mult_prod_mat_TCC1-1 nil 3615823426 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (mult_prod_mat 0
  (mult_prod_mat-1 nil 3615823806
   ("" (induct "p")
    (("1" (skeep)
      (("1" (assert)
        (("1" (expand "prod_mat" + 2)
          (("1" (expand "prod_mat" + 2)
            (("1" (assert)
              (("1" (lemma "prod_mat_eq")
                (("1" (inst?)
                  (("1"
                    (inst - "LAMBDA (i: nat):
                  IF i <= k THEN FM(i) ELSE GM(i - 1 - k) ENDIF")
                    (("1" (assert)
                      (("1" (skosimp*) (("1" (assertnil nil)) nil))
                      nil)
                     ("2" (skosimp*) (("2" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (assert)
        (("2" (inst?)
          (("2" (expand "prod_mat" + 2)
            (("2" (expand "prod_mat" + 3)
              (("2" (assert)
                (("2" (rewrite "matrix_mult_assoc" 1 :dir rl)
                  (("1" (assertnil nil)
                   ("2" (hide (-2 1))
                    (("2" (typepred "prod_mat(pn!1)(GM!1,j!1)")
                      (("2" (expand "rows")
                        (("2" (expand "length")
                          (("2" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (hide 2) (("3" (skosimp*) (("3" (assertnil nil)) nil))
      nil))
    nil)
   ((matrix_mult_assoc formula-decl nil matrices 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)
    (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)
    (k skolem-const-decl "nat" matrix_det nil)
    (prod_mat_eq formula-decl nil matrix_det nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (entry const-decl "real" matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (pred type-eq-decl nil defined_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers 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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (prod_mat_expand_left_TCC1 0
  (prod_mat_expand_left_TCC1-1 nil 3615824896
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_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))
   nil))
 (prod_mat_expand_left 0
  (prod_mat_expand_left-1 nil 3615824880
   (""
    (case "FORALL (k: nat, pn: posnat, FM: [nat -> SquareMatrix(pn)]):
         prod_mat(pn)(FM, k+1) =
          FM(0) * prod_mat(pn)(LAMBDA (i): FM(i + 1), k)")
    (("1" (skeep)
      (("1" (inst - "k-1" "pn" "FM")
        (("1" (assertnil nil) ("2" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "k")
        (("1" (skeep)
          (("1" (assert)
            (("1" (expand "prod_mat")
              (("1" (expand "prod_mat") (("1" (propax) nil nil)) nil))
              nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (assert)
              (("2" (inst - "pn" "FM")
                (("2" (assert)
                  (("2" (expand "prod_mat" +)
                    (("2" (rewrite "matrix_mult_assoc" :dir rl)
                      (("1" (assertnil nil)
                       ("2"
                        (typepred
                         "prod_mat(pn)(LAMBDA (i): FM(1 + i), j)")
                        (("2" (expand "rows" -3)
                          (("2" (expand "length")
                            (("2" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (matrix_mult_assoc formula-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (k skolem-const-decl "nat" matrix_det nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (mult_full application-judgement "FullMatrix" matrices 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers 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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (entry const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (row const-decl "Vector" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil))
   shostak))
 (transpose_prod_mat_TCC1 0
  (transpose_prod_mat_TCC1-1 nil 3615885429 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (transpose_prod_mat_TCC2 0
  (transpose_prod_mat_TCC2-1 nil 3615885429
   ("" (skeep)
    (("" (rewrite "rows_transpose")
      (("" (rewrite "columns_transpose") (("" (assertnil nil)) nil))
      nil))
    nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (rows_transpose formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (columns_transpose formula-decl nil matrices nil))
   nil))
 (transpose_prod_mat 0
  (transpose_prod_mat-1 nil 3615885430
   ("" (induct "k")
    (("1" (skeep)
      (("1" (expand "prod_mat") (("1" (propax) nil nil)) nil)) nil)
     ("2" (skeep)
      (("2" (skeep)
        (("2" (assert)
          (("2" (lemma "prod_mat_expand_left")
            (("2"
              (inst - "1+j" "pn" "LAMBDA (i):
                  IF i <= 1 + j THEN transpose(FM(1 - i + j))
                  ELSE FM(i)
                  ENDIF")
              (("1" (assert)
                (("1" (replaces -1)
                  (("1" (expand "prod_mat" + 1)
                    (("1" (rewrite "transpose_mult")
                      (("1" (inst - "pn" "FM")
                        (("1" (assert)
                          (("1" (lemma "prod_mat_eq")
                            (("1"
                              (inst - "j" "pn" "LAMBDA (i):
                  IF i <= j THEN transpose(FM(j - i)) ELSE FM(i) ENDIF"
                               "LAMBDA (i_1: nat):
                   IF 1 + i_1 <= 1 + j THEN transpose(FM(j - i_1))
                   ELSE FM(1 + i_1)
                   ENDIF")
                              (("1"
                                (split -)
                                (("1" (assertnil nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (lift-if)
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (rewrite "rows_transpose")
                                    (("2"
                                      (rewrite "columns_transpose")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("3"
                                (hide 2)
                                (("3"
                                  (skosimp*)
                                  (("3" (assertnil nil))
                                  nil))
                                nil)
                               ("4"
                                (hide 2)
                                (("4"
                                  (skosimp*)
                                  (("4"
                                    (rewrite "rows_transpose")
                                    (("4"
                                      (rewrite "columns_transpose")
                                      (("4" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("5"
                                (hide 2)
                                (("5"
                                  (skosimp*)
                                  (("5" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide-all-but 1)
                (("2" (skosimp*)
                  (("2" (rewrite "rows_transpose")
                    (("2" (rewrite "columns_transpose")
                      (("2" (assertnil nil)) nil))
                    nil))
                  nil))
                nil)
               ("3" (hide-all-but 1)
                (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (hide-all-but 1)
      (("3" (skosimp*)
        (("3" (rewrite "rows_transpose")
          (("3" (rewrite "columns_transpose") (("3" (assertnil nil))
            nil))
          nil))
        nil))
      nil)
     ("4" (hide-all-but 1)
      (("4" (skosimp*) (("4" (assertnil nil)) nil)) nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (j skolem-const-decl "nat" matrix_det nil)
    (pn skolem-const-decl "posnat" matrix_det nil)
    (FM skolem-const-decl "[nat -> SquareMatrix(pn)]" matrix_det nil)
    (transpose_mult formula-decl nil matrices nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (columns_transpose formula-decl nil matrices nil)
    (rows_transpose formula-decl nil matrices nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (prod_mat_eq formula-decl nil matrix_det nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (prod_mat_expand_left formula-decl nil matrix_det nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (pred type-eq-decl nil defined_types nil)
    (transpose const-decl "PosFullMatrix" matrices 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers 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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (mult_simple_prod_TCC1 0
  (mult_simple_prod_TCC1-1 nil 3615823242
   ("" (skeep)
    (("" (rewrite "rows_mult")
      (("" (rewrite "columns_mult")
        (("1" (assertnil nil)
         ("2" (typepred "R")
          (("2" (expand "rows")
            (("2" (expand "length") (("2" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((rows_mult formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (columns_mult formula-decl nil matrices nil))
   nil))
 (mult_simple_prod 0
  (mult_simple_prod-1 nil 3615823243
   ("" (skeep)
    (("" (expand "is_simple_prod?")
      (("" (skolem - ("FM" "k"))
        (("" (skolem - ("GM" "p"))
          (("" (assert)
            (("" (flatten)
              (("" (replace -2 +)
                (("" (replace -4 +)
                  (("" (rewrite "mult_prod_mat" +)
                    ((""
                      (inst + "LAMBDA (i: nat):
                    IF i <= k THEN FM(i) ELSE GM(i - 1 - k) ENDIF"
                       "1+k+p")
                      (("1" (assert)
                        (("1" (expand "is_simple_seq?")
                          (("1" (skeep)
                            (("1" (lift-if)
                              (("1"
                                (split 1)
                                (("1"
                                  (flatten)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (inst - "p!1")
                                      (("1"
                                        (assert)
                                        (("1" (ground) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (flatten)
                                  (("2"
                                    (inst -3 "p!1-1-k")
                                    (("1"
                                      (assert)
                                      (("1" (ground) nil nil))
                                      nil)
                                     ("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (skosimp*) (("2" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((is_simple_prod? const-decl "bool" matrix_det nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (k skolem-const-decl "nat" matrix_det 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)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (p!1 skolem-const-decl "nat" matrix_det 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)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (mult_prod_mat formula-decl nil matrix_det nil))
   shostak))
 (Id_simple_prod 0
  (Id_simple_prod-1 nil 3615889356
   ("" (skeep)
    (("" (expand "is_simple_prod?")
      (("" (inst + "LAMBDA (i): Id(pn)" "0")
        (("" (split)
          (("1" (expand "is_simple_seq?") (("1" (propax) nil nil)) nil)
           ("2" (expand "prod_mat") (("2" (propax) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((is_simple_prod? const-decl "bool" matrix_det nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (entry const-decl "real" matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (Esr_simple_prod 0
  (Esr_simple_prod-1 nil 3615824263
   ("" (skeep)
    (("" (expand "is_simple_prod?")
      (("" (inst + "LAMBDA (j:nat): Esr(pn)(i,r)" "0")
        (("" (split)
          (("1" (expand "is_simple_seq?")
            (("1" (skeep)
              (("1" (assert) (("1" (inst 4 "i" "r"nil nil)) nil))
              nil))
            nil)
           ("2" (expand "prod_mat") (("2" (propax) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((is_simple_prod? const-decl "bool" matrix_det nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (Ers_simple_prod 0
  (Ers_simple_prod-1 nil 3615824437
   ("" (skeep)
    (("" (expand "is_simple_prod?")
      (("" (inst + "LAMBDA (p:nat): Ers(pn)(i,j)" "0")
        (("" (split)
          (("1" (expand "is_simple_seq?")
            (("1" (skeep)
              (("1" (assert)
                (("1" (inst + "i" "j") (("1" (assertnil nil)) nil))
                nil))
              nil))
            nil)
           ("2" (expand "prod_mat") (("2" (propax) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((is_simple_prod? const-decl "bool" matrix_det nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (Ers const-decl "{M: SquareMatrix(pn) | M = swap(i, j)(Id(pn))}"
     matrix_det nil)
    (Id const-decl "{M: SquareMatrix(pm) |
         (FORALL (i, j):
            entry(M)(i, j) = IF i < pm AND i = j THEN 1 ELSE 0 ENDIF)
          AND
          (FORALL (pn: posnat, N: MatrixMN(pm, pn)): M * N = N) AND
           (FORALL (pn: posnat, N: MatrixMN(pn, pm)): N * M = N)}"
        matrices nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (swap const-decl "{PFM |
         rows(PFM) = rows(D) AND
          columns(PFM) = columns(D) AND
           (FORALL (k, p):
              i < rows(D) AND j < rows(D) IMPLIES
               entry(PFM)(k, p) =
                (IF k = i THEN entry(D)(j, p)
                 ELSIF k = j THEN entry(D)(i, p)
                 ELSE entry(D)(k, p)
                 ENDIF))}" matrix_props nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (entry const-decl "real" matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (Easr_simple_prod 0
  (Easr_simple_prod-1 nil 3615824583
   ("" (skeep)
    (("" (expand "is_simple_prod?")
      (("" (inst + "LAMBDA (p:nat): Easr(pn)(i,j,r)" "0")
        (("" (split)
          (("1" (expand "is_simple_seq?")
            (("1" (skeep)
              (("1" (inst 3 "i" "j" "r") (("1" (assertnil nil)) nil))
              nil))
            nil)
           ("2" (expand "prod_mat") (("2" (propax) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((is_simple_prod? const-decl "bool" matrix_det nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (> const-decl "bool" reals nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (det_simple_prod_1 0
  (det_simple_prod_1-1 nil 3615824734
   ("" (expand "is_simple_prod?")
    ((""
      (case "FORALL (pn: posnat, S: SquareMatrix(pn),k):
               (EXISTS (FM: [nat -> SquareMatrix(pn)]):
                  is_simple_seq?(pn)(FM, k, FALSE,false) AND S = prod_mat(pn)(FM, k))
                IMPLIES det(S) = 1")
      (("1" (skeep)
        (("1" (skeep)
          (("1" (inst - "pn" "S" "k")
            (("1" (assert)
              (("1" (inst + "FM") (("1" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (induct "k")
          (("1" (skeep)
            (("1" (skeep)
              (("1" (assert)
                (("1" (replace -2)
                  (("1" (expand "prod_mat")
                    (("1" (expand "is_simple_seq?")
                      (("1" (inst - "0")
                        (("1" (assert)
                          (("1" (ground)
                            (("1" (replaces -1)
                              (("1" (rewrite "det_Id"nil nil)) nil)
                             ("2" (skeep)
                              (("2"
                                (replace -3)
                                (("2"
                                  (rewrite "det_Easr")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skeep)
            (("2" (assert)
              (("2" (skeep)
                (("2" (assert)
                  (("2" (skeep)
                    (("2" (replace -3 +)
                      (("2" (rewrite "prod_mat_expand_left" 1)
                        (("2"
                          (inst - "pn"
                           "prod_mat(pn)(LAMBDA (i): FM(1 + i), j)")
                          (("2" (assert)
                            (("2" (split -1)
                              (("1"
                                (expand "is_simple_seq?")
                                (("1"
                                  (inst - "0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (split -)
                                      (("1"
                                        (replaces -1)
                                        (("1"
                                          (rewrite "mult_Id_left")
                                          nil
                                          nil))
                                        nil)
                                       ("2"
                                        (skosimp*)
                                        (("2"
                                          (replace -3)
                                          (("2"
                                            (name
                                             "GV"
                                             "prod_mat(pn)(LAMBDA (i): FM(1 + i), j)")
                                            (("2"
                                              (replace -1)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (rewrite
                                                   "mult_Easr_left"
                                                   +)
                                                  (("2"
                                                    (rewrite
                                                     "det_replace_row_sum_scal")
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (inst + "LAMBDA (i): FM(1+i)")
                                  (("2"
                                    (assert)
                                    (("2"
                                      (expand "is_simple_seq?")
                                      (("2"
                                        (skeep)
                                        (("2"
                                          (inst - "1+p")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((det def-decl "real" matrix_props nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (FALSE const-decl "bool" booleans nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (det_Easr formula-decl nil matrix_det nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (det_Id formula-decl nil matrix_props nil)
    (mult_Id_left formula-decl nil matrices nil)
    (mult_Easr_left formula-decl nil matrix_det nil)
    (det_replace_row_sum_scal formula-decl nil matrix_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (prod_mat_expand_left formula-decl nil matrix_det nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (is_simple_prod? const-decl "bool" matrix_det nil))
   shostak))
 (det_mult_simple_prod_left 0
  (det_mult_simple_prod_left-1 nil 3615825883
   ("" (expand "is_simple_prod?")
    ((""
      (case " FORALL (pn: posnat, S, R: SquareMatrix(pn),Kz:nat,k:nat):k<=Kz AND
               (EXISTS (FM: [nat -> SquareMatrix(pn)]):
                  is_simple_seq?(pn)(FM, k, FALSE, FALSE) AND
                   S = prod_mat(pn)(FM, k))
                IMPLIES det(S * R) = det(R)")
      (("1" (skeep)
        (("1" (skeep)
          (("1" (inst - "pn" "S" "R" "k" "k")
            (("1" (assert)
              (("1" (inst + "FM") (("1" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (induct "Kz")
          (("1" (skeep)
            (("1" (case "k = 0")
              (("1" (replaces -1)
                (("1" (hide -1)
                  (("1" (assert)
                    (("1" (skeep)
                      (("1" (expand "is_simple_seq?")
                        (("1" (inst - "0")
                          (("1" (expand "prod_mat")
                            (("1" (replace -2 :dir rl)
                              (("1"
                                (ground)
                                (("1"
                                  (replaces -1)
                                  (("1"
                                    (rewrite "mult_Id_left")
                                    nil
                                    nil))
                                  nil)
                                 ("2"
                                  (skeep)
                                  (("2"
                                    (replace -3 +)
                                    (("2"
                                      (rewrite "mult_Easr_left" +)
                                      (("2"
                                        (rewrite
                                         "det_replace_row_sum_scal")
                                        nil
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (skeep)
                (("2" (replace -3) (("2" (assertnil nil)) nil)) nil))
              nil))
            nil)
           ("2" (skeep)
            (("2" (skeep)
              (("2" (skeep)
                (("2" (case "NOT k = j+1")
                  (("1" (inst - "pn" "S" "R" "k")
                    (("1" (assert)
                      (("1" (inst + "FM") (("1" (assertnil nil))
                        nil))
                      nil))
                    nil)
                   ("2" (replace -1)
                    (("2" (hide -3)
                      (("2" (assert)
                        (("2" (replace -4 +)
                          (("2" (expand "prod_mat" +)
                            (("2" (rewrite "matrix_mult_assoc")
                              (("1"
                                (inst-cp
                                 -
                                 "pn"
                                 "prod_mat(pn)(FM,j)"
                                 "FM(1+j)*R"
                                 "j")
                                (("1"
                                  (assert)
                                  (("1"
                                    (split -)
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (inst
                                           -
                                           "pn"
                                           "FM(1+j)"
                                           "R"
                                           "0")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst
                                               +
                                               "LaMBDA (p:nat): FM(1+j)")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "is_simple_seq?")
                                                  (("1"
                                                    (skosimp*)
                                                    (("1"
                                                      (inst - "1+j")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "prod_mat")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (inst + "FM")
                                      (("2"
                                        (hide -2)
                                        (("2"
                                          (expand "is_simple_seq?")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (rewrite "rows_mult")
                                  (("2"
                                    (rewrite "columns_mult")
                                    (("1" (assertnil nil)
                                     ("2"
                                      (typepred "FM(1+j)")
                                      (("2"
                                        (expand "rows")
                                        (("2"
                                          (expand "length")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (typepred "FM(1+j)")
                                (("2"
                                  (expand "rows")
                                  (("2"
                                    (expand "length")
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (row const-decl "Vector" matrices nil)
    (* const-decl "real" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (entry const-decl "real" matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (det def-decl "real" matrix_props nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (FALSE const-decl "bool" booleans nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (mult_Easr_left formula-decl nil matrix_det nil)
    (det_replace_row_sum_scal formula-decl nil matrix_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_Id_left formula-decl nil matrices nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (matrix_mult_assoc formula-decl nil matrices nil)
    (rows_mult formula-decl nil matrices nil)
    (columns_mult formula-decl nil matrices nil)
    (R skolem-const-decl "SquareMatrix(pn)" matrix_det nil)
    (j skolem-const-decl "nat" matrix_det nil)
    (FM skolem-const-decl "[nat -> SquareMatrix(pn)]" matrix_det nil)
    (pn skolem-const-decl "posnat" matrix_det nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (is_simple_prod? const-decl "bool" matrix_det nil))
   shostak))
 (Easr_null 0
  (Easr_null-1 nil 3615889893
   ("" (skeep)
    (("" (typepred "Easr(pn)(i,j,r)")
      (("" (expand "rows")
        (("" (expand "length") (("" (assertnil nil)) nil)) nil))
      nil))
    nil)
   ((Easr const-decl "SquareMatrix(pn)" matrix_det nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (<= const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (length def-decl "nat" list_props nil)
    (< const-decl "bool" reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (Matrix type-eq-decl nil matrices nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (transpose_simple_prod_TCC1 0
  (transpose_simple_prod_TCC1-1 nil 3615826667
   ("" (skeep)
    (("" (rewrite "rows_transpose")
      (("" (rewrite "columns_transpose") (("" (assertnil nil)) nil))
      nil))
    nil)
   ((rows_transpose formula-decl nil matrices nil)
    (number nonempty-type-decl nil numbers nil)
    (list type-decl nil list_adt nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt 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 "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (columns_transpose formula-decl nil matrices nil))
   nil))
 (transpose_simple_prod 0
  (transpose_simple_prod-1 nil 3615826668
   (""
    (case "FORALL (include_scals, include_swaps: bool, pn: posnat,
                            S: SquareMatrix(pn)):
                      is_simple_prod?(pn, include_scals, include_swaps)(S) IMPLIES
                       is_simple_prod?(pn, include_scals, include_swaps)(transpose(S))")
    (("1" (skeep)
      (("1" (ground)
        (("1" (inst?) (("1" (assertnil nil)) nil)
         ("2" (inst - _ _ "pn" "transpose(S)")
          (("2" (inst?)
            (("2" (assert)
              (("2" (rewrite "transpose_transpose"nil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (skeep)
        (("2" (expand "is_simple_prod?")
          (("2" (skeep)
            (("2"
              (inst +
               "LAMBDA (i): IF i<=k THEN transpose(FM(k-i)) ELSE FM(i) ENDIF"
               "k")
              (("1" (lemma "transpose_prod_mat")
                (("1" (inst?)
                  (("1" (replace -3 +)
                    (("1" (replace -1)
                      (("1" (expand "is_simple_seq?")
                        (("1" (skeep)
                          (("1" (case "p>k")
                            (("1" (assert)
                              (("1"
                                (inst - "p")
                                (("1" (ground) nil nil))
                                nil))
                              nil)
                             ("2" (assert)
                              (("2"
                                (inst - "k-p")
                                (("2"
                                  (split -)
                                  (("1"
                                    (replaces -1)
                                    (("1"
                                      (rewrite "transpose_Id")
                                      nil
                                      nil))
                                    nil)
                                   ("2"
                                    (flatten)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (skeep)
                                        (("2"
                                          (lemma "transpose_Ers")
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (replace -5)
                                              (("2"
                                                (replace -1)
                                                (("2"
                                                  (inst + "j" "i")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (skeep)
                                    (("3"
                                      (lemma "transpose_Easr")
                                      (("3"
                                        (inst?)
                                        (("3"
                                          (replace -4)
                                          (("3"
                                            (replace -1)
                                            (("3"
                                              (assert)
                                              (("3"
                                                (inst + "j" "i" "r")
                                                (("3"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("4"
                                    (flatten)
                                    (("4"
                                      (assert)
                                      (("4"
                                        (skeep)
                                        (("4"
                                          (lemma "transpose_Esr")
                                          (("4"
                                            (inst?)
                                            (("4"
                                              (inst 5 "i" "r")
                                              (("4" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide-all-but 1)
                (("2" (skosimp*)
                  (("2" (rewrite "rows_transpose")
                    (("2" (rewrite "columns_transpose")
                      (("2" (assertnil nil)) nil))
                    nil))
                  nil))
                nil)
               ("3" (hide-all-but 1)
                (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (hide-all-but 1)
      (("3" (skosimp*)
        (("3" (rewrite "rows_transpose")
          (("3" (rewrite "columns_transpose") (("3" (assertnil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (k skolem-const-decl "nat" matrix_det nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (FM skolem-const-decl "[nat -> SquareMatrix(pn)]" matrix_det nil)
    (pn skolem-const-decl "posnat" matrix_det nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (transpose_Id formula-decl nil matrices nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (transpose_Ers formula-decl nil matrix_det nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (transpose_Easr formula-decl nil matrix_det nil)
    (transpose_Esr formula-decl nil matrix_det nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (transpose_prod_mat formula-decl nil matrix_det nil)
    (columns_transpose formula-decl nil matrices nil)
    (rows_transpose formula-decl nil matrices nil)
    (transpose_transpose formula-decl nil matrices nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers 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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (is_simple_prod? const-decl "bool" matrix_det nil)
    (transpose const-decl "PosFullMatrix" matrices nil))
   shostak))
 (diagonal_simple_prod 0
  (diagonal_simple_prod-1 nil 3615903437
   ("" (skeep)
    ((""
      (name "GZ"
            "LAMBDA (k): form_matrix(lambda (i,j): IF i<=k AND i=j THEN entry(S)(i,j) ELSIF i=j THEN 1 ELSE 0 ENDIF,pn,pn)")
      ((""
        (case "FORALL (k): k<pn IMPLIES is_simple_prod?(pn,true,include_swaps)(GZ(k))")
        (("1" (case "S = GZ(pn-1)")
          (("1" (inst - "pn-1")
            (("1" (assert) (("1" (assertnil nil)) nil)) nil)
           ("2" (hide (-1 2))
            (("2" (rewrite "full_matrix_eq")
              (("1" (split +)
                (("1" (expand "GZ" 1)
                  (("1" (rewrite "rows_form_matrix")
                    (("1" (assertnil nil)) nil))
                  nil)
                 ("2" (expand "GZ" 1)
                  (("2" (lemma "columns_form_matrix")
                    (("2" (inst?) (("2" (assertnil nil)) nil)) nil))
                  nil)
                 ("3" (skosimp*)
                  (("3" (expand "GZ" +)
                    (("3" (rewrite "entry_form_matrix")
                      (("3" (lift-if)
                        (("3" (assert)
                          (("3" (ground)
                            (("3" (typepred "i!1")
                              (("3"
                                (typepred "j!1")
                                (("3"
                                  (expand "diagonal?")
                                  (("3"
                                    (inst - "i!1" "j!1")
                                    (("3" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (flatten)
                (("2" (lemma "form_matrix_square")
                  (("2"
                    (inst - "LAMBDA (i, j):
                       IF i <= pn-1 AND i = j THEN entry(S)(i, j)
                       ELSIF i = j THEN 1
                       ELSE 0
                       ENDIF" "pn" "pn")
                    (("2" (skosimp*)
                      (("2" (assert)
                        (("2" (expand "GZ" +)
                          (("2" (assert)
                            (("2" (inst - "i!1" "j!1"nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide (-1 2))
          (("2" (induct "k")
            (("1" (flatten)
              (("1" (assert)
                (("1" (hide -2)
                  (("1" (expand "is_simple_prod?")
                    (("1" (inst + "LAMBDA (i): GZ(0)" "0")
                      (("1" (split)
                        (("1" (expand "is_simple_seq?")
                          (("1" (skeep)
                            (("1" (inst 4 "0" "entry(S)(0,0)")
                              (("1"
                                (assert)
                                (("1"
                                  (hide (2 3))
                                  (("1"
                                    (rewrite "full_matrix_eq" 2)
                                    (("1"
                                      (split)
                                      (("1"
                                        (expand "GZ")
                                        (("1"
                                          (rewrite "rows_form_matrix")
                                          (("1" (assertnil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "GZ" 1)
                                        (("2"
                                          (lemma "columns_form_matrix")
                                          (("2"
                                            (inst?)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("3"
                                        (skeep)
                                        (("3"
                                          (typepred "i")
                                          (("3"
                                            (typepred "j")
                                            (("3"
                                              (expand "GZ")
                                              (("3"
                                                (hide 2)
                                                (("3"
                                                  (rewrite
                                                   "entry_form_matrix")
                                                  (("3"
                                                    (assert)
                                                    (("3"
                                                      (rewrite
                                                       "entry_Esr")
                                                      (("3"
                                                        (lift-if)
                                                        (("3"
                                                          (lift-if)
                                                          (("3"
                                                            (lift-if)
                                                            (("3"
                                                              (assert)
                                                              (("3"
                                                                (lift-if)
                                                                (("3"
                                                                  (ground)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (skosimp*)
                                        (("2"
                                          (lemma "form_matrix_square")
                                          (("2"
                                            (expand "GZ" 2)
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (expand "GZ" 1)
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (inst
                                                     -
                                                     "i!1"
                                                     "j!1")
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "prod_mat")
                          (("2" (propax) nil nil)) nil))
                        nil)
                       ("2" (split +)
                        (("1" (flatten)
                          (("1" (lemma "form_matrix_square")
                            (("1" (expand "GZ")
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (skosimp*)
                                    (("1"
                                      (inst - "i!1" "j!1")
                                      nil
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "GZ")
                          (("2" (rewrite "rows_form_matrix")
                            (("2" (assertnil nil)) nil))
                          nil)
                         ("3" (lemma "columns_form_matrix")
                          (("3" (expand "GZ")
                            (("3" (inst?) (("3" (assertnil nil))
                              nil))
                            nil))
                          nil)
                         ("4" (expand "GZ")
                          (("4" (rewrite "rows_form_matrix")
                            (("4" (lemma "columns_form_matrix")
                              (("4"
                                (inst?)
                                (("4" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("5" (expand "GZ")
                          (("5" (rewrite "rows_form_matrix"nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (skeep)
              (("2"
                (case "GZ(j+1) = GZ(j)*Esr(pn)(j+1,entry(S)(j+1,j+1))")
                (("1" (replaces -1)
                  (("1" (rewrite "mult_simple_prod")
                    (("1" (hide 2)
                      (("1" (rewrite "Esr_simple_prod"nil nil)) nil)
                     ("2" (assert)
                      (("2" (expand "is_simple_prod?")
                        (("2" (skeep)
                          (("2" (assert)
                            (("2" (flatten)
                              (("2"
                                (replace -2)
                                (("2"
                                  (assert)
                                  (("2"
                                    (typepred "prod_mat(pn)(FM,k)")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (skosimp*)
                                        (("2"
                                          (inst - "i!1" "j!1")
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assert)
                  (("2" (hide (-1 2))
                    (("2" (expand "GZ")
                      (("2" (expand "Esr")
                        (("2" (rewrite "form_matrix_mult")
                          (("2" (rewrite "full_matrix_eq")
                            (("2" (split)
                              (("1"
                                (rewrite "rows_form_matrix")
                                (("1"
                                  (rewrite "rows_form_matrix")
                                  nil
                                  nil))
                                nil)
                               ("2"
                                (lemma "columns_form_matrix")
                                (("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (replaces -1)
                                      (("2"
                                        (lemma "columns_form_matrix")
                                        (("2"
                                          (inst?)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("3"
                                (skosimp*)
                                (("3"
                                  (rewrite "entry_form_matrix")
                                  (("3"
                                    (rewrite "entry_form_matrix")
                                    (("3"
                                      (assert)
                                      (("3"
                                        (lift-if)
                                        (("3"
                                          (split 1)
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (split 1)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (replace -2)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lemma
                                                           "sigma_eq_one_arg2")
                                                          (("1"
                                                            (inst?)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "j!1")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (split
                                                                   -)
                                                                  (("1"
                                                                    (replaces
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (lift-if)
                                                                          (("1"
                                                                            (lift-if)
                                                                            (("1"
                                                                              (ground)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (skosimp*)
                                                                      (("2"
                                                                        (expand
                                                                         "diagonal?")
                                                                        (("2"
                                                                          (lift-if)
                                                                          (("2"
                                                                            (lift-if)
                                                                            (("2"
                                                                              (lift-if)
                                                                              (("2"
                                                                                (lift-if)
                                                                                (("2"
                                                                                  (lift-if)
                                                                                  (("2"
                                                                                    (lift-if)
                                                                                    (("2"
                                                                                      (lift-if)
                                                                                      (("2"
                                                                                        (lift-if)
                                                                                        (("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"
                                                  (flatten)
                                                  (("2"
                                                    (split 2)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (replaces -1)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lemma
                                                             "sigma_eq_one_arg2")
                                                            (("1"
                                                              (inst?)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "j!1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (skosimp*)
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (lift-if)
                                                                          (("1"
                                                                            (ground)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (rewrite
                                                         "sigma_restrict_eq_0")
                                                        (("2"
                                                          (hide 3)
                                                          (("2"
                                                            (skosimp*)
                                                            (("2"
                                                              (expand
                                                               "diagonal?")
                                                              (("2"
                                                                (inst-cp
                                                                 -
                                                                 "i!1"
                                                                 "i!2")
                                                                (("2"
                                                                  (lift-if)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (lift-if)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (hide 2)
              (("3" (skeep)
                (("3" (assert)
                  (("3" (split)
                    (("1" (lemma "form_matrix_square")
                      (("1" (expand "GZ")
                        (("1"
                          (inst - "LAMBDA (i, j):
                                  IF i <= k AND i = j THEN entry(S)(i, j)
                                  ELSIF i = j THEN 1
                                  ELSE 0
                                  ENDIF" "pn" "pn")
                          (("1" (assert)
                            (("1" (flatten)
                              (("1"
                                (assert)
                                (("1"
                                  (skosimp*)
                                  (("1" (inst - "i!1" "j!1"nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "GZ")
                        (("2" (rewrite "rows_form_matrix")
                          (("2" (assertnil nil)) nil))
                        nil))
                      nil)
                     ("3" (expand "GZ")
                      (("3" (lemma "columns_form_matrix")
                        (("3" (inst?) (("3" (assertnil nil)) nil))
                        nil))
                      nil)
                     ("4" (expand "GZ")
                      (("4" (rewrite "rows_form_matrix")
                        (("4" (lemma "columns_form_matrix")
                          (("4" (inst?) (("4" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil)
                     ("5" (expand "GZ")
                      (("5" (rewrite "rows_form_matrix"nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (hide 2)
          (("3" (skeep)
            (("3" (assert)
              (("3" (split)
                (("1" (flatten)
                  (("1" (expand "GZ")
                    (("1" (lemma "form_matrix_square")
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (skosimp*)
                            (("1" (inst - "i!1" "j!1"nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (expand "GZ")
                  (("2" (rewrite "rows_form_matrix")
                    (("2" (assertnil nil)) nil))
                  nil)
                 ("3" (expand "GZ")
                  (("3" (lemma "columns_form_matrix")
                    (("3" (inst?) (("3" (assertnil nil)) nil)) nil))
                  nil)
                 ("4" (expand "GZ")
                  (("4" (rewrite "rows_form_matrix")
                    (("4" (lemma "columns_form_matrix")
                      (("4" (inst?) (("4" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("5" (expand "GZ")
                  (("5" (rewrite "rows_form_matrix"nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((form_matrix const-decl "{M: MatrixMN(m, n) |
         FORALL (i: below(m), j: below(n)): nth(row(M)(i), j) = F(i, j)}"
                 matrices nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (rows const-decl "nat" matrices nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (entry const-decl "real" matrices nil)
    (<= const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (row const-decl "Vector" matrices nil)
    (Vector type-eq-decl nil matrices nil)
    (MatrixMN type-eq-decl nil matrices nil)
    (nth def-decl "T" list_props nil)
    (below type-eq-decl nil nat_types nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (length def-decl "nat" list_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Matrix type-eq-decl nil matrices nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (every adt-def-decl "boolean" list_adt nil)
    (PRED type-eq-decl nil defined_types nil)
    (list type-decl nil list_adt nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (form_matrix_square application-judgement "FullMatrix" matrices
     nil)
    (/= const-decl "boolean" notequal nil)
    (form_matrix_mult formula-decl nil matrices nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (subrange type-eq-decl nil integers nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (sigma_nat application-judgement "nat" sigma_nat "reals/")
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (sigma_eq_one_arg2 formula-decl nil sigma "reals/")
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (odd_times_odd_is_odd application-judgement "odd_int" integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (Esr_simple_prod formula-decl nil matrix_det nil)
    (mult_simple_prod formula-decl nil matrix_det nil)
    (* const-decl "{A: MatrixMN(rows(M), columns(N)) |
         FORALL (i, j): entry(A)(i, j) = row(M)(i) * col(N)(j)}"
       matrices nil)
    (col def-decl "VectorN(rows(M))" matrices nil)
    (VectorN type-eq-decl nil matrices nil)
    (* const-decl "real" matrices nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_full application-judgement "FullMatrix" matrices nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (prod_mat def-decl "SquareMatrix(pn)" matrix_det nil)
    (is_simple_seq? const-decl "bool" matrix_det nil)
    (entry_Esr formula-decl nil matrix_det nil)
    (Esr const-decl "SquareMatrix(pn)" matrix_det nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (S skolem-const-decl "SquareMatrix(pn)" matrix_det nil)
    (pn skolem-const-decl "posnat" matrix_det nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_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)
    (full_matrix_eq formula-decl nil matrices nil)
    (entry_form_matrix formula-decl nil matrices nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (diagonal? const-decl "bool" matrix_det nil)
    (columns_form_matrix formula-decl nil matrices nil)
    (GZ skolem-const-decl "[k: nat ->
   {M: MatrixMN(pn, pn) |
            FORALL (i_1: below(pn), j_1: below(pn)):
              nth(row(M)(i_1), j_1) =
               IF i_1 <= k AND i_1 = j_1 THEN entry(S)(i_1, j_1)
               ELSIF i_1 = j_1 THEN 1
               ELSE 0
               ENDIF}]" matrix_det nil)
    (rows_form_matrix formula-decl nil matrices nil)
    (form_matrix_square judgement-tcc nil matrices nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (is_simple_prod? const-decl "bool" matrix_det nil)
    (TRUE const-decl "bool" booleans nil))
   shostak))
 (is_simple_prod_implic 0
  (is_simple_prod_implic-1 nil 3616751452
   ("" (skeep)
    (("" (expand "is_simple_prod?")
      (("" (skeep)
        (("" (inst + "FM" "k")
          (("" (assert)
            (("" (expand "is_simple_seq?")
              (("" (skeep)
                (("" (inst - "p") (("" (ground) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((is_simple_prod? const-decl "bool" matrix_det 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)
    (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)
    (Matrix type-eq-decl nil matrices nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (null? adt-recognizer-decl "[list -> boolean]" list_adt nil)
    (< const-decl "bool" reals nil)
    (length def-decl "nat" list_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil nat_types nil)
    (nth def-decl "T" list_props nil)
    (FullMatrix type-eq-decl nil matrices nil)
    (> const-decl "bool" reals nil)
    (rows const-decl "nat" matrices nil)
    (<= const-decl "bool" reals nil)
    (columns def-decl "{c: nat |
         (FORALL (i: below(length(M))): length(nth(M, i)) <= c) AND
          (null?(M) AND c = 0 OR
            (EXISTS (i: below(length(M))): length(nth(M, i)) = c))}"
             matrices nil)
    (PosFullMatrix type-eq-decl nil matrices nil)
    (Square type-eq-decl nil matrices nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (SquareMatrix type-eq-decl nil matrices nil)
    (is_simple_seq? const-decl "bool" matrix_det nil))
   shostak)))


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

¤ 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.565Bemerkung:  (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.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge