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


Impressum countable_props.prf

  Interaktion und
PortierbarkeitLisp
 

(countable_props
 (infinite_countably_infinite 0
  (infinite_countably_infinite-1 nil 3316998965
   ("" (skosimp)
    (("" (typepred "x!1")
      (("" (expand "is_countably_infinite")
        (("" (skosimp)
          (("" (typepred "f!1")
            (("" (lemma "infinite_def2" ("S" "x!1"))
              (("" (replace -3)
                (("" (assert) (("" (inst + "f!1"nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((countably_infinite_set type-eq-decl nil countability nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (infinite_def2 formula-decl nil infinite_nat_def nil)
    (surjective? const-decl "bool" functions nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (bijective? const-decl "bool" functions nil))
   nil))
 (countably_infinite_add 0
  (countably_infinite_add-1 nil 3316998965
   ("" (skolem-typepred)
    (("" (case "member(t!1, CountInf!1)")
      (("1" (forward-chain "member_add[T]") (("1" (assertnil nil))
        nil)
       ("2" (expand"is_countably_infinite" "member")
        (("2" (skolem-typepred)
          (("2"
            (inst +
             "LAMBDA (x: (add(t!1, CountInf!1))): IF x = t!1 THEN 0 ELSE f!1(x) + 1 ENDIF")
            (("1" (grind :if-match nil)
              (("1" (case "y!1 = 0")
                (("1" (inst + "t!1") (("1" (assertnil nil)) nil)
                 ("2" (assert)
                  (("2" (inst - "y!1 - 1")
                    (("2" (skolem!)
                      (("2" (inst + "x!1") (("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (inst - "x1!1" "x2!1") (("2" (assertnil nil))
                nil))
              nil)
             ("2" (skosimp :preds? t)
              (("2" (expand"add" "member") (("2" (assertnil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((member const-decl "bool" sets nil)
    (infinite_add application-judgement "infinite_set[T]"
     countable_props nil)
    (member_add formula-decl nil sets_lemmas nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (bijective? const-decl "bool" functions nil)
    (surjective? const-decl "bool" functions nil)
    (injective? const-decl "bool" functions nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (f!1 skolem-const-decl "(bijective?[(CountInf!1), nat])"
     countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (CountInf!1 skolem-const-decl "countably_infinite_set"
     countable_props nil)
    (t!1 skolem-const-decl "T" countable_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (add const-decl "(nonempty?)" sets nil)
    (nonempty? const-decl "bool" sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (countable_add 0
  (countable_add-1 nil 3316998965
   ("" (skolem-typepred)
    (("" (case "member[T](t!1,Count!1)")
      (("1" (lemma "member_add[T]" ("x" "t!1" "a" "Count!1"))
        (("1" (assertnil nil)) nil)
       ("2" (expand "is_countable")
        (("2" (skosimp)
          (("2" (typepred "f!1")
            (("2"
              (inst +
               "lambda (x:(add[T](t!1, Count!1))): if x = t!1 then 0 else f!1(x)+1 endif")
              (("1" (expand "injective?")
                (("1" (skosimp)
                  (("1" (typepred "x1!1")
                    (("1" (typepred "x2!1")
                      (("1" (expand "add")
                        (("1" (split)
                          (("1" (expand "member")
                            (("1" (assertnil nil)) nil)
                           ("2" (assert)
                            (("2" (expand "member")
                              (("2"
                                (assert)
                                (("2"
                                  (split)
                                  (("1" (assertnil nil)
                                   ("2"
                                    (inst - "x1!1" "x2!1")
                                    (("2"
                                      (case-replace "x1!1 = t!1")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (skosimp)
                (("2" (typepred "x!1")
                  (("2" (expand "add")
                    (("2" (assert)
                      (("2" (expand "member") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((member const-decl "bool" sets nil)
    (member_add formula-decl nil sets_lemmas nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nonempty? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets 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)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (t!1 skolem-const-decl "T" countable_props nil)
    (Count!1 skolem-const-decl "countable_set[T]" countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (f!1 skolem-const-decl "(injective?[(Count!1), nat])"
     countable_props nil)
    (x1!1 skolem-const-decl "(add[T](t!1, Count!1))" countable_props
     nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (injective? const-decl "bool" functions nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (countably_infinite_remove 0
  (countably_infinite_remove-1 nil 3316998965
   ("" (skolem-typepred)
    (("" (case "member(t!1, CountInf!1)")
      (("1" (expand "is_countably_infinite")
        (("1" (skolem-typepred)
          (("1"
            (inst +
             "LAMBDA (x: (remove(t!1, CountInf!1))): IF f!1(x) <= f!1(t!1) THEN f!1(x) ELSE f!1(x) - 1 ENDIF")
            (("1" (grind :if-match nil)
              (("1" (case "y!1 < f!1(t!1)")
                (("1" (inst - "y!1")
                  (("1" (skolem!)
                    (("1" (assert)
                      (("1" (inst + "x!1") (("1" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (inst - "1 + y!1")
                  (("2" (skolem!)
                    (("2" (assert)
                      (("2" (inst + "x!1") (("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (inst - "x1!1" "x2!1") (("2" (assertnil nil))
                nil)
               ("3" (inst - "x1!1" "t!1") (("3" (assertnil nil)) nil)
               ("4" (inst - "t!1" "x2!1") (("4" (assertnil nil)) nil)
               ("5" (inst - "x1!1" "x2!1") (("5" (assertnil nil))
                nil))
              nil)
             ("2" (skosimp :preds? t)
              (("2" (expand"remove" "member")
                (("2" (assertnil nil)) nil))
              nil)
             ("3" (skosimp :preds? t)
              (("3" (expand"remove" "member")
                (("3" (flatten) nil nil)) nil))
              nil)
             ("4" (skosimp :preds? t)
              (("4" (expand"remove" "member")
                (("4" (flatten) nil nil)) nil))
              nil)
             ("5" (skolem-typepred)
              (("5" (expand"remove" "member"nil nil)) nil)
             ("6" (skolem-typepred)
              (("6" (expand"remove" "member")
                (("6" (flatten) nil nil)) nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (forward-chain "member_remove[T]") (("2" (assertnil nil))
        nil))
      nil))
    nil)
   ((member const-decl "bool" sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (bijective? const-decl "bool" functions nil)
    (surjective? const-decl "bool" functions nil)
    (injective? const-decl "bool" functions nil)
    (/= const-decl "boolean" notequal nil)
    (infinite_remove application-judgement "infinite_set[T]"
     countable_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (f!1 skolem-const-decl "(bijective?[(CountInf!1), nat])"
     countable_props nil)
    (CountInf!1 skolem-const-decl "countably_infinite_set"
     countable_props nil)
    (t!1 skolem-const-decl "T" countable_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (remove const-decl "set" sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (member_remove formula-decl nil sets_lemmas nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (countable_remove 0
  (countable_remove-1 nil 3316998965
   ("" (skosimp)
    (("" (typepred "Count!1")
      (("" (lemma "member_remove" ("x" "t!1" "a" "Count!1"))
        (("" (case-replace "member(t!1, Count!1)")
          (("1" (expand "is_countable")
            (("1" (skosimp)
              (("1" (typepred "f!1")
                (("1"
                  (inst +
                   "lambda (x:(remove[T](t!1, Count!1))): f!1(x)")
                  (("1" (expand "injective?")
                    (("1" (skosimp)
                      (("1" (inst - "x1!1" "x2!1")
                        (("1" (assertnil nil)) nil))
                      nil))
                    nil)
                   ("2" (skosimp)
                    (("2" (typepred "x!1")
                      (("2" (expand "remove")
                        (("2" (flatten)
                          (("2" (assert)
                            (("2" (expand "member")
                              (("2" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (member const-decl "bool" sets nil)
    (remove const-decl "set" sets nil)
    (t!1 skolem-const-decl "T" countable_props nil)
    (Count!1 skolem-const-decl "countable_set[T]" countable_props nil)
    (f!1 skolem-const-decl "(injective?[(Count!1), nat])"
     countable_props nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (injective? const-decl "bool" functions nil)
    (member_remove formula-decl nil sets_lemmas nil))
   nil))
 (countably_infinite_rest 0
  (countably_infinite_rest-1 nil 3316998965
   ("" (expand "rest") (("" (propax) nil nil)) nil)
   ((rest const-decl "set" sets nil)
    (countably_infinite_remove application-judgement
     "countably_infinite_set[T]" countable_props nil)
    (countable_remove application-judgement "countable_set[T]"
     countable_props nil))
   nil))
 (countable_rest 0
  (countable_rest-1 nil 3316998965
   ("" (expand "rest") (("" (propax) nil nil)) nil)
   ((rest const-decl "set" sets nil)
    (countable_remove application-judgement "countable_set[T]"
     countable_props nil))
   nil))
 (countable_intersection1 0
  (countable_intersection1-1 nil 3316998965
   ("" (skolem-typepred)
    (("" (expand "is_countable")
      (("" (skolem-typepred)
        ((""
          (inst + "LAMBDA (x: (intersection(Count!1, S!1))): f!1(x)")
          (("1" (expand "injective?")
            (("1" (skosimp :preds? t)
              (("1" (expand"intersection" "member")
                (("1" (flatten)
                  (("1" (inst - "x1!1" "x2!1") (("1" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (grind) nil nil))
          nil))
        nil))
      nil))
    nil)
   ((intersection const-decl "set" sets nil)
    (Count!1 skolem-const-decl "countable_set[T]" countable_props nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (f!1 skolem-const-decl "(injective?[(Count!1), nat])"
     countable_props nil)
    (member const-decl "bool" sets nil)
    (injective? const-decl "bool" functions nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (countable_intersection2 0
  (countable_intersection2-1 nil 3316998965
   ("" (skolem!)
    (("" (rewrite "intersection_commutative[T]")
      (("" (assertnil nil)) nil))
    nil)
   ((intersection_commutative formula-decl nil sets_lemmas nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_countable const-decl "bool" countability nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (T formal-type-decl nil countable_props nil)
    (countable_intersection1 application-judgement "countable_set[T]"
     countable_props nil))
   nil))
 (countably_infinite_difference 0
  (countably_infinite_difference-1 nil 3316998965
   (""
    (case "forall (n:nat,CountInf, Fin):card(Fin) <= n =>
        is_countably_infinite[T](difference[T](CountInf, Fin))")
    (("1" (skosimp)
      (("1" (inst - "card(Fin!1)" "CountInf!1" "Fin!1")
        (("1" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "n")
        (("1" (skosimp)
          (("1" (expand "<=")
            (("1" (split)
              (("1" (assertnil nil)
               ("2" (lemma "card_is_0[T]" ("S" "Fin!1"))
                (("2" (replace -2)
                  (("2" (replace -1)
                    (("2" (rewrite "difference_emptyset1[T]")
                      (("2" (typepred "CountInf!1")
                        (("2" (propax) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp*)
          (("2" (expand "<=" -2)
            (("2" (split -2)
              (("1" (inst - "CountInf!1" "Fin!1")
                (("1" (assertnil nil)) nil)
               ("2" (lemma "nonempty_card[T]" ("S" "Fin!1"))
                (("2" (assert)
                  (("2" (lemma "card_rest[T]" ("S" "Fin!1"))
                    (("2" (split -1)
                      (("1" (replace -3)
                        (("1" (assert)
                          (("1"
                            (inst -
                             "remove(choose[T](Fin!1),CountInf!1)"
                             "rest(Fin!1)")
                            (("1" (assert)
                              (("1"
                                (case-replace
                                 "(difference[T](remove(choose[T](Fin!1), CountInf!1), rest(Fin!1)))=(difference[T](CountInf!1, Fin!1))")
                                (("1"
                                  (hide -1 -3 -4 2)
                                  (("1"
                                    (apply-extensionality :hide? t)
                                    (("1"
                                      (expand "difference")
                                      (("1"
                                        (expand "rest")
                                        (("1"
                                          (expand "nonempty?")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (expand "member")
                                              (("1"
                                                (expand "remove")
                                                (("1"
                                                  (expand "member")
                                                  (("1"
                                                    (case-replace
                                                     "CountInf!1(x!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case-replace
                                                         "Fin!1(x!1)")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "nonempty?")
                        (("2" (propax) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_rest application-judgement "finite_set[T]" countable_props
     nil)
    (member const-decl "bool" sets nil)
    (finite_remove application-judgement "finite_set[T]"
     countable_props nil)
    (remove const-decl "set" sets nil)
    (nonempty? const-decl "bool" sets nil)
    (choose const-decl "(p)" sets nil) (rest const-decl "set" sets nil)
    (countable_remove application-judgement "countable_set[T]"
     countable_props nil)
    (countably_infinite_remove application-judgement
     "countably_infinite_set[T]" countable_props nil)
    (card_rest formula-decl nil finite_sets nil)
    (nonempty_card formula-decl nil finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (difference_emptyset1 formula-decl nil sets_lemmas nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (card_is_0 formula-decl nil finite_sets nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (infinite_difference application-judgement "infinite_set[T]"
     countable_props 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)
    (T formal-type-decl nil countable_props nil)
    (set type-eq-decl nil sets nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (difference const-decl "set" sets nil))
   nil))
 (countable_difference 0
  (countable_difference-1 nil 3316998965
   ("" (grind :if-match nil)
    (("" (inst + "LAMBDA (x: (difference[T](Count!1, S!1))): f!1(x)")
      (("1" (grind) nil nil) ("2" (grind) nil nil)) nil))
    nil)
   ((difference const-decl "set" sets nil)
    (Count!1 skolem-const-decl "countable_set[T]" countable_props nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (f!1 skolem-const-decl "(injective?[(Count!1), nat])"
     countable_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (member const-decl "bool" sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (injective? const-decl "bool" functions nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (T formal-type-decl nil countable_props nil))
   nil))
 (finite_countable 0
  (finite_countable-1 nil 3316998965 ("" (judgement-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)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets 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)
    (x!1 skolem-const-decl "finite_set[T]" countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (N!1 skolem-const-decl "nat" countable_props nil)
    (f!1 skolem-const-decl "[(x!1) -> below[N!1]]" countable_props nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (T formal-type-decl nil countable_props nil)
    (is_countable const-decl "bool" countability nil)
    (injective? const-decl "bool" functions nil))
   nil))
 (infinite_uncountable 0
  (infinite_uncountable-1 nil 3316998965 ("" (judgement-tcc) nil nil)
   ((T formal-type-decl nil countable_props nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_countable const-decl "bool" countability nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (uncountable_set type-eq-decl nil countability 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)
    (x!1 skolem-const-decl "uncountable_set[T]" countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (N!1 skolem-const-decl "nat" countable_props nil)
    (f!1 skolem-const-decl "[(x!1) -> below[N!1]]" countable_props nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (is_finite const-decl "bool" finite_sets nil)
    (injective? const-decl "bool" functions nil))
   nil))
 (countably_infinite_subset_exists 0
  (countably_infinite_subset_exists-1 nil 3317000413
   ("" (skolem + "X!1")
    (("" (typepred "X!1")
      (("" (lemma "infinite_def" ("X" "X!1"))
        (("" (replace 1)
          (("" (flatten)
            (("" (skosimp)
              (("" (typepred "f!1")
                ((""
                  (lemma "bijective_image[nat, (X!1)]" ("inj" "f!1"))
                  ((""
                    (lemma
                     "bij_inv_is_bij[nat, ((image(f!1, fullset[nat])))]"
                     ("f" "f!1"))
                    (("" (assert)
                      ((""
                        (inst + "image[nat,(X!1)](f!1, fullset[nat])")
                        (("1" (expand "subset?")
                          (("1" (expand "member")
                            (("1" (expand "extend")
                              (("1"
                                (hide-all-but 2)
                                (("1"
                                  (skosimp)
                                  (("1" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "extend")
                          (("2" (expand "is_countably_infinite")
                            (("2"
                              (inst +
                               "inverse[nat, ((image[nat, (X!1)](f!1, fullset[nat])))](f!1)")
                              (("2"
                                (split)
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (lift-if 1)
                                    (("1" (assertnil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide-all-but (-1 1))
                                  (("2"
                                    (expand "bijective?")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (split)
                                        (("1"
                                          (expand "injective?")
                                          (("1"
                                            (skosimp)
                                            (("1"
                                              (inst -2 "x1!1" "x2!1")
                                              (("1" (assertnil nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand "surjective?")
                                          (("2"
                                            (skosimp)
                                            (("2"
                                              (inst - "y!1")
                                              (("2"
                                                (skosimp)
                                                (("2"
                                                  (inst + "x!1")
                                                  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)
   ((infinite_set type-eq-decl nil infinite_sets_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil countable_props nil)
    (bijective_image formula-decl nil function_image_aux nil)
    (inverse const-decl "D" function_inverse nil)
    (bijective? const-decl "bool" functions nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (surjective? const-decl "bool" functions nil)
    (subset? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (X!1 skolem-const-decl "infinite_set[T]" countable_props nil)
    (FALSE const-decl "bool" booleans nil)
    (extend const-decl "R" extend nil)
    (f!1 skolem-const-decl "(injective?[nat, (X!1)])" countable_props
     nil)
    (bij_inv_is_bij formula-decl nil function_inverse nil)
    (image const-decl "set[R]" function_image nil)
    (fullset const-decl "set" sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (injective? const-decl "bool" functions nil)
    (infinite_def formula-decl nil infinite_nat_def nil))
   shostak))
 (countably_infinite_strict_subset_exists 0
  (countably_infinite_strict_subset_exists-1 nil 3317000591
   ("" (skolem!)
    (("" (use "countably_infinite_subset_exists")
      (("" (skolem-typepred)
        (("" (use "infinite_nonempty[T]")
          (("" (expand"nonempty?" "empty?" "member")
            (("" (skolem!)
              (("" (inst + "remove(x!1, CountInf!1)")
                (("1" (expand"strict_subset?" "subset?" "member")
                  (("1" (split)
                    (("1" (expand"remove" "member")
                      (("1" (skosimp)
                        (("1" (inst - "x!2") (("1" (assertnil nil))
                          nil))
                        nil))
                      nil)
                     ("2" (decompose-equality)
                      (("2" (expand"remove" "member")
                        (("2" (inst - "x!1")
                          (("2" (inst - "x!1") (("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2"
                  (lemma "countably_infinite_subset[T]"
                   ("CountInf" "CountInf!1" "Inf"
                    "remove(x!1, CountInf!1)"))
                  (("2" (assert)
                    (("2" (expand"subset?" "remove" "member")
                      (("2" (skosimp) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((countably_infinite_subset_exists formula-decl nil countable_props
     nil)
    (infinite_set type-eq-decl nil infinite_sets_def nil)
    (is_finite const-decl "bool" finite_sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil countable_props nil)
    (infinite_nonempty judgement-tcc nil infinite_sets_def nil)
    (subset? const-decl "bool" sets nil)
    (strict_subset? const-decl "bool" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (remove const-decl "set" sets nil)
    (countable_remove application-judgement "countable_set[T]"
     countable_props nil)
    (countably_infinite_remove application-judgement
     "countably_infinite_set[T]" countable_props nil)
    (nonempty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil))
   shostak))
 (countable_card 0
  (countable_card-1 nil 3317002096
   ("" (skosimp)
    (("" (split)
      (("1" (flatten)
        (("1" (expand "is_countable")
          (("1" (skosimp)
            (("1" (typepred "f!1")
              (("1" (expand "is_countably_infinite")
                (("1"
                  (case "is_finite[nat](image(f!1, fullset[(S!1)]))")
                  (("1" (assert)
                    (("1" (hide 2 3)
                      (("1" (expand "fullset")
                        (("1" (expand "is_finite")
                          (("1" (skosimp)
                            (("1" (inst + "N!1" "f!2 o f!1")
                              (("1"
                                (expand "injective?")
                                (("1"
                                  (expand "o ")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (typepred "x1!1")
                                      (("1"
                                        (typepred "x2!1")
                                        (("1"
                                          (inst -4 "x1!1" "x2!1")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst
                                               -
                                               "f!1(x1!1)"
                                               "f!1(x2!1)")
                                              (("1" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp)
                                (("2"
                                  (expand "image")
                                  (("2"
                                    (typepred "x1!1")
                                    (("2" (inst + "x1!1"nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (case "nonempty?(S!1)")
                    (("1"
                      (lemma "bijective_image[(S!1), nat]"
                       ("inj" "f!1"))
                      (("1"
                        (case "exists (phi:(bijective?[nat,(image(f!1, fullset[(S!1)]))])):TRUE")
                        (("1" (skosimp)
                          (("1" (typepred "phi!1")
                            (("1"
                              (lemma
                               "bijective_inverse_exists[nat, (image(f!1, fullset[(S!1)]))]"
                               ("f" "phi!1"))
                              (("1"
                                (expand "exists1")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (skolem - "psi!1")
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (lemma
                                         "bij_inv_is_bij_alt[nat, (image(f!1, fullset[(S!1)]))]"
                                         ("f" "phi!1" "g" "psi!1"))
                                        (("1"
                                          (inst + "psi!1 o f!1")
                                          (("1"
                                            (hide-all-but (-1 -4 1))
                                            (("1"
                                              (expand "bijective?")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (split)
                                                  (("1"
                                                    (expand "o")
                                                    (("1"
                                                      (expand
                                                       "injective?")
                                                      (("1"
                                                        (skosimp)
                                                        (("1"
                                                          (inst
                                                           -4
                                                           "x1!1"
                                                           "x2!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "f!1(x1!1)"
                                                               "f!1(x2!1)")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (expand "o")
                                                    (("2"
                                                      (expand
                                                       "surjective?")
                                                      (("2"
                                                        (skosimp)
                                                        (("2"
                                                          (inst
                                                           -2
                                                           "y!1")
                                                          (("2"
                                                            (skosimp)
                                                            (("2"
                                                              (typepred
                                                               "x!1")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "x!1")
                                                                (("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (inst
                                                                     +
                                                                     "x!2")
                                                                    (("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)
                         ("2" (hide -1 4)
                          (("2"
                            (name "REMOVE_MIN"
                                  "lambda (X:infinite_set[nat]): remove(min(X),X)")
                            (("2"
                              (case "forall (X: infinite_set[nat]): strict_subset?(REMOVE_MIN(X),X)")
                              (("1"
                                (name
                                 "GG"
                                 "lambda (n:nat): iterate(REMOVE_MIN,n)(image[(S!1), nat](f!1, fullset[(S!1)]))")
                                (("1"
                                  (case
                                   "FORALL (X: infinite_set[nat]): min[nat](X)<min[nat](REMOVE_MIN(X))")
                                  (("1"
                                    (name
                                     "FF"
                                     "lambda (n:nat): min[nat](GG(n))")
                                    (("1"
                                      (case
                                       "forall (n:nat): subset?(GG(n),image(f!1, fullset[(S!1)]))")
                                      (("1"
                                        (case
                                         "forall (n:nat): image(f!1, fullset[(S!1)])(FF(n))")
                                        (("1"
                                          (case
                                           "forall (i,j:nat): i<j => FF(i)<FF(j)")
                                          (("1"
                                            (case
                                             "forall (n:nat): n <= FF(n)")
                                            (("1"
                                              (case
                                               "forall (n:(image(f!1, fullset[(S!1)]))): exists (k:nat): FF(k)=n")
                                              (("1"
                                                (inst + "FF")
                                                (("1"
                                                  (split)
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (expand
                                                     "bijective?")
                                                    (("2"
                                                      (split)
                                                      (("1"
                                                        (expand
                                                         "injective?")
                                                        (("1"
                                                          (skolem
                                                           +
                                                           ("i!1"
                                                            "j!1"))
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (lemma
                                                               "trich_lt"
                                                               ("x"
                                                                "i!1"
                                                                "y"
                                                                "j!1"))
                                                              (("1"
                                                                (split)
                                                                (("1"
                                                                  (inst
                                                                   -5
                                                                   "i!1"
                                                                   "j!1")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (propax)
                                                                  nil
                                                                  nil)
                                                                 ("3"
                                                                  (inst
                                                                   -5
                                                                   "j!1"
                                                                   "i!1")
                                                                  (("3"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (expand
                                                         "surjective?")
                                                        (("2"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (case
                                                   "forall (i,n,k:nat): image(f!1, fullset[(S!1)])(k) & FF(i)<=k & k<=FF(i+n) => exists (j:nat): FF(j) = k")
                                                  (("1"
                                                    (skosimp)
                                                    (("1"
                                                      (inst-cp
                                                       -2
                                                       "n!1")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "0"
                                                         "FF(n!1)"
                                                         "n!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (split -1)
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (hide-all-but
                                                               (1 3))
                                                              (("2"
                                                                (expand
                                                                 "FF")
                                                                (("2"
                                                                  (expand
                                                                   "GG")
                                                                  (("2"
                                                                    (expand
                                                                     "REMOVE_MIN")
                                                                    (("2"
                                                                      (expand
                                                                       "iterate")
                                                                      (("2"
                                                                        (typepred
                                                                         "n!1")
                                                                        (("2"
                                                                          (typepred
                                                                           "min[nat](image[(S!1), nat](f!1, fullset[(S!1)]))")
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "n!1")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (expand
                                                               "<="
                                                               -2)
                                                              (("3"
                                                                (split)
                                                                (("1"
                                                                  (inst
                                                                   -3
                                                                   "n!1"
                                                                   "FF(n!1)")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (replace
                                                                   -1
                                                                   *
                                                                   rl)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (induct "n")
                                                      (("1"
                                                        (skosimp)
                                                        (("1"
                                                          (inst
                                                           +
                                                           "i!1")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (expand
                                                           "<="
                                                           -3)
                                                          (("2"
                                                            (split)
                                                            (("1"
                                                              (inst
                                                               -2
                                                               "i!1+1"
                                                               "k!1")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (split
                                                                   -2)
                                                                  (("1"
                                                                    (propax)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2
                                                                     4)
                                                                    (("2"
                                                                      (case
                                                                       "k!1<FF(1 + i!1)")
                                                                      (("1"
                                                                        (hide
                                                                         1)
                                                                        (("1"
                                                                          (expand
                                                                           "FF")
                                                                          (("1"
                                                                            (hide
                                                                             -5
                                                                             -4
                                                                             -9
                                                                             -11
                                                                             -15)
                                                                            (("1"
                                                                              (typepred
                                                                               "min[nat](GG(1 + i!1))")
                                                                              (("1"
                                                                                (inst
                                                                                 -2
                                                                                 "k!1")
                                                                                (("1"
                                                                                  (split
                                                                                   -2)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil)
                                                                                   ("2"
                                                                                    (case
                                                                                     "forall (n:nat): min[nat](GG(n)) < k!1 => GG(n+1)(k!1)")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "i!1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       2
                                                                                       -1
                                                                                       -2
                                                                                       -3)
                                                                                      (("2"
                                                                                        (induct
                                                                                         "n")
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "0"
                                                                                             "1")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "GG")
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "iterate")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "REMOVE_MIN")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "iterate")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "remove")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "member")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (skosimp*)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (inst-cp
                                                                                               -
                                                                                               "j!2"
                                                                                               "1+j!2")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "GG")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "iterate"
                                                                                                       1)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "REMOVE_MIN"
                                                                                                         1
                                                                                                         1)
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "remove"
                                                                                                           1)
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "member")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (inst
                                                               +
                                                               "i!1")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide-all-but (-1 1))
                                              (("2"
                                                (induct "n")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (skosimp)
                                                  (("2"
                                                    (inst
                                                     -
                                                     "j!1"
                                                     "j!1+1")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide-all-but (-4 1))
                                            (("2"
                                              (case
                                               "forall (i,n:nat): FF(i)< FF(i+1+n)")
                                              (("1"
                                                (skosimp)
                                                (("1"
                                                  (inst
                                                   -
                                                   "i!1"
                                                   "j!1-i!1-1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (induct "n")
                                                  (("1"
                                                    (skosimp)
                                                    (("1"
                                                      (expand "FF")
                                                      (("1"
                                                        (expand "GG")
                                                        (("1"
                                                          (expand
                                                           "iterate"
                                                           1
                                                           2)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "iterate(REMOVE_MIN, i!1)
                  (image[(S!1), nat](f!1, fullset[(S!1)]))")
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp)
                                                    (("2"
                                                      (skosimp)
                                                      (("2"
                                                        (inst - "i!1")
                                                        (("2"
                                                          (name-replace
                                                           "LHS"
                                                           "FF(i!1)")
                                                          (("2"
                                                            (expand
                                                             "FF")
                                                            (("2"
                                                              (expand
                                                               "GG")
                                                              (("2"
                                                                (expand
                                                                 "iterate"
                                                                 1)
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "iterate(REMOVE_MIN, 1 + i!1 + j!1)
                   (image[(S!1), nat](f!1, fullset[(S!1)]))")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide-all-but (-1 1))
                                          (("2"
                                            (skosimp)
                                            (("2"
                                              (expand "FF")
                                              (("2"
                                                (typepred
                                                 "min[nat](GG(n!1))")
                                                (("2"
                                                  (inst -3 "n!1")
                                                  (("2"
                                                    (expand "subset?")
                                                    (("2"
                                                      (inst
                                                       -3
                                                       "min[nat](GG(n!1))")
                                                      (("2"
                                                        (expand
                                                         "member")
                                                        (("2"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide-all-but (-4 1))
                                        (("2"
                                          (induct "n")
                                          (("1"
                                            (expand "GG")
                                            (("1"
                                              (expand "iterate")
                                              (("1"
                                                (expand "subset?")
                                                (("1"
                                                  (skosimp)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp)
                                            (("2"
                                              (expand "strict_subset?")
                                              (("2"
                                                (expand "GG")
                                                (("2"
                                                  (expand "iterate" 1)
                                                  (("2"
                                                    (inst
                                                     -
                                                     "iterate(REMOVE_MIN, j!1)
                                (image[(S!1), nat](f!1, fullset[(S!1)]))")
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (hide 2)
                                                        (("2"
                                                          (expand
                                                           "subset?")
                                                          (("2"
                                                            (skosimp)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "x!1")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "x!1")
                                                                (("2"
                                                                  (expand
                                                                   "member")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (skosimp)
                                    (("2"
                                      (hide-all-but (-2 1))
                                      (("2"
                                        (typepred "min[nat](X!1)")
                                        (("2"
                                          (expand "REMOVE_MIN")
                                          (("2"
                                            (typepred
                                             "min[nat](remove(min(X!1), X!1))")
                                            (("2"
                                              (expand "remove" -1 1)
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (expand "member")
                                                  (("2"
                                                    (inst
                                                     -4
                                                     "min[nat](remove(min(X!1), X!1))")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (propax) nil nil))
                                nil)
                               ("2"
                                (hide-all-but 1)
                                (("2"
                                  (skosimp)
                                  (("2"
                                    (expand "REMOVE_MIN")
                                    (("2"
                                      (expand "strict_subset?")
                                      (("2"
                                        (typepred "min(X!1)")
                                        (("2"
                                          (expand "remove")
                                          (("2"
                                            (expand "member")
                                            (("2"
                                              (split)
                                              (("1"
                                                (expand "subset?")
                                                (("1"
                                                  (skolem + ("n!1"))
                                                  (("1"
                                                    (expand "member")
                                                    (("1"
                                                      (typepred "n!1")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (case-replace
                                                           "min(X!1)=n!1")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            (("2"
                                                              (flatten)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "/=" 1)
                                                (("2"
                                                  (replace -1 -2 rl)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "nonempty?")
                      (("2" (lemma "infinite_nonempty[T]")
                        (("2" (inst - "S!1")
                          (("2" (expand "nonempty?")
                            (("2" (propax) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (flatten)
        (("2" (split)
          (("1" (expand "is_countable")
            (("1" (expand "is_finite")
              (("1" (skosimp)
                (("1" (inst + "f!1")
                  (("1" (expand "injective?") (("1" (propax) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "is_countably_infinite")
            (("2" (expand "is_countable")
              (("2" (skosimp)
                (("2" (typepred "f!1") (("2" (inst + "f!1"nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((is_countable const-decl "bool" countability nil)
    (injective? const-decl "bool" functions nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (fullset const-decl "set" sets nil)
    (image const-decl "set[R]" function_image nil)
    (is_finite const-decl "bool" finite_sets nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (f!1 skolem-const-decl "(injective?[(S!1), nat])" countable_props
     nil)
    (TRUE const-decl "bool" booleans nil)
    (O const-decl "T3" function_props nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (infinite_nonempty judgement-tcc nil infinite_sets_def nil)
    (bijective_image formula-decl nil function_image_aux nil)
    (strict_subset? const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil)
    (trich_lt formula-decl nil real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (FF skolem-const-decl
     "[n: nat -> {a | GG(n)(a) AND (FORALL (x: nat): GG(n)(x) IMPLIES a <= x)}]"
     countable_props nil)
    (GG skolem-const-decl "[nat -> infinite_set[nat]]" countable_props
     nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers 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)
    (REMOVE_MIN skolem-const-decl
     "[infinite_set[nat] -> infinite_set[nat]]" countable_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers 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)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (member const-decl "bool" sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (i!1 skolem-const-decl "nat" countable_props nil)
    (j!1 skolem-const-decl "nat" countable_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (iterate def-decl "T" function_iterate nil)
    (/= const-decl "boolean" notequal nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (remove const-decl "set" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (infinite_set type-eq-decl nil infinite_sets_def nil)
    (infinite_remove application-judgement "infinite_set[nat]"
     countability nil)
    (bijective_inverse_exists formula-decl nil function_inverse_def
     nil)
    (psi!1 skolem-const-decl "[(image(f!1, fullset[(S!1)])) -> nat]"
     countable_props nil)
    (surjective? const-decl "bool" functions nil)
    (inverse? const-decl "bool" function_inverse_def nil)
    (bij_inv_is_bij_alt formula-decl nil function_inverse_def nil)
    (exists1 const-decl "bool" exists1 nil)
    (bijective? const-decl "bool" functions nil)
    (nonempty? const-decl "bool" sets nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (f!1 skolem-const-decl "[(S!1) -> below[N!1]]" countable_props nil)
    (N!1 skolem-const-decl "nat" countable_props nil))
   shostak))
 (countably_infinite_union1 0
  (countably_infinite_union1-1 nil 3316998965
   ("" (skolem + ("X!1" "Y!1"))
    (("" (typepred "X!1")
      (("" (typepred "Y!1")
        (("" (name "DD" "difference(X!1,Y!1)")
          (("" (lemma "countable_difference" ("Count" "X!1" "S" "Y!1"))
            (("" (replace -2)
              (("" (lemma "union_difference" ("a" "Y!1" "b" "X!1"))
                (("" (replace -1)
                  (("" (replace -3)
                    ((""
                      (lemma "difference_disjoint"
                       ("a" "Y!1" "b" "X!1"))
                      (("" (replace -4)
                        (("" (hide -2 -4 -6)
                          (("" (rewrite "countable_card")
                            (("" (split)
                              (("1"
                                (name "N" "card(DD)")
                                (("1"
                                  (lemma
                                   "card_bij[T]"
                                   ("N" "N" "S" "DD"))
                                  (("1"
                                    (assert)
                                    (("1"
                                      (skosimp)
                                      (("1"
                                        (expand
                                         "is_countably_infinite")
                                        (("1"
                                          (skosimp)
                                          (("1"
                                            (typepred "f!2")
                                            (("1"
                                              (inst
                                               +
                                               "lambda (x:(union(Y!1, DD))): if DD(x) then f!1(x) else N+f!2(x) endif")
                                              (("1"
                                                (expand "bijective?")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (split)
                                                    (("1"
                                                      (hide -2 -4)
                                                      (("1"
                                                        (expand
                                                         "injective?")
                                                        (("1"
                                                          (skosimp)
                                                          (("1"
                                                            (typepred
                                                             "x1!1")
                                                            (("1"
                                                              (typepred
                                                               "x2!1")
                                                              (("1"
                                                                (expand
                                                                 "union")
                                                                (("1"
                                                                  (expand
                                                                   "member")
                                                                  (("1"
                                                                    (split)
                                                                    (("1"
                                                                      (split)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "disjoint?")
                                                                          (("1"
                                                                            (expand
                                                                             "intersection")
                                                                            (("1"
                                                                              (expand
                                                                               "empty?")
                                                                              (("1"
                                                                                (expand
                                                                                 "member")
                                                                                (("1"
                                                                                  (inst-cp
                                                                                   -8
                                                                                   "x1!1")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -8
                                                                                     "x2!1")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (inst
                                                                                           -4
                                                                                           "x1!1"
                                                                                           "x2!1")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (expand
                                                                           "disjoint?")
                                                                          (("2"
                                                                            (expand
                                                                             "intersection")
                                                                            (("2"
                                                                              (expand
                                                                               "empty?")
                                                                              (("2"
                                                                                (expand
                                                                                 "member")
                                                                                (("2"
                                                                                  (inst-cp
                                                                                   -8
                                                                                   "x1!1")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -8
                                                                                     "x2!1")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (split)
                                                                      (("1"
                                                                        (expand
                                                                         "disjoint?")
                                                                        (("1"
                                                                          (expand
                                                                           "intersection")
                                                                          (("1"
                                                                            (expand
                                                                             "empty?")
                                                                            (("1"
                                                                              (expand
                                                                               "member")
                                                                              (("1"
                                                                                (inst-cp
                                                                                 -8
                                                                                 "x1!1")
                                                                                (("1"
                                                                                  (inst
                                                                                   -8
                                                                                   "x2!1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (inst
                                                                           -5
                                                                           "x1!1"
                                                                           "x2!1")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide -1 -3)
                                                      (("2"
                                                        (expand
                                                         "surjective?")
                                                        (("2"
                                                          (skosimp)
                                                          (("2"
                                                            (case
                                                             "y!1>=N")
                                                            (("1"
                                                              (inst
                                                               -2
                                                               "y!1-N")
                                                              (("1"
                                                                (skosimp)
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "x!1")
                                                                  (("1"
                                                                    (typepred
                                                                     "x!1")
                                                                    (("1"
                                                                      (expand
                                                                       "disjoint?")
                                                                      (("1"
                                                                        (expand
                                                                         "intersection")
                                                                        (("1"
                                                                          (expand
                                                                           "empty?")
                                                                          (("1"
                                                                            (expand
                                                                             "member")
                                                                            (("1"
                                                                              (inst
                                                                               -7
                                                                               "x!1")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "union")
                                                                    (("2"
                                                                      (expand
                                                                       "member")
                                                                      (("2"
                                                                        (propax)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (inst
                                                               -2
                                                               "y!1")
                                                              (("1"
                                                                (skosimp)
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "x!1")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "union")
                                                                    (("2"
                                                                      (expand
                                                                       "member")
                                                                      (("2"
                                                                        (propax)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (skosimp)
                                                (("2"
                                                  (typepred "x!1")
                                                  (("2"
                                                    (expand "union")
                                                    (("2"
                                                      (expand "member")
                                                      (("2"
                                                        (split)
                                                        (("1"
                                                          (propax)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (propax) nil nil))
                                nil)
                               ("2"
                                (expand "disjoint?")
                                (("2"
                                  (expand "intersection")
                                  (("2"
                                    (expand "empty?")
                                    (("2"
                                      (expand "member")
                                      (("2"
                                        (expand
                                         "is_countably_infinite")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (typepred "f!1")
                                            (("2"
                                              (typepred "f!2")
                                              (("2"
                                                (inst
                                                 +
                                                 "lambda (x:(union(Y!1, DD))): if DD(x) then 2*f!1(x) else 2*f!2(x)+1 endif")
                                                (("1"
                                                  (expand "bijective?")
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (split)
                                                      (("1"
                                                        (hide -2 -4)
                                                        (("1"
                                                          (expand
                                                           "injective?")
                                                          (("1"
                                                            (skosimp)
                                                            (("1"
                                                              (typepred
                                                               "x1!1")
                                                              (("1"
                                                                (typepred
                                                                 "x2!1")
                                                                (("1"
                                                                  (expand
                                                                   "union")
                                                                  (("1"
                                                                    (expand
                                                                     "member")
                                                                    (("1"
                                                                      (split)
                                                                      (("1"
                                                                        (split)
                                                                        (("1"
                                                                          (inst
                                                                           -4
                                                                           "x1!1"
                                                                           "x2!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (inst-cp
                                                                               -5
                                                                               "x1!1")
                                                                              (("1"
                                                                                (inst
                                                                                 -5
                                                                                 "x2!1")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             -6
                                                                             "x2!1")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (split)
                                                                        (("1"
                                                                          (inst
                                                                           -6
                                                                           "x1!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             -5
                                                                             "x1!1"
                                                                             "x2!1")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide -1 -3)
                                                        (("2"
                                                          (expand
                                                           "surjective?")
                                                          (("2"
                                                            (skosimp)
                                                            (("2"
                                                              (case
                                                               "even?(y!1)")
                                                              (("1"
                                                                (expand
                                                                 "even?")
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (inst
                                                                       -3
                                                                       "j!1")
                                                                      (("1"
                                                                        (skosimp)
                                                                        (("1"
                                                                          (inst
                                                                           +
                                                                           "x!1")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (expand
                                                                             "union")
                                                                            (("2"
                                                                              (expand
                                                                               "member")
                                                                              (("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (rewrite
                                                                 "even_or_odd")
                                                                (("2"
                                                                  (expand
                                                                   "odd?")
                                                                  (("2"
                                                                    (skosimp)
                                                                    (("2"
                                                                      (replace
                                                                       -1)
                                                                      (("2"
                                                                        (inst
                                                                         -2
                                                                         "j!1")
                                                                        (("1"
                                                                          (skosimp)
                                                                          (("1"
                                                                            (inst
                                                                             +
                                                                             "x!1")
                                                                            (("1"
                                                                              (inst
                                                                               -4
                                                                               "x!1")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "union")
                                                                              (("2"
                                                                                (expand
                                                                                 "member")
                                                                                (("2"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (skosimp)
                                                  (("2"
                                                    (typepred "x!1")
                                                    (("2"
                                                      (expand "union")
                                                      (("2"
                                                        (expand
                                                         "member")
                                                        (("2"
                                                          (split)
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (propax)
                                                            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)
   ((countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (difference const-decl "set" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (countable_difference application-judgement "countable_set[T]"
     countable_props nil)
    (difference_disjoint formula-decl nil sets_lemmas nil)
    (card_bij formula-decl nil finite_sets nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (union const-decl "set" sets nil)
    (Y!1 skolem-const-decl "countably_infinite_set" countable_props
     nil)
    (DD skolem-const-decl "countable_set[T]" countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (f!2 skolem-const-decl "(bijective?[(Y!1), nat])" countable_props
     nil)
    (f!1 skolem-const-decl "[(DD) -> below[N]]" countable_props nil)
    (N skolem-const-decl "{n: nat | n = Card(DD)}" countable_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (x!1 skolem-const-decl "(DD)" countable_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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (y!1 skolem-const-decl "nat" countable_props nil)
    (x!1 skolem-const-decl "(Y!1)" countable_props nil)
    (surjective? const-decl "bool" functions nil)
    (member const-decl "bool" sets nil)
    (disjoint? const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (intersection const-decl "set" sets nil)
    (injective? const-decl "bool" functions nil)
    (bijective? const-decl "bool" functions nil)
    (infinite_union_left application-judgement "infinite_set[T]"
     countable_props nil)
    (number nonempty-type-decl nil numbers nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (x1!1 skolem-const-decl "(union(Y!1, DD))" countable_props nil)
    (x2!1 skolem-const-decl "(union(Y!1, DD))" countable_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (even? const-decl "bool" integers nil)
    (j!1 skolem-const-decl "int" countable_props nil)
    (x!1 skolem-const-decl "(DD)" countable_props nil)
    (odd? const-decl "bool" integers nil)
    (x!1 skolem-const-decl "(Y!1)" countable_props nil)
    (j!1 skolem-const-decl "int" countable_props nil)
    (even_or_odd formula-decl nil naturalnumbers nil)
    (f!2 skolem-const-decl "(bijective?[(Y!1), nat])" countable_props
     nil)
    (f!1 skolem-const-decl "(bijective?[(DD), nat])" countable_props
     nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (countable_card formula-decl nil countable_props nil)
    (union_difference formula-decl nil sets_lemmas nil)
    (countable_difference judgement-tcc nil countable_props nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil))
   nil))
 (countably_infinite_union2 0
  (countably_infinite_union2-1 nil 3316998965
   ("" (skolem!)
    (("" (rewrite "union_commutative[T]") (("" (assertnil nil)) nil))
    nil)
   ((union_commutative formula-decl nil sets_lemmas nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_countable const-decl "bool" countability nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (T formal-type-decl nil countable_props nil)
    (countably_infinite_union1 application-judgement
     "countably_infinite_set[T]" countable_props nil))
   nil))
 (countable_union 0
  (countable_union-1 nil 3316998965
   ("" (skolem-typepred)
    (("" (auto-rewrite "countable_card")
      (("" (smash)
        (("1" (use "finite_union[T]"nil nil)
         ("2" (use "countably_infinite_union2"nil nil)
         ("3" (use "countably_infinite_union1"nil nil)
         ("4" (use "countably_infinite_union1"nil nil))
        nil))
      nil))
    nil)
   ((countably_infinite_union1 judgement-tcc nil countable_props nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (countably_infinite_union2 judgement-tcc nil countable_props nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (finite_union judgement-tcc nil finite_sets nil)
    (countable_card formula-decl nil countable_props nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (countably_infinite_def 0
  (countably_infinite_def-1 nil 3454922909
   ("" (skosimp)
    (("" (split)
      (("1" (flatten)
        (("1" (lemma "countable_card" ("S" "S!1"))
          (("1" (replace -1 1)
            (("1" (hide -1)
              (("1" (case-replace "is_finite(S!1)")
                (("1" (lemma "infinite_countably_infinite")
                  (("1" (inst - "S!1"nil nil)) nil)
                 ("2" (assertnil nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (flatten)
        (("2" (lemma "countable_card" ("S" "S!1"))
          (("2" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil countable_props nil)
    (countable_card formula-decl nil countable_props nil)
    (infinite_countably_infinite judgement-tcc nil countable_props nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (is_finite const-decl "bool" finite_sets nil))
   shostak))
 (countable_emptyset 0
  (countable_emptyset-1 nil 3454937862
   ("" (lemma "finite_countable") (("" (inst - "emptyset[T]"nil nil))
    nil)
   ((finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set" countable_props nil)
    (T formal-type-decl nil countable_props nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (emptyset const-decl "set" sets nil)
    (finite_countable judgement-tcc nil countable_props nil))
   shostak))
 (countable_singleton 0
  (countable_singleton-1 nil 3454937897
   ("" (skosimp)
    (("" (lemma "finite_countable")
      (("" (inst - "singleton(t!1)"nil nil)) nil))
    nil)
   ((finite_countable judgement-tcc nil countable_props nil)
    (singleton const-decl "(singleton?)" sets nil)
    (singleton? const-decl "bool" sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil countable_props nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set" countable_props nil))
   shostak))
 (card_le_finite 0
  (card_le_finite-1 nil 3462010233
   ("" (grind :if-match nil)
    (("" (inst + "N!1" "f!2 o f!1")
      (("" (expand "o")
        (("" (skosimp)
          (("" (inst - "f!1(x1!1)" "f!1(x2!1)")
            (("" (inst - "x1!1" "x2!1") (("" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((O const-decl "T3" function_props nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props 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)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (card_le const-decl "bool" card_comp_set nil)
    (T formal-type-decl nil countable_props nil)
    (injective? const-decl "bool" functions nil))
   nil))
 (card_ge_infinite 0
  (card_ge_infinite-1 nil 3462010266
   ("" (grind :if-match nil)
    (("" (inst + "N!1" "f!2 o f!1")
      (("" (skosimp)
        (("" (expand "o")
          (("" (inst - "x1!1" "x2!1")
            (("" (inst - "f!1(x1!1)" "f!1(x2!1)")
              (("" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (O const-decl "T3" function_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props 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)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (infinite_set type-eq-decl nil infinite_sets_def nil)
    (is_finite const-decl "bool" finite_sets nil)
    (card_ge const-decl "bool" card_comp_set nil)
    (T formal-type-decl nil countable_props nil)
    (injective? const-decl "bool" functions nil))
   nil))
 (card_eq_countably_infinite 0
  (card_eq_countably_infinite-1 nil 3462010285
   ("" (skosimp :preds? t)
    (("" (expand"is_countably_infinite" "card_eq")
      (("" (skosimp* t)
        (("" (use "composition_bijective[(S!1), (CountInf!1), nat]")
          (("" (inst + "f!1 o f!2"nil nil)) nil))
        nil))
      nil))
    nil)
   ((card_eq const-decl "bool" card_comp_set nil)
    (composition_bijective judgement-tcc nil function_props nil)
    (f!2 skolem-const-decl "[(S!1) -> (CountInf!1)]" countable_props
     nil)
    (CountInf!1 skolem-const-decl "countably_infinite_set"
     countable_props nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (f!1 skolem-const-decl "(bijective?[(CountInf!1), nat])"
     countable_props nil)
    (O const-decl "T3" function_props nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (bijective? const-decl "bool" functions nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (T formal-type-decl nil countable_props nil)
    (set type-eq-decl nil sets nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (countably_infinite_set type-eq-decl nil countability nil))
   nil))
 (card_le_countable 0
  (card_le_countable-1 nil 3462010304
   ("" (skosimp* t)
    (("" (expand"is_countable" "card_le")
      (("" (skosimp* t)
        (("" (use "composition_injective[(S!1), (Count!1), nat]")
          (("" (inst + "f!1 o f!2"nil nil)) nil))
        nil))
      nil))
    nil)
   ((card_le const-decl "bool" card_comp_set nil)
    (composition_injective judgement-tcc nil function_props nil)
    (f!2 skolem-const-decl "[(S!1) -> (Count!1)]" countable_props nil)
    (Count!1 skolem-const-decl "countable_set[T]" countable_props nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (f!1 skolem-const-decl "(injective?[(Count!1), nat])"
     countable_props nil)
    (O const-decl "T3" function_props nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (injective? const-decl "bool" functions nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (T formal-type-decl nil countable_props nil)
    (set type-eq-decl nil sets nil)
    (is_countable const-decl "bool" countability nil)
    (countable_set nonempty-type-eq-decl nil countability nil))
   nil))
 (card_ge_uncountable 0
  (card_ge_uncountable-1 nil 3462010326
   ("" (skosimp* t)
    (("" (expand"card_ge" "is_countable")
      (("" (skosimp* t)
        (("" (use "composition_injective[(Uncount!1), (S!1), nat]")
          (("" (inst + "f!2 o f!1"nil nil)) nil))
        nil))
      nil))
    nil)
   ((card_ge const-decl "bool" card_comp_set nil)
    (composition_injective judgement-tcc nil function_props nil)
    (f!1 skolem-const-decl "[(Uncount!1) -> (S!1)]" countable_props
     nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (Uncount!1 skolem-const-decl "uncountable_set[T]" countable_props
     nil)
    (f!2 skolem-const-decl "(injective?[(S!1), nat])" countable_props
     nil)
    (O const-decl "T3" function_props nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (injective? const-decl "bool" functions nil)
    (T formal-type-decl nil countable_props nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_countable const-decl "bool" countability nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (uncountable_set type-eq-decl nil countability nil))
   nil))
 (countably_infinite_subset_union 0
  (countably_infinite_subset_union-1 nil 3462010351
   ("" (expand"is_countably_infinite" "card_eq")
    (("" (skosimp* t)
      (("" (use "bijective_inverse_exists[(Q!1), nat]")
        (("" (use "bijective_inverse_exists[(R!1), nat]")
          (("" (expand "exists1")
            (("" (skosimp*)
              (("" (assert)
                ((""
                  (lemma "bij_left_right[(Q!1), nat]"
                   ("f" "f!2" "g" "x!2"))
                  (("" (use "bij_inv_is_bij_alt[(Q!1), nat]")
                    ((""
                      (lemma "bij_left_right[(R!1), nat]"
                       ("f" "f!1" "g" "x!1"))
                      (("" (use "bij_inv_is_bij_alt[(R!1), nat]")
                        (("" (flatten)
                          (("" (delete -7 -8 -9 -10)
                            ((""
                              (inst +
                               "LAMBDA (p: (S!1)): IF Q!1(p) THEN IF odd?(f!2(p)) THEN x!1((f!2(p) - 1) / 2) ELSE x!2(f!2(p) / 2) ENDIF ELSE p ENDIF")
                              (("1"
                                (expand "bijective?")
                                (("1"
                                  (prop)
                                  (("1"
                                    (expand "injective?")
                                    (("1"
                                      (skosimp)
                                      (("1"
                                        (smash)
                                        (("1"
                                          (inst
                                           -
                                           "(f!2(x1!1) - 1) / 2"
                                           "(f!2(x2!1) - 1) / 2")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst -14 "x1!1" "x2!1")
                                              (("1" (assertnil nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide -2)
                                            (("2"
                                              (forward-chain
                                               "odd_div2")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "odd?")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("3"
                                            (forward-chain "odd_div2")
                                            (("3"
                                              (assert)
                                              (("3"
                                                (expand "odd?")
                                                (("3"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand*
                                           "subset?"
                                           "disjoint?"
                                           "empty?"
                                           "intersection"
                                           "member")
                                          (("2"
                                            (inst
                                             -17
                                             "x!1((f!2(x1!1) - 1) / 2)")
                                            (("1"
                                              (inst
                                               -18
                                               "x!1((f!2(x1!1) - 1) / 2)")
                                              (("1" (assertnil nil)
                                               ("2"
                                                (forward-chain
                                                 "odd_div2")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (expand "odd?")
                                                    (("2"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (forward-chain
                                               "odd_div2")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "odd?")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (typepred "x2!1")
                                          (("3"
                                            (expand*
                                             "disjoint?"
                                             "empty?"
                                             "intersection"
                                             "member")
                                            (("3"
                                              (inst -18 "x2!1")
                                              (("3" (assertnil nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("4"
                                          (expand*
                                           "subset?"
                                           "disjoint?"
                                           "empty?"
                                           "intersection"
                                           "member")
                                          (("4"
                                            (inst
                                             -17
                                             "x!2(f!2(x1!1) / 2)")
                                            (("1"
                                              (inst
                                               -18
                                               "x!2(f!2(x1!1) / 2)")
                                              (("1" (assertnil nil)
                                               ("2"
                                                (hide -3)
                                                (("2"
                                                  (rewrite
                                                   "odd_iff_not_even")
                                                  (("2"
                                                    (forward-chain
                                                     "even_div2")
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (rewrite
                                               "odd_iff_not_even")
                                              (("2"
                                                (forward-chain
                                                 "even_div2")
                                                nil
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("5"
                                          (inst
                                           -8
                                           "f!2(x1!1) / 2"
                                           "f!2(x2!1) / 2")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst -12 "x1!1" "x2!1")
                                              (("1" (assertnil nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (rewrite
                                               "odd_iff_not_even")
                                              (("2"
                                                (forward-chain
                                                 "even_div2")
                                                nil
                                                nil))
                                              nil))
                                            nil)
                                           ("3"
                                            (rewrite
                                             "odd_iff_not_even")
                                            (("3"
                                              (forward-chain
                                               "even_div2")
                                              nil
                                              nil))
                                            nil))
                                          nil)
                                         ("6"
                                          (expand*
                                           "disjoint?"
                                           "empty?"
                                           "intersection"
                                           "member")
                                          (("6"
                                            (inst - "x1!1")
                                            (("6" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "surjective?")
                                    (("2"
                                      (skolem-typepred)
                                      (("2"
                                        (expand"union" "member")
                                        (("2"
                                          (split)
                                          (("1"
                                            (case "Q!1(y!1)")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (inst
                                                 +
                                                 "x!2(f!2(y!1) * 2)")
                                                (("1"
                                                  (smash)
                                                  (("1"
                                                    (expand
                                                     "right_inverse?"
                                                     -10)
                                                    (("1"
                                                      (inst
                                                       -10
                                                       "2 * f!2(y!1)")
                                                      (("1"
                                                        (replace -10)
                                                        (("1"
                                                          (rewrite
                                                           "odd_iff_not_even")
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (expand
                                                     "right_inverse?"
                                                     -9)
                                                    (("2"
                                                      (inst
                                                       -9
                                                       "2 * f!2(y!1)")
                                                      (("2"
                                                        (replace -9)
                                                        (("2"
                                                          (expand
                                                           "left_inverse?"
                                                           -10)
                                                          (("2"
                                                            (inst
                                                             -10
                                                             "y!1")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand*
                                                   "subset?"
                                                   "member")
                                                  (("2"
                                                    (inst
                                                     -15
                                                     "x!2(2 * f!2(y!1))")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (inst + "y!1")
                                              (("2" (assertnil nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (inst
                                             +
                                             "x!2(f!1(y!1) * 2 + 1)")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand
                                                 "right_inverse?"
                                                 -8)
                                                (("1"
                                                  (inst
                                                   -8
                                                   "1 + 2 * f!1(y!1)")
                                                  (("1"
                                                    (replace -8)
                                                    (("1"
                                                      (expand
                                                       "left_inverse?"
                                                       -5)
                                                      (("1"
                                                        (inst -5 "y!1")
                                                        (("1"
                                                          (ground)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (expand*
                                               "subset?"
                                               "member")
                                              (("2"
                                                (inst
                                                 -14
                                                 "x!2(1 + 2 * f!1(y!1))")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (expand"union" "member"nil nil)
                               ("3"
                                (expand"subset?" "union" "member")
                                (("3"
                                  (skosimp)
                                  (("3"
                                    (inst - "x!2(f!2(p!1) / 2)")
                                    (("1" (assertnil nil)
                                     ("2"
                                      (rewrite "odd_iff_not_even")
                                      (("2"
                                        (forward-chain "even_div2")
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("4"
                                (skosimp)
                                (("4"
                                  (rewrite "odd_iff_not_even")
                                  (("4"
                                    (forward-chain "even_div2")
                                    (("4" (assertnil nil))
                                    nil))
                                  nil))
                                nil)
                               ("5" (expand"union" "member"nil nil)
                               ("6"
                                (skosimp)
                                (("6"
                                  (forward-chain "odd_div2")
                                  (("6"
                                    (assert)
                                    (("6"
                                      (expand "odd?")
                                      (("6" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bijective? const-decl "bool" functions nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (set type-eq-decl nil sets nil)
    (T formal-type-decl nil countable_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bij_left_right formula-decl nil function_inverse_def nil)
    (inverse? const-decl "bool" function_inverse_def nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (odd? const-decl "bool" integers nil)
    (Q!1 skolem-const-decl "set[T]" countable_props nil)
    (f!2 skolem-const-decl "(bijective?[(Q!1), nat])" countable_props
     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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (x!1 skolem-const-decl "[nat -> (R!1)]" countable_props nil)
    (R!1 skolem-const-decl "set[T]" countable_props nil)
    (union const-decl "set" sets nil)
    (x!2 skolem-const-decl "[nat -> (Q!1)]" countable_props nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (odd_iff_not_even formula-decl nil naturalnumbers nil)
    (even_div2 formula-decl nil naturalnumbers nil)
    (disjoint? const-decl "bool" sets nil)
    (intersection const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (x1!1 skolem-const-decl "(S!1)" countable_props nil)
    (x2!1 skolem-const-decl "(S!1)" countable_props nil)
    (odd_div2 formula-decl nil naturalnumbers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (injective? const-decl "bool" functions nil)
    (right_inverse? const-decl "bool" function_inverse_def nil)
    (left_inverse? const-decl "bool" function_inverse_def nil)
    (y!1 skolem-const-decl "(union(S!1, R!1))" countable_props nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (f!1 skolem-const-decl "(bijective?[(R!1), nat])" countable_props
     nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (surjective? const-decl "bool" functions nil)
    (p!1 skolem-const-decl "(S!1)" countable_props nil)
    (bij_inv_is_bij_alt formula-decl nil function_inverse_def nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (exists1 const-decl "bool" exists1 nil)
    (bijective_inverse_exists formula-decl nil function_inverse_def
     nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (card_eq const-decl "bool" card_comp_set nil))
   nil))
 (countable_finite_subset_union 0
  (countable_finite_subset_union-1 nil 3462010371
   ("" (skosimp)
    (("" (assert)
      (("" (lemma "bij_exists[T]" ("S" "R!1"))
        (("" (expand"is_countably_infinite" "card_eq")
          (("" (skosimp* :preds? t)
            (("" (use "bijective_inverse_exists[(Q!1), nat]")
              (("" (assert)
                ((""
                  (lemma
                   "bijective_inverse_exists[(R!1), below(card(R!1))]"
                   ("f" "f!1"))
                  (("" (expand "exists1")
                    (("" (skosimp*)
                      (("" (assert)
                        ((""
                          (lemma "bij_left_right[(Q!1), nat]"
                           ("f" "f!2" "g" "x!2"))
                          ((""
                            (lemma
                             "bij_left_right[(R!1), below(card(R!1))]"
                             ("f" "f!1" "g" "x!1"))
                            ((""
                              (lemma
                               "bij_inv_is_bij_alt[(R!1), below(card(R!1))]"
                               ("f" "f!1" "g" "x!1"))
                              ((""
                                (lemma
                                 "bij_inv_is_bij_alt[(Q!1), nat]"
                                 ("f" "f!2" "g" "x!2"))
                                ((""
                                  (flatten)
                                  ((""
                                    (delete -7 -8 -9 -10)
                                    ((""
                                      (inst
                                       +
                                       "LAMBDA (p: (S!1)): IF Q!1(p) THEN IF f!2(p) < card(R!1) THEN x!1(f!2(p)) ELSE x!2(f!2(p) - card(R!1)) ENDIF ELSE p ENDIF")
                                      (("1"
                                        (expand "bijective?")
                                        (("1"
                                          (prop)
                                          (("1"
                                            (expand "injective?")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (smash)
                                                (("1"
                                                  (inst
                                                   -8
                                                   "f!2(x1!1)"
                                                   "f!2(x2!1)")
                                                  (("1"
                                                    (inst
                                                     -14
                                                     "x1!1"
                                                     "x2!1")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand*
                                                   "subset?"
                                                   "disjoint?"
                                                   "empty?"
                                                   "intersection"
                                                   "member")
                                                  (("2"
                                                    (inst
                                                     -17
                                                     "x!1(f!2(x1!1))")
                                                    (("2"
                                                      (inst
                                                       -18
                                                       "x!1(f!2(x1!1))")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (typepred "x2!1")
                                                  (("3"
                                                    (expand*
                                                     "disjoint?"
                                                     "empty?"
                                                     "intersection"
                                                     "member")
                                                    (("3"
                                                      (inst -18 "x2!1")
                                                      (("3"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("4"
                                                  (expand*
                                                   "subset?"
                                                   "disjoint?"
                                                   "empty?"
                                                   "intersection"
                                                   "member")
                                                  (("4"
                                                    (inst
                                                     -17
                                                     "x!2(f!2(x1!1) - card(R!1))")
                                                    (("4"
                                                      (inst
                                                       -18
                                                       "x!2(f!2(x1!1) - card(R!1))")
                                                      (("4"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("5"
                                                  (inst
                                                   -
                                                   "f!2(x1!1) - card(R!1)"
                                                   "f!2(x2!1) - card(R!1)")
                                                  (("5"
                                                    (inst
                                                     -12
                                                     "x1!1"
                                                     "x2!1")
                                                    (("5"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("6"
                                                  (expand*
                                                   "disjoint?"
                                                   "empty?"
                                                   "intersection"
                                                   "member")
                                                  (("6"
                                                    (inst -17 "x1!1")
                                                    (("6"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "surjective?")
                                            (("2"
                                              (skolem-typepred)
                                              (("2"
                                                (expand*
                                                 "union"
                                                 "member")
                                                (("2"
                                                  (split)
                                                  (("1"
                                                    (case "Q!1(y!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (inst
                                                         +
                                                         "x!2(f!2(y!1) + card(R!1))")
                                                        (("1"
                                                          (smash)
                                                          (("1"
                                                            (expand
                                                             "right_inverse?"
                                                             -10)
                                                            (("1"
                                                              (inst
                                                               -10
                                                               "card(R!1) + f!2(y!1)")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "right_inverse?"
                                                             -9)
                                                            (("2"
                                                              (inst
                                                               -9
                                                               "card(R!1) + f!2(y!1)")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "left_inverse?"
                                                                   -10)
                                                                  (("2"
                                                                    (inst
                                                                     -10
                                                                     "y!1")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand*
                                                           "subset?"
                                                           "member")
                                                          (("2"
                                                            (inst
                                                             -15
                                                             "x!2(card(R!1) + f!2(y!1))")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst + "y!1")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (inst
                                                     +
                                                     "x!2(f!1(y!1))")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "right_inverse?"
                                                         -8)
                                                        (("1"
                                                          (inst
                                                           -8
                                                           "f!1(y!1)")
                                                          (("1"
                                                            (replace
                                                             -8)
                                                            (("1"
                                                              (expand
                                                               "left_inverse?"
                                                               -7)
                                                              (("1"
                                                                (inst
                                                                 -7
                                                                 "y!1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand*
                                                       "subset?"
                                                       "member")
                                                      (("2"
                                                        (inst
                                                         -14
                                                         "x!2(f!1(y!1))")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand"union" "member")
                                        nil
                                        nil)
                                       ("3"
                                        (expand*
                                         "subset?"
                                         "union"
                                         "member")
                                        (("3"
                                          (skosimp)
                                          (("3"
                                            (assert)
                                            (("3"
                                              (inst
                                               -
                                               "x!2(f!2(p!1) - card(R!1))")
                                              (("3" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("4"
                                        (skosimp)
                                        (("4" (assertnil nil))
                                        nil)
                                       ("5"
                                        (expand"union" "member")
                                        nil
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (card_eq const-decl "bool" card_comp_set nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (bijective_inverse_exists formula-decl nil function_inverse_def
     nil)
    (below type-eq-decl nil naturalnumbers nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (bij_left_right formula-decl nil function_inverse_def nil)
    (inverse? const-decl "bool" function_inverse_def nil)
    (bij_inv_is_bij_alt formula-decl nil function_inverse_def nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (Q!1 skolem-const-decl "set[T]" countable_props nil)
    (f!2 skolem-const-decl "(bijective?[(Q!1), nat])" countable_props
     nil)
    (R!1 skolem-const-decl "set[T]" countable_props nil)
    (union const-decl "set" sets nil)
    (x!1 skolem-const-decl "[below(card(R!1)) -> (R!1)]"
     countable_props nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (x!2 skolem-const-decl "[nat -> (Q!1)]" countable_props nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (disjoint? const-decl "bool" sets nil)
    (intersection const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (injective? const-decl "bool" functions nil)
    (right_inverse? const-decl "bool" function_inverse_def nil)
    (left_inverse? const-decl "bool" function_inverse_def nil)
    (y!1 skolem-const-decl "(union(S!1, R!1))" countable_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (f!1 skolem-const-decl "[(R!1) -> below(card(R!1))]"
     countable_props nil)
    (surjective? const-decl "bool" functions nil)
    (exists1 const-decl "bool" exists1 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (bijective? const-decl "bool" functions nil)
    (bij_exists formula-decl nil finite_sets nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (T formal-type-decl nil countable_props nil))
   nil))
 (infinite_countable_union 0
  (infinite_countable_union-1 nil 3462010390
   ("" (skolem-typepred)
    (("" (use "union_difference[T]")
      (("" (use "difference_disjoint[T]")
        (("" (assert)
          (("" (use "countably_infinite_subset_exists")
            (("" (skolem-typepred)
              (("" (rewrite "countable_card")
                (("" (split)
                  (("1"
                    (lemma "countable_finite_subset_union"
                     ("Q" "CountInf!1" "R" "difference(Count!1, Inf!1)"
                      "S" "Inf!1"))
                    (("1" (assert)
                      (("1" (use "finite_difference[T]"nil nil))
                      nil))
                    nil)
                   ("2" (use "countable_difference")
                    (("2" (rewrite "countable_card")
                      (("2" (split)
                        (("1"
                          (lemma "countable_finite_subset_union"
                           ("Q" "CountInf!1" "R"
                            "difference(Count!1, Inf!1)" "S" "Inf!1"))
                          (("1" (assertnil nil)) nil)
                         ("2"
                          (lemma "countably_infinite_subset_union"
                           ("Q" "CountInf!1" "R"
                            "difference(Count!1, Inf!1)" "S" "Inf!1"))
                          (("2" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((union_difference formula-decl nil sets_lemmas nil)
    (infinite_union_left application-judgement "infinite_set[T]"
     countable_props nil)
    (countable_difference application-judgement "countable_set[T]"
     countable_props nil)
    (countably_infinite_set type-eq-decl nil countability nil)
    (is_countably_infinite const-decl "bool" countability nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (finite_difference judgement-tcc nil finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (difference const-decl "set" sets nil)
    (countable_finite_subset_union formula-decl nil countable_props
     nil)
    (countably_infinite_subset_union formula-decl nil countable_props
     nil)
    (countable_difference judgement-tcc nil countable_props nil)
    (countable_card formula-decl nil countable_props nil)
    (countably_infinite_subset_exists formula-decl nil countable_props
     nil)
    (difference_disjoint formula-decl nil sets_lemmas nil)
    (countable_set nonempty-type-eq-decl nil countability nil)
    (is_countable const-decl "bool" countability nil)
    (infinite_set type-eq-decl nil infinite_sets_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil countable_props nil))
   nil))
 (infinite_countable_difference 0
  (infinite_countable_difference-1 nil 3462010407
   ("" (skosimp :preds? t)
    ((""
      (lemma "countable_intersection2" ("S" "S!1" "Count" "Count!1"))
      ((""
        (case "S!1 = union(difference(S!1, Count!1), intersection(S!1, Count!1))")
        (("1" (lemma "infinite_countable_union")
          (("1"
            (inst - "difference(S!1, Count!1)"
             "intersection(S!1, Count!1)")
            (("1" (replace -2 -1 :dir rl)
              (("1" (rewrite "card_eq_symmetric"nil nil)) nil))
            nil))
          nil)
         ("2" (hide -1 -2 2 3) (("2" (grind-with-ext) nil nil)) nil))
        nil))
      nil))
    nil)
   ((countable_intersection2 judgement-tcc nil countable_props nil)
    (member const-decl "bool" sets nil)
    (infinite_countable_union formula-decl nil countable_props nil)
    (card_eq_symmetric formula-decl nil card_comp_set_props nil)
    (infinite_set type-eq-decl nil infinite_sets_def nil)
    (Count!1 skolem-const-decl "countable_set[T]" countable_props nil)
    (S!1 skolem-const-decl "set[T]" countable_props nil)
    (is_finite const-decl "bool" finite_sets nil)
    (countable_intersection2 application-judgement "countable_set[T]"
     countable_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (union const-decl "set" sets nil)
    (difference const-decl "set" sets nil)
    (intersection const-decl "set" sets nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (T formal-type-decl nil countable_props nil)
    (set type-eq-decl nil sets nil)
    (is_countable const-decl "bool" countability nil)
    (countable_set nonempty-type-eq-decl nil countability nil))
   nil)))


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.203Bemerkung:  (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-04-27) ¤

*Eine klare Vorstellung vom Zielzustand






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


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