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


Quelle  subset_algebra_def.prf

  Sprache: Lisp
 

(subset_algebra_def
 (sigma_union_implies_subset_union 0
  (sigma_union_implies_subset_union-1 nil 3313473197
   ("" (expand "subset_algebra_union?")
    (("" (expand "sigma_algebra_union?")
      (("" (skosimp*)
        (("" (typepred "x!1")
          (("" (typepred "y!1")
            (("" (name "U" "union(singleton(x!1),singleton(y!1))")
              (("" (inst - "U")
                ((""
                  (case-replace
                   "(FORALL (x: (extend[setof[T], (S!1), bool, FALSE](U))):
           member(x, S!1))")
                  (("1" (split -5)
                    (("1" (expand "member")
                      (("1" (expand "extend")
                        (("1" (expand "Union")
                          (("1" (expand "union")
                            (("1" (assert)
                              (("1"
                                (case-replace
                                 "{x: T |
             EXISTS (a:
                       (LAMBDA (t: setof[T]):
                          IF (S!1)(t) THEN U(t) ELSE FALSE ENDIF)):
               a(x)} = {x: T | member(x, x!1) OR member(x, y!1)}")
                                (("1"
                                  (hide 2)
                                  (("1"
                                    (apply-extensionality 1 :hide? t)
                                    (("1"
                                      (expand "member")
                                      (("1"
                                        (case-replace "x!1(x!2)")
                                        (("1"
                                          (inst + "x!1")
                                          (("1"
                                            (expand "U")
                                            (("1"
                                              (expand "singleton")
                                              (("1"
                                                (expand "union")
                                                (("1"
                                                  (expand "member")
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (case-replace "y!1(x!2)")
                                            (("1"
                                              (inst + "y!1")
                                              (("1"
                                                (expand "U")
                                                (("1"
                                                  (expand "singleton")
                                                  (("1"
                                                    (expand "union")
                                                    (("1"
                                                      (expand "member")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (assert)
                                              (("2"
                                                (skosimp)
                                                (("2"
                                                  (typepred "a!1")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand "U" -1)
                                                      (("2"
                                                        (expand
                                                         "singleton")
                                                        (("2"
                                                          (expand
                                                           "union")
                                                          (("2"
                                                            (expand
                                                             "member")
                                                            (("2"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "extend")
                        (("2" (expand "is_countable[set[T]]")
                          (("2"
                            (inst +
                             "lambda (x:setof[T]): IF x = x!1 THEN 0 ELSE 1 ENDIF")
                            (("2" (expand "injective?")
                              (("2"
                                (skosimp*)
                                (("2"
                                  (expand "restrict")
                                  (("2"
                                    (typepred "x1!1")
                                    (("2"
                                      (typepred "x2!1")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (expand "U")
                                          (("2"
                                            (expand "singleton")
                                            (("2"
                                              (expand "union")
                                              (("2"
                                                (expand "member")
                                                (("2"
                                                  (hide-all-but
                                                   (-1 -3 -5 1))
                                                  (("2"
                                                    (split -1)
                                                    (("1"
                                                      (split -2)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (split -2)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide 2)
                    (("2" (skosimp*)
                      (("2" (typepred "x!2")
                        (("2" (expand "extend")
                          (("2" (case-replace "S!1(x!2)")
                            (("1" (expand "member")
                              (("1" (propax) nil nil)) nil)
                             ("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (non_empty_finite_set type-eq-decl nil finite_sets nil)
    (empty? const-decl "bool" sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (singleton const-decl "(singleton?)" sets nil)
    (singleton? const-decl "bool" sets nil)
    (union const-decl "set" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (set type-eq-decl nil sets nil)
    (nonempty_finite_union1 application-judgement
     "non_empty_finite_set[T]" countable_props "sets_aux/")
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set[T]" countable_props "sets_aux/")
    (member const-decl "bool" sets nil)
    (is_countable const-decl "bool" countability "sets_aux/")
    (restrict const-decl "R" restrict 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)
    (Union const-decl "set" sets nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (y!1 skolem-const-decl "(S!1)" subset_algebra_def nil)
    (S!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (U skolem-const-decl "non_empty_finite_set[(S!1)]"
     subset_algebra_def nil)
    (x!1 skolem-const-decl "(S!1)" subset_algebra_def nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (FALSE const-decl "bool" booleans nil)
    (extend const-decl "R" extend nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil))
   shostak))
 (sigma_algebra_implies_subset_algebra 0
  (sigma_algebra_implies_subset_algebra-1 nil 3313474506
   ("" (skosimp*)
    (("" (expand "sigma_algebra?")
      (("" (expand "subset_algebra?")
        (("" (flatten)
          (("" (assert)
            (("" (rewrite "sigma_union_implies_subset_union"nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (sigma_union_implies_subset_union formula-decl nil
     subset_algebra_def nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil))
   shostak))
 (trivial_subset_algebra_TCC1 0
  (trivial_subset_algebra_TCC1-1 nil 3426521314
   ("" (expand "subset_algebra?")
    (("" (expand "emptyset")
      (("" (expand "fullset")
        (("" (expand "singleton")
          (("" (expand "union")
            (("" (expand "member")
              (("" (expand "subset_algebra_empty?")
                (("" (expand "subset_algebra_complement?")
                  (("" (expand "complement")
                    (("" (expand "subset_algebra_union?")
                      (("" (expand "union")
                        (("" (expand "member")
                          (("" (expand "emptyset")
                            (("" (split)
                              (("1"
                                (skosimp*)
                                (("1"
                                  (apply-extensionality :hide? t)
                                  (("1"
                                    (apply-extensionality :hide? t)
                                    (("1"
                                      (typepred "x!1")
                                      (("1"
                                        (split)
                                        (("1"
                                          (replace -1)
                                          (("1" (assertnil nil))
                                          nil)
                                         ("2"
                                          (replace -1)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp*)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (typepred "x!1")
                                      (("2"
                                        (typepred "y!1")
                                        (("2"
                                          (split -1)
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (split -2)
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (split -2)
                                            (("1" (assertnil nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((emptyset const-decl "set" sets nil)
    (singleton const-decl "(singleton?)" sets nil)
    (member const-decl "bool" sets nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (FALSE const-decl "bool" booleans nil)
    (TRUE const-decl "bool" booleans nil)
    (complement const-decl "set" sets nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (union const-decl "set" sets nil)
    (fullset const-decl "set" sets nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (nonempty_finite_union1 application-judgement
     "non_empty_finite_set[T]" countable_props "sets_aux/")
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set" finite_sets nil))
   nil))
 (sigma_algebra_TCC1 0
  (sigma_algebra_TCC1-1 nil 3426521314
   ("" (expand "trivial_subset_algebra")
    (("" (expand "emptyset")
      (("" (expand "fullset")
        (("" (expand "singleton")
          (("" (expand "union")
            (("" (expand "sigma_algebra?")
              (("" (expand "subset_algebra_empty?")
                (("" (expand "emptyset")
                  (("" (expand "member")
                    (("" (expand "subset_algebra_complement?")
                      (("" (expand "complement")
                        (("" (expand "sigma_algebra_union?")
                          (("" (expand "Union")
                            (("" (expand "member")
                              ((""
                                (split)
                                (("1"
                                  (skosimp*)
                                  (("1"
                                    (apply-extensionality :hide? t)
                                    (("1"
                                      (apply-extensionality :hide? t)
                                      (("1"
                                        (typepred "x!1")
                                        (("1"
                                          (split)
                                          (("1" (assertnil nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (skosimp*)
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (apply-extensionality :hide? t)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (typepred "a!1")
                                          (("2"
                                            (inst - "a!1")
                                            (("2"
                                              (split -4)
                                              (("1" (assertnil nil)
                                               ("2"
                                                (inst + "a!1")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((emptyset const-decl "set" sets nil)
    (singleton const-decl "(singleton?)" sets nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (TRUE const-decl "bool" booleans nil)
    (FALSE const-decl "bool" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (boolean nonempty-type-decl nil booleans nil)
    (Union const-decl "set" sets nil)
    (complement const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (union const-decl "set" sets nil)
    (fullset const-decl "set" sets nil)
    (trivial_subset_algebra const-decl "(subset_algebra?)"
     subset_algebra_def nil)
    (nonempty_finite_union1 application-judgement
     "non_empty_finite_set[T]" countable_props "sets_aux/")
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set" finite_sets nil))
   nil))
 (sigma_algebra_is_subset_algebra 0
  (sigma_algebra_is_subset_algebra-1 nil 3426521314
   ("" (skolem + ("A"))
    (("" (typepred "A")
      (("" (expand "subset_algebra?")
        (("" (expand "sigma_algebra?")
          (("" (flatten)
            (("" (replace -1)
              (("" (replace -2)
                (("" (expand "subset_algebra_union?")
                  (("" (expand "sigma_algebra_union?")
                    (("" (skosimp)
                      ((""
                        (inst -
                         "add[set[T]](x!1,singleton[set[T]](y!1))")
                        ((""
                          (case-replace
                           "Union(add[set[T]](x!1, singleton[set[T]](y!1)))=union(x!1, y!1)")
                          (("1" (split -4)
                            (("1" (propax) nil nil)
                             ("2" (rewrite "finite_countable[set[T]]")
                              nil nil)
                             ("3" (hide-all-but 1)
                              (("3"
                                (skosimp)
                                (("3"
                                  (typepred "x!2")
                                  (("3"
                                    (expand "singleton")
                                    (("3"
                                      (expand "add")
                                      (("3"
                                        (expand "member")
                                        (("3"
                                          (split)
                                          (("1" (assertnil nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide-all-but 1)
                            (("2" (apply-extensionality :hide? t)
                              (("2"
                                (expand "union")
                                (("2"
                                  (expand "singleton")
                                  (("2"
                                    (expand "add")
                                    (("2"
                                      (expand "member")
                                      (("2"
                                        (expand "Union")
                                        (("2"
                                          (case-replace "x!1(x!2)")
                                          (("1" (inst + "x!1"nil nil)
                                           ("2"
                                            (case-replace "y!1(x!2)")
                                            (("1"
                                              (inst + "y!1")
                                              nil
                                              nil)
                                             ("2"
                                              (assert)
                                              (("2"
                                                (skosimp)
                                                (("2"
                                                  (typepred "a!1")
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil)
    (union const-decl "set" sets nil) (Union const-decl "set" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nonempty_add_finite application-judgement
     "non_empty_finite_set[T]" countable_props "sets_aux/")
    (member const-decl "bool" sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_countable judgement-tcc nil countable_props "sets_aux/")
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (nonempty_singleton_finite application-judgement
     "non_empty_finite_set[T]" countable_props "sets_aux/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (singleton const-decl "(singleton?)" sets nil)
    (singleton? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil))
   nil))
 (powerset_is_sigma_algebra 0
  (powerset_is_sigma_algebra-1 nil 3426523512
   ("" (expand "sigma_algebra?")
    (("" (split)
      (("1" (expand "subset_algebra_empty?") (("1" (grind) nil nil))
        nil)
       ("2" (grind) nil nil) ("3" (grind) nil nil))
      nil))
    nil)
   ((emptyset const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (fullset const-decl "set" sets nil)
    (subset? const-decl "bool" sets nil)
    (powerset const-decl "setofsets" sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (complement const-decl "set" sets nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (is_countable const-decl "bool" countability "sets_aux/")
    (Union const-decl "set" sets nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (nonempty_powerset application-judgement "(nonempty?[set[T]])"
     sets_lemmas nil))
   shostak))
 (generated_sigma_algebra_TCC1 0
  (generated_sigma_algebra_TCC1-1 nil 3426521314
   ("" (skosimp)
    (("" (expand "Intersection")
      (("" (expand "sigma_algebra?")
        (("" (split)
          (("1" (expand "subset_algebra_empty?")
            (("1" (expand "member")
              (("1" (skosimp)
                (("1" (typepred "a!1")
                  (("1" (expand "sigma_algebra?")
                    (("1" (flatten)
                      (("1" (expand "subset_algebra_empty?")
                        (("1" (expand "member")
                          (("1" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "subset_algebra_complement?")
            (("2" (skosimp)
              (("2" (expand "member")
                (("2" (skosimp)
                  (("2" (typepred "a!1")
                    (("2" (expand "sigma_algebra?")
                      (("2" (flatten)
                        (("2" (expand "subset_algebra_complement?")
                          (("2" (expand "member")
                            (("2" (typepred "x!1")
                              (("2"
                                (inst - "a!1")
                                (("2" (inst - "x!1"nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (expand "sigma_algebra_union?")
            (("3" (skosimp)
              (("3" (expand "member")
                (("3" (skosimp)
                  (("3" (typepred "a!1")
                    (("3" (expand "sigma_algebra?")
                      (("3" (flatten)
                        (("3" (expand "sigma_algebra_union?")
                          (("3" (inst - "X!2")
                            (("3" (assert)
                              (("3"
                                (expand "member")
                                (("3"
                                  (skosimp)
                                  (("3"
                                    (typepred "x!1")
                                    (("3"
                                      (expand "subset?")
                                      (("3"
                                        (inst - "x!1")
                                        (("3"
                                          (assert)
                                          (("3"
                                            (expand "member")
                                            (("3"
                                              (inst - "x!1")
                                              (("3"
                                                (inst - "a!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)
   ((Intersection const-decl "set" sets nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (member const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (X!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (a!1 skolem-const-decl
     "({Y | sigma_algebra?(Y) AND subset?[setof[T]](X!1, Y)})"
     subset_algebra_def nil)
    (x!1 skolem-const-decl "({x |
    FORALL (a: ({Y | sigma_algebra?(Y) AND subset?[setof[T]](X!1, Y)})):
      a(x)})" subset_algebra_def nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil))
   nil))
 (generated_sigma_algebra_subset1 0
  (generated_sigma_algebra_subset1-1 nil 3426523538
   ("" (skosimp)
    (("" (expand "generated_sigma_algebra")
      (("" (expand "subset?")
        (("" (expand "Intersection")
          (("" (expand "member")
            (("" (skosimp*)
              (("" (typepred "a!1")
                (("" (inst - "x!1")
                  (("" (expand "member") (("" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((generated_sigma_algebra const-decl "sigma_algebra"
     subset_algebra_def 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 subset_algebra_def nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil) (member const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil))
   shostak))
 (generated_sigma_algebra_subset2 0
  (generated_sigma_algebra_subset2-1 nil 3426523636
   ("" (skosimp)
    (("" (expand "generated_sigma_algebra")
      (("" (expand "Intersection")
        (("" (expand "subset?" 1 1)
          (("" (expand "member")
            (("" (skosimp)
              (("" (inst - "Y!1") (("" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((generated_sigma_algebra const-decl "sigma_algebra"
     subset_algebra_def nil)
    (subset? const-decl "bool" sets nil)
    (Y!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (X!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (set type-eq-decl nil sets nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (member const-decl "bool" sets nil)
    (Intersection const-decl "set" sets nil))
   shostak))
 (generated_sigma_algebra_idempotent 0
  (generated_sigma_algebra_idempotent-1 nil 3426523706
   ("" (skosimp)
    ((""
      (lemma "generated_sigma_algebra_subset2" ("X" "A!1" "Y" "A!1"))
      (("" (assert)
        (("" (rewrite "subset_reflexive")
          (("" (lemma "generated_sigma_algebra_subset1" ("X" "A!1"))
            ((""
              (lemma "subset_antisymmetric"
               ("a" "generated_sigma_algebra(A!1)" "b" "A!1"))
              (("" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (generated_sigma_algebra_subset2 formula-decl nil
     subset_algebra_def nil)
    (subset_reflexive formula-decl nil sets_lemmas nil)
    (set type-eq-decl nil sets nil)
    (subset_antisymmetric formula-decl nil sets_lemmas nil)
    (generated_sigma_algebra const-decl "sigma_algebra"
     subset_algebra_def nil)
    (generated_sigma_algebra_subset1 formula-decl nil
     subset_algebra_def nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil))
   shostak))
 (intersection_sigma_algebra 0
  (intersection_sigma_algebra-1 nil 3426523790
   ("" (skosimp)
    (("" (typepred "A!1")
      (("" (typepred "B!1")
        (("" (expand "intersection")
          (("" (expand "sigma_algebra?")
            (("" (flatten)
              (("" (expand "member")
                (("" (split)
                  (("1" (expand "subset_algebra_empty?")
                    (("1" (expand "member") (("1" (assertnil nil))
                      nil))
                    nil)
                   ("2" (expand "subset_algebra_complement?")
                    (("2" (skosimp)
                      (("2" (typepred "x!1")
                        (("2" (inst - "x!1")
                          (("2" (inst - "x!1")
                            (("2" (expand "member")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("3" (expand "sigma_algebra_union?")
                    (("3" (skosimp)
                      (("3" (expand "member")
                        (("3" (inst -5 "X!1")
                          (("3" (inst -8 "X!1")
                            (("3" (assert)
                              (("3"
                                (split -5)
                                (("1"
                                  (split -8)
                                  (("1" (assertnil nil)
                                   ("2"
                                    (skosimp)
                                    (("2"
                                      (inst - "x!1")
                                      (("2" (flatten) nil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (skosimp)
                                  (("2"
                                    (inst - "x!1")
                                    (("2" (flatten) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (intersection const-decl "set" sets nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (member const-decl "bool" sets nil))
   shostak))
 (sigma_member 0
  (sigma_member-1 nil 3426524135
   ("" (expand "member")
    (("" (skosimp)
      (("" (expand "sigma")
        (("" (expand "extend")
          (("" (expand "Union")
            (("" (expand "generated_sigma_algebra")
              (("" (expand "Intersection")
                (("" (expand "subset?")
                  (("" (expand "member")
                    (("" (skosimp*)
                      (("" (typepred "a!1")
                        (("" (expand "subset?")
                          (("" (expand "member")
                            (("" (inst - "x!1")
                              ((""
                                (split -2)
                                (("1" (propax) nil nil)
                                 ("2" (inst + "A!1"nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((extend const-decl "R" extend nil)
    (generated_sigma_algebra const-decl "sigma_algebra"
     subset_algebra_def nil)
    (subset? const-decl "bool" sets nil)
    (I!1 skolem-const-decl "set[sigma_algebra]" subset_algebra_def nil)
    (A!1 skolem-const-decl "sigma_algebra" subset_algebra_def 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 subset_algebra_def nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (FALSE const-decl "bool" booleans nil)
    (Intersection const-decl "set" sets nil)
    (Union const-decl "set" sets nil)
    (sigma const-decl "sigma_algebra" subset_algebra_def nil)
    (member const-decl "bool" sets nil))
   shostak))
 (powerset_is_subset_algebra 0
  (powerset_is_subset_algebra-1 nil 3449732914
   ("" (lemma "powerset_is_sigma_algebra")
    (("" (lemma "sigma_algebra_is_subset_algebra")
      (("" (inst - "powerset(fullset[T])"nil nil)) nil))
    nil)
   ((sigma_algebra_is_subset_algebra judgement-tcc nil
     subset_algebra_def nil)
    (fullset const-decl "set" sets nil)
    (powerset const-decl "setofsets" sets nil)
    (set type-eq-decl nil sets nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (nonempty_powerset application-judgement "(nonempty?[set[T]])"
     sets_lemmas nil)
    (powerset_is_sigma_algebra formula-decl nil subset_algebra_def
     nil))
   shostak))
 (generated_subset_algebra_TCC1 0
  (generated_subset_algebra_TCC1-1 nil 3449732913
   ("" (subtype-tcc) nil nil)
   ((a!1 skolem-const-decl "({Y |
    (Y(emptyset[T]) AND
      (FORALL (x: (Y)): Y(complement(x))) AND
       (FORALL (x, y: (Y)): Y(union(x, y))))
     AND (FORALL (x: setof[T]): X!1(x) => Y(x))})" subset_algebra_def
     nil)
    (x!1 skolem-const-decl "(Intersection[setof[T]]
     ({Y |
         (Y(emptyset[T]) AND
           (FORALL (x: (Y)): Y(complement(x))) AND
            (FORALL (x, y: (Y)): Y(union(x, y))))
          AND (FORALL (x: setof[T]): X!1(x) => Y(x))}))"
     subset_algebra_def 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 subset_algebra_def nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (emptyset const-decl "set" sets nil)
    (complement const-decl "set" sets nil)
    (union const-decl "set" sets nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (X!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (a!1 skolem-const-decl "({Y |
    (Y(emptyset[T]) AND
      (FORALL (x: (Y)): Y(complement(x))) AND
       (FORALL (x, y: (Y)): Y(union(x, y))))
     AND (FORALL (x: setof[T]): X!1(x) => Y(x))})" subset_algebra_def
     nil)
    (x!1 skolem-const-decl "(Intersection[setof[T]]
     ({Y |
         (Y(emptyset[T]) AND
           (FORALL (x: (Y)): Y(complement(x))) AND
            (FORALL (x, y: (Y)): Y(union(x, y))))
          AND (FORALL (x: setof[T]): X!1(x) => Y(x))}))"
     subset_algebra_def nil)
    (y!1 skolem-const-decl "(Intersection[setof[T]]
     ({Y |
         (Y(emptyset[T]) AND
           (FORALL (x: (Y)): Y(complement(x))) AND
            (FORALL (x, y: (Y)): Y(union(x, y))))
          AND (FORALL (x: setof[T]): X!1(x) => Y(x))}))"
     subset_algebra_def nil)
    (Intersection_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (member const-decl "bool" sets nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (subset? const-decl "bool" sets nil)
    (Intersection const-decl "set" sets nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/"))
   nil))
 (generated_subset_algebra_subset1 0
  (generated_subset_algebra_subset1-1 nil 3449732987
   ("" (skosimp)
    (("" (expand "subset?")
      (("" (expand "member")
        (("" (skosimp)
          (("" (expand "generated_subset_algebra")
            (("" (expand "Intersection")
              (("" (skosimp)
                (("" (typepred "a!1")
                  (("" (expand "subset?")
                    (("" (inst - "x!1")
                      (("" (expand "member") (("" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset? const-decl "bool" sets nil)
    (Intersection const-decl "set" sets nil)
    (set type-eq-decl nil sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (generated_subset_algebra const-decl "subset_algebra"
     subset_algebra_def nil)
    (member const-decl "bool" sets nil))
   shostak))
 (generated_subset_algebra_subset2 0
  (generated_subset_algebra_subset2-1 nil 3449733118
   ("" (skosimp)
    (("" (expand "subset?" +)
      (("" (expand "member")
        (("" (skosimp)
          (("" (expand "generated_subset_algebra")
            (("" (expand "Intersection")
              (("" (inst - "Y!1") (("" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset? const-decl "bool" sets nil)
    (Intersection const-decl "set" sets nil)
    (Y!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (X!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (set type-eq-decl nil sets nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (generated_subset_algebra const-decl "subset_algebra"
     subset_algebra_def nil)
    (member const-decl "bool" sets nil))
   shostak))
 (generated_subset_algebra_idempotent 0
  (generated_subset_algebra_idempotent-1 nil 3449733211
   ("" (skosimp)
    (("" (typepred "B!1")
      (("" (lemma "generated_subset_algebra_subset1" ("X" "B!1"))
        ((""
          (lemma "generated_subset_algebra_subset2"
           ("X" "B!1" "Y" "B!1"))
          (("" (assert)
            (("" (rewrite "subset_reflexive")
              ((""
                (lemma "subset_antisymmetric"
                 ("a" "generated_subset_algebra(B!1)" "b" "B!1"))
                (("" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (generated_subset_algebra_subset2 formula-decl nil
     subset_algebra_def nil)
    (set type-eq-decl nil sets nil)
    (subset_reflexive formula-decl nil sets_lemmas nil)
    (generated_subset_algebra const-decl "subset_algebra"
     subset_algebra_def nil)
    (subset_antisymmetric formula-decl nil sets_lemmas nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (generated_subset_algebra_subset1 formula-decl nil
     subset_algebra_def nil))
   shostak))
 (intersection_subset_algebra 0
  (intersection_subset_algebra-1 nil 3449733399
   ("" (skosimp)
    (("" (typepred "A!1")
      (("" (typepred "B!1")
        (("" (expand "subset_algebra?")
          (("" (flatten)
            (("" (split)
              (("1" (expand "subset_algebra_empty?")
                (("1" (expand "member")
                  (("1" (expand "intersection")
                    (("1" (expand "member") (("1" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (expand "subset_algebra_complement?")
                (("2" (skosimp)
                  (("2" (expand "complement")
                    (("2" (expand "member")
                      (("2" (expand "intersection")
                        (("2" (expand "member")
                          (("2" (inst - "x!1")
                            (("1" (inst - "x!1")
                              (("1" (assertnil nil)
                               ("2"
                                (typepred "x!1")
                                (("2"
                                  (expand "intersection")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "member")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (typepred "x!1")
                              (("2"
                                (expand "intersection")
                                (("2"
                                  (expand "member")
                                  (("2" (flatten) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("3" (expand "subset_algebra_union?")
                (("3" (skosimp)
                  (("3" (typepred "x!1")
                    (("3" (typepred "y!1")
                      (("3" (expand "intersection")
                        (("3" (expand "member")
                          (("3" (flatten)
                            (("3" (inst - "x!1" "y!1")
                              (("3"
                                (inst - "x!1" "y!1")
                                (("3" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (member const-decl "bool" sets nil)
    (intersection const-decl "set" sets nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (B!1 skolem-const-decl "subset_algebra" subset_algebra_def nil)
    (set type-eq-decl nil sets nil)
    (A!1 skolem-const-decl "subset_algebra" subset_algebra_def nil)
    (x!1 skolem-const-decl "(intersection(A!1, B!1))"
     subset_algebra_def nil)
    (complement const-decl "set" sets nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (x!1 skolem-const-decl "(intersection(A!1, B!1))"
     subset_algebra_def nil)
    (y!1 skolem-const-decl "(intersection(A!1, B!1))"
     subset_algebra_def nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil))
   shostak))
 (subset_member 0
  (subset_member-1 nil 3449733630
   ("" (skosimp)
    (("" (expand "subset?")
      (("" (skosimp)
        (("" (expand "member")
          (("" (expand "subset")
            (("" (expand "generated_subset_algebra")
              (("" (expand "Intersection")
                (("" (skosimp)
                  (("" (typepred "a!1")
                    (("" (expand "subset?")
                      (("" (expand "member")
                        (("" (inst - "x!1")
                          (("" (assert)
                            (("" (hide 2)
                              ((""
                                (expand "extend")
                                ((""
                                  (expand "Union")
                                  (("" (inst + "B!1"nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (generated_subset_algebra const-decl "subset_algebra"
     subset_algebra_def nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas 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 subset_algebra_def nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil) (Union const-decl "set" sets nil)
    (subset_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (FALSE const-decl "bool" booleans nil)
    (extend const-decl "R" extend nil)
    (Intersection const-decl "set" sets nil)
    (subset const-decl "subset_algebra" subset_algebra_def nil))
   shostak))
 (card_TCC1 0
  (card_TCC1-1 nil 3455341025
   ("" (skosimp)
    (("" (typepred "a!1")
      (("" (expand "finite_disjoint_union?")
        (("" (skosimp)
          (("" (expand "nonempty?")
            (("" (expand "empty?")
              (("" (inst -4 "n!1")
                (("" (expand "member")
                  (("" (inst + "E!1")
                    (("" (expand "finite_disjoint_union_of?")
                      (("" (assert)
                        (("" (skosimp)
                          (("" (inst - "i!1")
                            (("" (flatten)
                              ((""
                                (assert)
                                ((""
                                  (expand "member")
                                  ((""
                                    (replace -3)
                                    ((""
                                      (expand "empty?")
                                      ((""
                                        (expand "member")
                                        (("" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((finite_disjoint_union? const-decl "bool" subset_algebra_def nil)
    (set type-eq-decl nil sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (finite_disjoint_union_of? const-decl "bool" subset_algebra_def
     nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sequence type-eq-decl nil sequences 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)
    (nonempty? const-decl "bool" sets nil))
   nil))
 (disjoint_algebra_construction 0
  (disjoint_algebra_construction-1 nil 3450336806
   ("" (skosimp*)
    ((""
      (case "subset?(finite_disjoint_unions(NX!1),generated_subset_algebra(NX!1))")
      (("1"
        (lemma "generated_subset_algebra_subset2"
         ("X" "NX!1" "Y" "finite_disjoint_unions(NX!1)"))
        (("1" (split -1)
          (("1"
            (lemma "subset_antisymmetric"
             ("a" "generated_subset_algebra(NX!1)" "b"
              "finite_disjoint_unions(NX!1)"))
            (("1" (assertnil nil)) nil)
           ("2" (hide-all-but 1)
            (("2" (expand "finite_disjoint_unions")
              (("2" (expand "fullset")
                (("2" (expand "extend")
                  (("2" (expand "subset?")
                    (("2" (expand "member")
                      (("2" (skosimp)
                        (("2" (assert)
                          (("2" (prop)
                            (("2" (expand "finite_disjoint_union?")
                              (("2"
                                (inst
                                 +
                                 "lambda n: if n=0 then x!1 else emptyset[T] endif"
                                 "1")
                                (("2"
                                  (split)
                                  (("1"
                                    (expand "disjoint?")
                                    (("1"
                                      (expand "emptyset")
                                      (("1"
                                        (expand "disjoint?")
                                        (("1"
                                          (expand "intersection")
                                          (("1"
                                            (expand "empty?")
                                            (("1"
                                              (expand "member")
                                              (("1"
                                                (skosimp)
                                                (("1"
                                                  (skosimp)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (expand "emptyset")
                                      (("2"
                                        (expand "IUnion")
                                        (("2"
                                          (case-replace "x!1(x!2)")
                                          (("1" (inst + "0"nil nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (skosimp)
                                    (("3"
                                      (expand "member")
                                      (("3"
                                        (rewrite "emptyset_is_empty?")
                                        (("3"
                                          (rewrite
                                           "emptyset_is_empty?")
                                          (("3"
                                            (case-replace "i!1 < 1")
                                            (("1" (assertnil nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (hide 2)
            (("3" (hide -1)
              (("3"
                (case "forall (a,b:(finite_disjoint_unions(NX!1))): finite_disjoint_unions(NX!1)(intersection(a,b))")
                (("1" (case "finite_disjoint_unions(NX!1)(emptyset)")
                  (("1"
                    (case "FORALL (a: (finite_disjoint_unions(NX!1))):
        finite_disjoint_unions(NX!1)(complement(a))")
                    (("1" (expand "subset_algebra?")
                      (("1" (split)
                        (("1" (expand "subset_algebra_empty?")
                          (("1" (expand "member")
                            (("1" (propax) nil nil)) nil))
                          nil)
                         ("2" (expand "subset_algebra_complement?")
                          (("2" (skosimp)
                            (("2" (expand "member")
                              (("2" (inst - "x!1"nil nil)) nil))
                            nil))
                          nil)
                         ("3" (expand "subset_algebra_union?")
                          (("3" (expand "member")
                            (("3" (skosimp)
                              (("3"
                                (inst-cp - "y!1")
                                (("3"
                                  (inst-cp - "x!1")
                                  (("3"
                                    (inst
                                     -
                                     "complement(x!1)"
                                     "complement(y!1)")
                                    (("3"
                                      (rewrite "demorgan1" -5 :dir rl)
                                      (("3"
                                        (inst
                                         -
                                         "complement(union(x!1, y!1))")
                                        (("3"
                                          (rewrite
                                           "complement_complement")
                                          nil
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (skosimp)
                        (("2" (typepred "a!1")
                          (("2" (expand "finite_disjoint_unions" -1)
                            (("2" (expand "fullset")
                              (("2"
                                (expand "extend")
                                (("2"
                                  (prop)
                                  (("2"
                                    (expand
                                     "finite_disjoint_union?"
                                     -1)
                                    (("2"
                                      (skosimp)
                                      (("2"
                                        (expand "member")
                                        (("2"
                                          (case-replace "n!1=0")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (case-replace
                                               "a!1=emptyset")
                                              (("1"
                                                (rewrite
                                                 "complement_emptyset"
                                                 1)
                                                (("1"
                                                  (hide -1 -2 -3 -4 -5)
                                                  (("1"
                                                    (typepred "NX!1")
                                                    (("1"
                                                      (expand
                                                       "nonempty?")
                                                      (("1"
                                                        (expand
                                                         "empty?"
                                                         1)
                                                        (("1"
                                                          (skosimp)
                                                          (("1"
                                                            (expand
                                                             "member")
                                                            (("1"
                                                              (inst
                                                               -5
                                                               "x!1")
                                                              (("1"
                                                                (expand
                                                                 "finite_disjoint_union?"
                                                                 -5)
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (expand
                                                                     "member")
                                                                    (("1"
                                                                      (expand
                                                                       "finite_disjoint_unions"
                                                                       1)
                                                                      (("1"
                                                                        (expand
                                                                         "fullset"
                                                                         1
                                                                         1)
                                                                        (("1"
                                                                          (expand
                                                                           "extend")
                                                                          (("1"
                                                                            (prop)
                                                                            (("1"
                                                                              (expand
                                                                               "finite_disjoint_union?")
                                                                              (("1"
                                                                                (inst
                                                                                 +
                                                                                 "lambda i: if i = 0 then x!1 else E!2(i-1) endif"
                                                                                 "n!2+1")
                                                                                (("1"
                                                                                  (split)
                                                                                  (("1"
                                                                                    (hide-all-but
                                                                                     (-6
                                                                                      -5
                                                                                      1))
                                                                                    (("1"
                                                                                      (expand
                                                                                       "disjoint?")
                                                                                      (("1"
                                                                                        (expand
                                                                                         "disjoint?")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "intersection")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "member")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "empty?")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "member")
                                                                                                (("1"
                                                                                                  (skosimp*)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "i!1=0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "extensionality_postulate"
                                                                                                         ("f"
                                                                                                          "complement(x!1)"
                                                                                                          "g"
                                                                                                          "IUnion(E!2)"))
                                                                                                        (("1"
                                                                                                          (flatten
                                                                                                           -1)
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (split
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (hide
                                                                                                                 -6)
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "x!2")
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "complement")
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "member")
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "IUnion")
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           +
                                                                                                                           "j!1-1")
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (propax)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (case-replace
                                                                                                         "j!1=0")
                                                                                                        (("1"
                                                                                                          (lemma
                                                                                                           "extensionality_postulate"
                                                                                                           ("f"
                                                                                                            "complement(x!1)"
                                                                                                            "g"
                                                                                                            "IUnion(E!2)"))
                                                                                                          (("1"
                                                                                                            (flatten
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (hide
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (split)
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "x!2")
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "complement")
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "member")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           -4
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "IUnion")
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 +
                                                                                                                                 "i!1-1")
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (propax)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "i!1 - 1"
                                                                                                             "j!1-1")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "x!2")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (apply-extensionality
                                                                                     1
                                                                                     :hide?
                                                                                     t)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "fullset"
                                                                                       1)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "IUnion")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "complement")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "member")
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "extensionality_postulate"
                                                                                               ("f"
                                                                                                "complement(x!1)"
                                                                                                "g"
                                                                                                "IUnion(E!2)"))
                                                                                              (("1"
                                                                                                (flatten
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (split
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "x!2")
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -7)
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "complement")
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "member")
                                                                                                            (("1"
                                                                                                              (case-replace
                                                                                                               "x!1(x!2)")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   +
                                                                                                                   "0")
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "IUnion")
                                                                                                                  (("2"
                                                                                                                    (skosimp)
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       +
                                                                                                                       "i!1+1")
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (expand
                                                                                                       "IUnion")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "complement")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "member")
                                                                                                          (("2"
                                                                                                            (propax)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (skosimp)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("3"
                                                                                    (skosimp*)
                                                                                    (("3"
                                                                                      (expand
                                                                                       "member")
                                                                                      (("3"
                                                                                        (assert)
                                                                                        (("3"
                                                                                          (case-replace
                                                                                           "i!1=0")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (inst
                                                                                               -7
                                                                                               "i!1-1")
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (split)
                                                                                                    (("1"
                                                                                                      (flatten)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (flatten)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (skosimp)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (apply-extensionality
                                                 1
                                                 :hide?
                                                 t)
                                                (("2"
                                                  (expand "emptyset")
                                                  (("2"
                                                    (replace -4 -1)
                                                    (("2"
                                                      (expand "IUnion")
                                                      (("2"
                                                        (skosimp)
                                                        (("2"
                                                          (inst
                                                           -5
                                                           "i!1")
                                                          (("2"
                                                            (expand
                                                             "empty?")
                                                            (("2"
                                                              (inst
                                                               -5
                                                               "x!1")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "member")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (case "n!1>0")
                                            (("1"
                                              (hide 1)
                                              (("1"
                                                (name
                                                 "FF"
                                                 "IComplement(E!1)")
                                                (("1"
                                                  (name
                                                   "F"
                                                   "lambda n: Intersection(image(FF,{i| i<=n}))")
                                                  (("1"
                                                    (case
                                                     "F(0) = complement(E!1(0))")
                                                    (("1"
                                                      (case
                                                       "forall n: F(n+1)=intersection(F(n),complement(E!1(n+1)))")
                                                      (("1"
                                                        (case
                                                         "FORALL n: n < n!1 => finite_disjoint_unions(NX!1)(F(n))")
                                                        (("1"
                                                          (replace
                                                           -8
                                                           1)
                                                          (("1"
                                                            (lemma
                                                             "IDemorgan1")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "E!1")
                                                              (("1"
                                                                (replace
                                                                 -1
                                                                 1)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (case
                                                                     "IIntersection(IComplement(E!1))=F(n!1-1)")
                                                                    (("1"
                                                                      (replace
                                                                       -1)
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "n!1-1")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (apply-extensionality
                                                                         :hide?
                                                                         t)
                                                                        (("2"
                                                                          (expand
                                                                           "IComplement")
                                                                          (("2"
                                                                            (expand
                                                                             "IIntersection")
                                                                            (("2"
                                                                              (case-replace
                                                                               "FORALL (i_1: nat): complement(E!1(i_1))(x!1)")
                                                                              (("1"
                                                                                (expand
                                                                                 "F"
                                                                                 1)
                                                                                (("1"
                                                                                  (expand
                                                                                   "FF")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "IComplement")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "image")
                                                                                      (("1"
                                                                                        (expand
                                                                                         "Intersection")
                                                                                        (("1"
                                                                                          (skosimp)
                                                                                          (("1"
                                                                                            (typepred
                                                                                             "a!2")
                                                                                            (("1"
                                                                                              (skosimp)
                                                                                              (("1"
                                                                                                (typepred
                                                                                                 "x!2")
                                                                                                (("1"
                                                                                                  (replace
                                                                                                   -2)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -3
                                                                                                     "x!2")
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (replace
                                                                                 1
                                                                                 2)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (skosimp)
                                                                                    (("2"
                                                                                      (inst
                                                                                       -10
                                                                                       "i!1")
                                                                                      (("2"
                                                                                        (flatten)
                                                                                        (("2"
                                                                                          (case
                                                                                           "i!1<n!1")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "F"
                                                                                               -2)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "Intersection")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -2
                                                                                                   "complement(E!1(i!1))")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "FF")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "image")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "IComplement")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           +
                                                                                                           "i!1")
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "complement")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "member")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "empty?"
                                                                                                   -12)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -12
                                                                                                     "x!1")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("2"
                                                                                                        (propax)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("3"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (induct
                                                             "n")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (replace
                                                                 -3)
                                                                (("1"
                                                                  (inst
                                                                   -9
                                                                   "0")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (inst
                                                                       -13
                                                                       "E!1(0)")
                                                                      (("1"
                                                                        (expand
                                                                         "finite_disjoint_unions")
                                                                        (("1"
                                                                          (expand
                                                                           "fullset")
                                                                          (("1"
                                                                            (expand
                                                                             "extend")
                                                                            (("1"
                                                                              (prop)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (inst
                                                                   -3
                                                                   "j!1")
                                                                  (("2"
                                                                    (replace
                                                                     -3)
                                                                    (("2"
                                                                      (inst
                                                                       -10
                                                                       "1+j!1")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (inst
                                                                           -14
                                                                           "E!1(1+j!1)")
                                                                          (("2"
                                                                            (inst
                                                                             -12
                                                                             "F(j!1)"
                                                                             "complement(E!1(1 + j!1))")
                                                                            (("2"
                                                                              (hide-all-but
                                                                               (-13
                                                                                1))
                                                                              (("2"
                                                                                (expand
                                                                                 "finite_disjoint_unions")
                                                                                (("2"
                                                                                  (expand
                                                                                   "fullset")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "extend")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide-all-but
                                                         1)
                                                        (("2"
                                                          (skosimp)
                                                          (("2"
                                                            (apply-extensionality
                                                             :hide?
                                                             t)
                                                            (("2"
                                                              (expand
                                                               "F")
                                                              (("2"
                                                                (expand
                                                                 "FF")
                                                                (("2"
                                                                  (expand
                                                                   "IComplement")
                                                                  (("2"
                                                                    (expand
                                                                     "complement")
                                                                    (("2"
                                                                      (expand
                                                                       "image")
                                                                      (("2"
                                                                        (expand
                                                                         "Intersection")
                                                                        (("2"
                                                                          (expand
                                                                           "intersection")
                                                                          (("2"
                                                                            (expand
                                                                             "member")
                                                                            (("2"
                                                                              (case-replace
                                                                               "E!1(1 + n!2)(x!1)")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "complement(E!1(1+n!2))")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "complement")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "member")
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (inst
                                                                                     +
                                                                                     "1+n!2")
                                                                                    (("2"
                                                                                      (apply-extensionality
                                                                                       :hide?
                                                                                       t)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "complement")
                                                                                        (("2"
                                                                                          (propax)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (case-replace
                                                                                   "FORALL (a:
                 ({y: set[T] |
                     EXISTS (x_1: ({i | i <= 1 + n!2})):
                       y = ({x: T | NOT member(x, E!1(x_1))})})):
         a(x!1)")
                                                                                  (("1"
                                                                                    (skosimp)
                                                                                    (("1"
                                                                                      (typepred
                                                                                       "a!2")
                                                                                      (("1"
                                                                                        (skosimp)
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "a!2")
                                                                                          (("1"
                                                                                            (inst
                                                                                             +
                                                                                             "x!2")
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (replace
                                                                                     1
                                                                                     3)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           "a!2")
                                                                                          (("2"
                                                                                            (skosimp)
                                                                                            (("2"
                                                                                              (typepred
                                                                                               "x!2")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "<="
                                                                                                 -1)
                                                                                                (("2"
                                                                                                  (split
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "a!2")
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       +
                                                                                                       "x!2")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "member")
                                                                                                        (("1"
                                                                                                          (replace
                                                                                                           -2)
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "E!1(1+n!2)")
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -2
                                                                                                       2)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("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))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide-all-but
                                                       (-3 1))
                                                      (("2"
                                                        (expand "F")
                                                        (("2"
                                                          (expand "FF")
                                                          (("2"
                                                            (expand
                                                             "IComplement")
                                                            (("2"
                                                              (expand
                                                               "image")
                                                              (("2"
                                                                (expand
                                                                 "complement")
                                                                (("2"
                                                                  (expand
                                                                   "member")
                                                                  (("2"
                                                                    (apply-extensionality
                                                                     :hide?
                                                                     t)
                                                                    (("2"
                                                                      (expand
                                                                       "Intersection")
                                                                      (("2"
                                                                        (case-replace
                                                                         "E!1(0)(x!1)")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "complement(E!1(0))")
                                                                            (("1"
                                                                              (expand
                                                                               "complement")
                                                                              (("1"
                                                                                (expand
                                                                                 "member")
                                                                                (("1"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (inst
                                                                               +
                                                                               "0")
                                                                              (("2"
                                                                                (expand
                                                                                 "complement")
                                                                                (("2"
                                                                                  (expand
                                                                                   "member")
                                                                                  (("2"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (skosimp)
                                                                            (("2"
                                                                              (typepred
                                                                               "a!2")
                                                                              (("2"
                                                                                (skosimp)
                                                                                (("2"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide 2)
                    (("2" (expand "finite_disjoint_unions" 1)
                      (("2" (expand "fullset")
                        (("2" (expand "extend")
                          (("2" (prop)
                            (("2" (expand "finite_disjoint_union?")
                              (("2"
                                (inst + "lambda i: emptyset[T]" "0")
                                (("2"
                                  (split 1)
                                  (("1"
                                    (hide-all-but 1)
                                    (("1" (grind) nil nil))
                                    nil)
                                   ("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (hide-all-but 1)
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (skosimp)
                                    (("3"
                                      (assert)
                                      (("3"
                                        (rewrite "emptyset_is_empty?")
                                        nil
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide 2)
                  (("2" (skosimp)
                    (("2" (typepred "b!1")
                      (("2" (typepred "a!1")
                        (("2"
                          (expand "finite_disjoint_unions" (-1 -2 1))
                          (("2" (expand "fullset")
                            (("2" (expand "extend")
                              (("2"
                                (prop)
                                (("2"
                                  (expand
                                   "finite_disjoint_union?"
                                   (-1 -2 1))
                                  (("2"
                                    (skolem - ("AA" "mm"))
                                    (("2"
                                      (skolem - ("BB" "nn"))
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (expand "member")
                                          (("2"
                                            (case-replace "mm=0")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (inst
                                                 +
                                                 "lambda i: emptyset"
                                                 "0")
                                                (("1"
                                                  (split)
                                                  (("1"
                                                    (hide-all-but 1)
                                                    (("1"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (apply-extensionality
                                                     :hide?
                                                     t)
                                                    (("2"
                                                      (expand
                                                       "intersection")
                                                      (("2"
                                                        (expand
                                                         "IUnion")
                                                        (("2"
                                                          (expand
                                                           "emptyset")
                                                          (("2"
                                                            (expand
                                                             "member")
                                                            (("2"
                                                              (flatten)
                                                              (("2"
                                                                (replace
                                                                 -5)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (skosimp)
                                                                    (("2"
                                                                      (inst
                                                                       -6
                                                                       "i!1")
                                                                      (("2"
                                                                        (expand
                                                                         "empty?")
                                                                        (("2"
                                                                          (expand
                                                                           "member")
                                                                          (("2"
                                                                            (inst
                                                                             -6
                                                                             "x!1")
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (skosimp)
                                                    (("3"
                                                      (assert)
                                                      (("3"
                                                        (rewrite
                                                         "emptyset_is_empty?")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (case "mm>0")
                                              (("1"
                                                (hide 1)
                                                (("1"
                                                  (case-replace "nn=0")
                                                  (("1"
                                                    (inst
                                                     +
                                                     "lambda i: emptyset"
                                                     "0")
                                                    (("1"
                                                      (split)
                                                      (("1"
                                                        (hide-all-but
                                                         1)
                                                        (("1"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (apply-extensionality
                                                         :hide?
                                                         t)
                                                        (("2"
                                                          (expand
                                                           "intersection")
                                                          (("2"
                                                            (expand
                                                             "member")
                                                            (("2"
                                                              (expand
                                                               "IUnion")
                                                              (("2"
                                                                (expand
                                                                 "emptyset")
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (replace
                                                                     -9
                                                                     -1)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (skosimp)
                                                                        (("2"
                                                                          (inst
                                                                           -10
                                                                           "i!1")
                                                                          (("2"
                                                                            (expand
                                                                             "empty?")
                                                                            (("2"
                                                                              (inst
                                                                               -10
                                                                               "x!1")
                                                                              (("2"
                                                                                (expand
                                                                                 "member")
                                                                                (("2"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (skosimp)
                                                        (("3"
                                                          (assert)
                                                          (("3"
                                                            (rewrite
                                                             "emptyset_is_empty?")
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (case "nn>0")
                                                    (("1"
                                                      (hide 1)
                                                      (("1"
                                                        (inst
                                                         +
                                                         "lambda i: let n = ndiv(i,nn) in intersection(AA(n),BB(rem(nn)(i)))"
                                                         "nn*mm")
                                                        (("1"
                                                          (split)
                                                          (("1"
                                                            (expand
                                                             "disjoint?")
                                                            (("1"
                                                              (expand
                                                               "intersection")
                                                              (("1"
                                                                (expand
                                                                 "disjoint?")
                                                                (("1"
                                                                  (expand
                                                                   "intersection")
                                                                  (("1"
                                                                    (expand
                                                                     "empty?")
                                                                    (("1"
                                                                      (expand
                                                                       "member")
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (inst
                                                                           -7
                                                                           "ndiv(i!1, nn)"
                                                                           "ndiv(j!1, nn)")
                                                                          (("1"
                                                                            (inst
                                                                             -10
                                                                             "rem(nn)(i!1)"
                                                                             "rem(nn)(j!1)")
                                                                            (("1"
                                                                              (expand
                                                                               "/=")
                                                                              (("1"
                                                                                (case
                                                                                 "rem(nn)(i!1) = rem(nn)(j!1)")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -3
                                                                                     -5)
                                                                                    (("1"
                                                                                      (typepred
                                                                                       "ndiv(i!1, nn)")
                                                                                      (("1"
                                                                                        (typepred
                                                                                         "ndiv(j!1, nn)")
                                                                                        (("1"
                                                                                          (replace
                                                                                           -1
                                                                                           1)
                                                                                          (("1"
                                                                                            (replace
                                                                                             -3
                                                                                             1)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -5
                                                                                                 1)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -10
                                                                                                     "x!1")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (inst
                                                                                     -10
                                                                                     "x!1")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (apply-extensionality
                                                             1
                                                             :hide?
                                                             t)
                                                            (("1"
                                                              (expand
                                                               "IUnion")
                                                              (("1"
                                                                (expand
                                                                 "intersection")
                                                                (("1"
                                                                  (expand
                                                                   "member")
                                                                  (("1"
                                                                    (case-replace
                                                                     "a!1(x!1) AND b!1(x!1)")
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (replace
                                                                         -9
                                                                         -1)
                                                                        (("1"
                                                                          (replace
                                                                           -6
                                                                           -2)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (skosimp*)
                                                                              (("1"
                                                                                (inst
                                                                                 +
                                                                                 "i!2*nn+i!1")
                                                                                (("1"
                                                                                  (typepred
                                                                                   "ndiv(i!2 * nn + i!1, nn)")
                                                                                  (("1"
                                                                                    (case
                                                                                     "i!1<nn")
                                                                                    (("1"
                                                                                      (case
                                                                                       "i!2<mm")
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "rem(nn)(i!2 * nn + i!1) = i!1")
                                                                                        (("1"
                                                                                          (replace
                                                                                           -6)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (case-replace
                                                                                               "ndiv(i!2 * nn + i!1, nn)=i!2")
                                                                                              (("1"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "both_sides_times1")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "nn"
                                                                                                     "ndiv(i!2 * nn + i!1, nn)"
                                                                                                     "i!2")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide
                                                                                           2)
                                                                                          (("2"
                                                                                            (rewrite
                                                                                             "rem_def"
                                                                                             1)
                                                                                            (("2"
                                                                                              (inst
                                                                                               +
                                                                                               "i!2")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (inst
                                                                                         -10
                                                                                         "i!2")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "empty?")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "member")
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -10
                                                                                                 "x!1")
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (inst
                                                                                       -12
                                                                                       "i!1")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "empty?")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "member")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (inst
                                                                                               -12
                                                                                               "x!1")
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (replace
                                                                       1
                                                                       2)
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (skosimp)
                                                                          (("2"
                                                                            (replace
                                                                             -6
                                                                             1)
                                                                            (("2"
                                                                              (replace
                                                                               -9
                                                                               1)
                                                                              (("2"
                                                                                (split)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (inst
                                                                                     +
                                                                                     "rem(nn)(i!1)")
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (inst
                                                                                     +
                                                                                     "ndiv(i!1,nn)")
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("3"
                                                            (skosimp)
                                                            (("3"
                                                              (case
                                                               "rem(nn)(i!1)<nn")
                                                              (("1"
                                                                (case
                                                                 "nn*ndiv(i!1, nn) +rem(nn)(i!1) = i!1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case
                                                                     "ndiv(i!1, nn)<mm")
                                                                    (("1"
                                                                      (lemma
                                                                       "both_sides_times_pos_le1"
                                                                       ("pz"
                                                                        "nn"
                                                                        "x"
                                                                        "ndiv(i!1, nn)"
                                                                        "y"
                                                                        "mm-1"))
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (case
                                                                           "i!1<mm*nn")
                                                                          (("1"
                                                                            (inst
                                                                             -10
                                                                             "ndiv(i!1, nn)")
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide
                                                                                   -11)
                                                                                  (("1"
                                                                                    (inst
                                                                                     -13
                                                                                     "rem(nn)(i!1)")
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -14)
                                                                                          (("1"
                                                                                            (inst
                                                                                             -14
                                                                                             "AA(ndiv(i!1, nn))"
                                                                                             "BB(rem(nn)(i!1))")
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (lemma
                                                                         "both_sides_times_pos_le1"
                                                                         ("pz"
                                                                          "nn"
                                                                          "x"
                                                                          "mm"
                                                                          "y"
                                                                          "ndiv(i!1, nn)"))
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             -8
                                                                             "ndiv(i!1, nn)")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (hide-all-but
                                                                                 (-8
                                                                                  2))
                                                                                (("2"
                                                                                  (expand
                                                                                   "empty?")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "intersection")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "member")
                                                                                      (("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "x!1")
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide-all-but
                                                                   (-1
                                                                    -2
                                                                    -3
                                                                    1))
                                                                  (("2"
                                                                    (typepred
                                                                     "ndiv(i!1, nn)")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (typepred
                                                                 "rem(nn)(i!1)")
                                                                (("2"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (lemma
                                                           "le_times_le_pos"
                                                           ("nnx"
                                                            "0"
                                                            "y"
                                                            "nn-1"
                                                            "nnz"
                                                            "0"
                                                            "w"
                                                            "mm-1"))
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("3"
                                                          (skosimp)
                                                          (("3"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (expand "finite_disjoint_unions")
          (("2" (expand "fullset")
            (("2" (expand "extend")
              (("2" (expand "subset?")
                (("2" (expand "member")
                  (("2" (skosimp*)
                    (("2" (prop)
                      (("2" (expand "generated_subset_algebra")
                        (("2" (expand "Intersection")
                          (("2" (skosimp)
                            (("2" (typepred "a!1")
                              (("2"
                                (expand "finite_disjoint_union?" -3)
                                (("2"
                                  (skosimp)
                                  (("2"
                                    (expand "member")
                                    (("2"
                                      (case "forall i: a!1(E!1(i))")
                                      (("1"
                                        (name
                                         "F"
                                         "lambda n: Union(image[nat,set[T]](E!1,{i | i <= n}))")
                                        (("1"
                                          (case
                                           "forall n: F(n+1) = union(F(n),E!1(n+1))")
                                          (("1"
                                            (case
                                             "IUnion(E!1) = F(n!1)")
                                            (("1"
                                              (case
                                               "forall n: a!1(F(n))")
                                              (("1"
                                                (inst - "n!1")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide-all-but
                                                 (1 -2 -4 -5 -9))
                                                (("2"
                                                  (induct "n")
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (case-replace
                                                       "F(0)=E!1(0)")
                                                      (("1"
                                                        (inst - "0")
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (expand "F")
                                                          (("2"
                                                            (apply-extensionality
                                                             :hide?
                                                             t)
                                                            (("2"
                                                              (case-replace
                                                               "E!1(0)(x!2)")
                                                              (("1"
                                                                (expand
                                                                 "image")
                                                                (("1"
                                                                  (expand
                                                                   "Union")
                                                                  (("1"
                                                                    (inst
                                                                     +
                                                                     "E!1(0)")
                                                                    (("1"
                                                                      (inst
                                                                       +
                                                                       "0")
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "image")
                                                                  (("2"
                                                                    (expand
                                                                     "Union")
                                                                    (("2"
                                                                      (skosimp)
                                                                      (("2"
                                                                        (typepred
                                                                         "a!2")
                                                                        (("2"
                                                                          (skosimp)
                                                                          (("2"
                                                                            (typepred
                                                                             "x!3")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp)
                                                    (("2"
                                                      (inst - "j!1")
                                                      (("2"
                                                        (replace -2)
                                                        (("2"
                                                          (hide -2)
                                                          (("2"
                                                            (expand
                                                             "subset_algebra?")
                                                            (("2"
                                                              (flatten)
                                                              (("2"
                                                                (expand
                                                                 "subset_algebra_union?")
                                                                (("2"
                                                                  (expand
                                                                   "member")
                                                                  (("2"
                                                                    (inst
                                                                     -2
                                                                     "j!1+1")
                                                                    (("2"
                                                                      (inst
                                                                       -5
                                                                       "F(j!1)"
                                                                       "E!1(j!1 + 1)")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide-all-but (-8 1))
                                              (("2"
                                                (apply-extensionality
                                                 :hide?
                                                 t)
                                                (("2"
                                                  (expand "F")
                                                  (("2"
                                                    (expand "image")
                                                    (("2"
                                                      (expand "Union")
                                                      (("2"
                                                        (expand
                                                         "IUnion")
                                                        (("2"
                                                          (case-replace
                                                           "EXISTS (i: nat): E!1(i)(x!2)")
                                                          (("1"
                                                            (skosimp)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "i!1")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (rewrite
                                                                   "emptyset_is_empty?")
                                                                  (("1"
                                                                    (lemma
                                                                     "trich_lt"
                                                                     ("x"
                                                                      "i!1"
                                                                      "y"
                                                                      "n!1"))
                                                                    (("1"
                                                                      (split)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (inst
                                                                           +
                                                                           "E!1(i!1)")
                                                                          (("1"
                                                                            (inst
                                                                             +
                                                                             "i!1")
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (replace
                                                                           -4
                                                                           -2)
                                                                          (("2"
                                                                            (expand
                                                                             "emptyset")
                                                                            (("2"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("3"
                                                                        (assert)
                                                                        (("3"
                                                                          (replace
                                                                           -4
                                                                           -2)
                                                                          (("3"
                                                                            (expand
                                                                             "emptyset")
                                                                            (("3"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (replace
                                                             1
                                                             2)
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (typepred
                                                                   "a!2")
                                                                  (("2"
                                                                    (skosimp)
                                                                    (("2"
                                                                      (inst
                                                                       +
                                                                       "x!3")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide-all-but 1)
                                            (("2"
                                              (skosimp)
                                              (("2"
                                                (apply-extensionality
                                                 :hide?
                                                 t)
                                                (("2"
                                                  (expand "union")
                                                  (("2"
                                                    (expand "F")
                                                    (("2"
                                                      (expand "member")
                                                      (("2"
                                                        (expand
                                                         "image")
                                                        (("2"
                                                          (expand
                                                           "Union")
                                                          (("2"
                                                            (case-replace
                                                             "E!1(1 + n!2)(x!2)")
                                                            (("1"
                                                              (inst
                                                               +
                                                               "E!1(1+n!2)")
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "1+n!2")
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              (("2"
                                                                (case-replace
                                                                 "EXISTS (a:
                 ({y: set[T] |
                     EXISTS (x: ({i | i <= 1 + n!2})): y = E!1(x)})):
         a(x!2)")
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (typepred
                                                                     "a!2")
                                                                    (("1"
                                                                      (skosimp)
                                                                      (("1"
                                                                        (typepred
                                                                         "x!3")
                                                                        (("1"
                                                                          (expand
                                                                           "<="
                                                                           -1)
                                                                          (("1"
                                                                            (split)
                                                                            (("1"
                                                                              (inst
                                                                               +
                                                                               "E!1(x!3)")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil)
                                                                               ("2"
                                                                                (inst
                                                                                 +
                                                                                 "x!3")
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (replace
                                                                   1
                                                                   3)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (skosimp)
                                                                      (("2"
                                                                        (typepred
                                                                         "a!2")
                                                                        (("2"
                                                                          (skosimp)
                                                                          (("2"
                                                                            (inst
                                                                             +
                                                                             "E!1(x!3)")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (inst
                                                                               +
                                                                               "x!3")
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide-all-but (1 -2 -1 -5))
                                        (("2"
                                          (skosimp)
                                          (("2"
                                            (inst - "i!1")
                                            (("2"
                                              (flatten)
                                              (("2"
                                                (expand "subset?")
                                                (("2"
                                                  (inst - "E!1(i!1)")
                                                  (("2"
                                                    (expand "member")
                                                    (("2"
                                                      (expand
                                                       "subset_algebra?")
                                                      (("2"
                                                        (flatten)
                                                        (("2"
                                                          (expand
                                                           "subset_algebra_empty?")
                                                          (("2"
                                                            (expand
                                                             "member")
                                                            (("2"
                                                              (rewrite
                                                               "emptyset_is_empty?")
                                                              (("2"
                                                                (case-replace
                                                                 "i!1 < n!1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((generated_subset_algebra const-decl "subset_algebra"
     subset_algebra_def nil)
    (subset_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (nonempty? const-decl "bool" sets nil)
    (finite_disjoint_unions const-decl "setofsets[T]"
     subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (subset? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (subset_antisymmetric formula-decl nil sets_lemmas nil)
    (extend const-decl "R" extend nil)
    (member const-decl "bool" sets nil)
    (finite_disjoint_union? const-decl "bool" subset_algebra_def nil)
    (intersection const-decl "set" sets nil)
    (empty? const-decl "bool" sets nil)
    (disjoint? const-decl "bool" sets nil)
    (disjoint? const-decl "bool" indexed_sets_aux "sets_aux/")
    (IUnion const-decl "set[T]" indexed_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (emptyset_is_empty? formula-decl nil sets_lemmas nil)
    (emptyset const-decl "set" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sequence type-eq-decl nil sequences 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)
    (fullset const-decl "set" sets nil)
    (le_times_le_pos formula-decl nil real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (rem_def formula-decl nil modulo_arithmetic nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (ndiv const-decl "{q: int | x = b * q + rem(b)(x)}"
     modulo_arithmetic nil)
    (rem const-decl "{r: mod(b) | EXISTS q: x = b * q + r}"
         modulo_arithmetic nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mod nonempty-type-eq-decl nil euclidean_division nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nn skolem-const-decl "nat" subset_algebra_def nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nil application-judgement "upto(n)" modulo_arithmetic nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (x!1 skolem-const-decl "set[T]" subset_algebra_def nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (extensionality_postulate formula-decl nil functions nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (complement_emptyset formula-decl nil sets_lemmas nil)
    (Intersection const-decl "set" sets nil)
    (image const-decl "set[R]" function_image nil)
    (<= const-decl "bool" reals nil)
    (Intersection_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (j!1 skolem-const-decl "nat" subset_algebra_def nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (FF skolem-const-decl "[nat -> set[T]]" subset_algebra_def nil)
    (F skolem-const-decl "[nat -> set[T]]" subset_algebra_def nil)
    (E!1 skolem-const-decl "sequence[set[T]]" subset_algebra_def nil)
    (i!1 skolem-const-decl "nat" subset_algebra_def nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (n!1 skolem-const-decl "nat" subset_algebra_def nil)
    (IIntersection const-decl "set[T]" indexed_sets nil)
    (IDemorgan1 formula-decl nil indexed_sets_aux "sets_aux/")
    (n!2 skolem-const-decl "nat" subset_algebra_def nil)
    (a!2 skolem-const-decl "({y: set[T] |
    EXISTS (x_1: ({i | i <= n!2})): y = ({x | NOT member(x, E!1(x_1))})})"
     subset_algebra_def nil)
    (x!2 skolem-const-decl "({i | i <= 1 + n!2})" subset_algebra_def
     nil)
    (a!2 skolem-const-decl "({y: set[T] |
    EXISTS (x_1: ({i | i <= 1 + n!2})):
      y = ({x: T | NOT member(x, E!1(x_1))})})" subset_algebra_def nil)
    (IComplement const-decl "set[T]" indexed_sets_aux "sets_aux/")
    (> const-decl "bool" reals nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil)
    (demorgan1 formula-decl nil sets_lemmas nil)
    (complement_complement formula-decl nil sets_lemmas nil)
    (union const-decl "set" sets nil)
    (y!1 skolem-const-decl "(finite_disjoint_unions(NX!1))"
     subset_algebra_def nil)
    (x!1 skolem-const-decl "(finite_disjoint_unions(NX!1))"
     subset_algebra_def nil)
    (NX!1 skolem-const-decl "(nonempty?[set[T]])" subset_algebra_def
     nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (complement const-decl "set" sets nil)
    (/= const-decl "boolean" notequal nil)
    (finite_intersection2 application-judgement "finite_set[T]"
     countable_props "sets_aux/")
    (generated_subset_algebra_subset2 formula-decl nil
     subset_algebra_def nil)
    (n!1 skolem-const-decl "nat" subset_algebra_def nil)
    (i!1 skolem-const-decl "nat" subset_algebra_def nil)
    (trich_lt formula-decl nil real_props nil)
    (F skolem-const-decl "[nat -> set[T]]" subset_algebra_def nil)
    (TRUE const-decl "bool" booleans nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (a!1 skolem-const-decl
     "({Y | subset_algebra?(Y) AND subset?(NX!1, Y)})"
     subset_algebra_def nil)
    (j!1 skolem-const-decl "nat" subset_algebra_def nil)
    (E!1 skolem-const-decl "sequence[set[T]]" subset_algebra_def nil)
    (x!3 skolem-const-decl "({i | i <= n!2})" subset_algebra_def nil)
    (x!3 skolem-const-decl "({i | i <= 1 + n!2})" subset_algebra_def
     nil)
    (n!2 skolem-const-decl "nat" subset_algebra_def nil)
    (Union const-decl "set" sets nil))
   shostak))
 (monotone_class_TCC1 0
  (monotone_class_TCC1-1 nil 3449748022
   ("" (expand "monotone?")
    (("" (skosimp)
      (("" (split)
        (("1" (flatten)
          (("1" (expand "member")
            (("1" (expand "trivial_subset_algebra")
              (("1" (expand "union")
                (("1" (expand "member")
                  (("1" (flatten)
                    (("1" (expand "singleton")
                      (("1" (case "forall n: E!1(n) = emptyset[T]")
                        (("1" (hide 2)
                          (("1" (expand "IUnion")
                            (("1" (apply-extensionality :hide? t)
                              (("1"
                                (expand "emptyset")
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (inst - "i!1")
                                    (("1"
                                      (replace -2 -1)
                                      (("1" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (skosimp)
                            (("2" (inst - "n!1")
                              (("2"
                                (assert)
                                (("2"
                                  (hide-all-but (-2 3))
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (expand "fullset")
                                      (("2"
                                        (expand "IUnion")
                                        (("2"
                                          (inst + "n!1")
                                          (("2"
                                            (replace -1 1)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (flatten)
          (("2" (expand "member")
            (("2" (expand "trivial_subset_algebra")
              (("2" (expand "union")
                (("2" (expand "member")
                  (("2" (expand "singleton")
                    (("2" (flatten)
                      (("2" (case "forall n: E!1(n) = fullset[T]")
                        (("1" (hide-all-but (-1 2))
                          (("1" (expand "fullset")
                            (("1" (expand "IIntersection")
                              (("1"
                                (apply-extensionality :hide? t)
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (inst - "i!1")
                                    (("1"
                                      (replace -1)
                                      (("1" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (skosimp)
                          (("2" (inst - "n!1")
                            (("2" (assert)
                              (("2"
                                (hide-all-but (-2 2))
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (expand "emptyset")
                                    (("2"
                                      (expand "IIntersection")
                                      (("2"
                                        (inst - "n!1")
                                        (("2"
                                          (replace -2 -1)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((IIntersection const-decl "set[T]" indexed_sets nil)
    (TRUE const-decl "bool" booleans nil)
    (trivial_subset_algebra const-decl "(subset_algebra?)"
     subset_algebra_def nil)
    (singleton const-decl "(singleton?)" sets nil)
    (fullset const-decl "set" sets nil)
    (IUnion const-decl "set[T]" indexed_sets nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (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 subset_algebra_def nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (sequence type-eq-decl nil sequences nil)
    (emptyset const-decl "set" sets nil)
    (union const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (monotone? const-decl "bool" subset_algebra_def nil))
   nil))
 (powerset_is_monotone 0
  (powerset_is_monotone-1 nil 3449818847
   ("" (expand "monotone?")
    (("" (skosimp)
      (("" (expand "member")
        (("" (split)
          (("1" (flatten)
            (("1" (expand "fullset")
              (("1" (expand "powerset")
                (("1" (expand "subset?")
                  (("1" (expand "member") (("1" (propax) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (flatten)
            (("2" (expand "fullset")
              (("2" (expand "powerset")
                (("2" (expand "subset?")
                  (("2" (expand "member") (("2" (propax) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((fullset const-decl "set" sets nil)
    (subset? const-decl "bool" sets nil)
    (powerset const-decl "setofsets" sets nil)
    (member const-decl "bool" sets nil)
    (monotone? const-decl "bool" subset_algebra_def nil))
   shostak))
 (sigma_algebra_is_monotone_class 0
  (sigma_algebra_is_monotone_class-1 nil 3449769838
   ("" (skolem + "A!1")
    (("" (typepred "A!1")
      (("" (expand "monotone?")
        (("" (skosimp)
          (("" (split)
            (("1" (expand "member")
              (("1" (skosimp)
                (("1" (expand "sigma_algebra?")
                  (("1" (flatten)
                    (("1" (expand "sigma_algebra_union?")
                      (("1" (inst - "image(E!1,fullset[nat])")
                        (("1" (split -4)
                          (("1" (expand "member")
                            (("1"
                              (case-replace
                               "Union(image(E!1, fullset[nat]))=IUnion(E!1)")
                              (("1"
                                (hide-all-but 1)
                                (("1"
                                  (apply-extensionality :hide? t)
                                  (("1"
                                    (expand "IUnion")
                                    (("1"
                                      (expand "fullset")
                                      (("1"
                                        (expand "image")
                                        (("1"
                                          (expand "Union")
                                          (("1"
                                            (case-replace
                                             "EXISTS (i: nat): E!1(i)(x!1)")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (inst + "E!1(i!1)")
                                                (("1"
                                                  (inst + "i!1")
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (replace 1 2)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (skosimp)
                                                  (("2"
                                                    (typepred "a!1")
                                                    (("2"
                                                      (skosimp)
                                                      (("2"
                                                        (replace -1 -2)
                                                        (("2"
                                                          (inst
                                                           +
                                                           "x!2")
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide-all-but 1)
                            (("2" (lemma "countable_image[nat,set[T]]")
                              (("2"
                                (inst - "fullset[nat]" "E!1")
                                (("2"
                                  (split)
                                  (("1"
                                    (expand "image" -1)
                                    (("1" (propax) nil nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (expand "fullset")
                                      (("2"
                                        (expand "is_countable")
                                        (("2"
                                          (inst + "lambda (n:nat): n")
                                          (("2"
                                            (expand "injective?")
                                            (("2" (skosimp) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (hide 2)
                            (("3" (skosimp)
                              (("3"
                                (typepred "x!1")
                                (("3"
                                  (expand "member")
                                  (("3"
                                    (expand "fullset")
                                    (("3"
                                      (expand "image")
                                      (("3"
                                        (skosimp)
                                        (("3"
                                          (replace -1)
                                          (("3"
                                            (inst - "x!2")
                                            nil
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (flatten)
              (("2" (expand "member")
                (("2" (expand "sigma_algebra?")
                  (("2" (flatten)
                    (("2" (expand "subset_algebra_complement?")
                      (("2" (expand "member")
                        (("2"
                          (inst-cp - "complement(IIntersection(E!1))")
                          (("1" (rewrite "complement_complement"nil
                            nil)
                           ("2" (hide 2)
                            (("2" (rewrite "IDemorgan2" +)
                              (("2"
                                (expand "sigma_algebra_union?")
                                (("2"
                                  (inst
                                   -
                                   "image(IComplement(E!1),fullset[nat])")
                                  (("2"
                                    (expand "member")
                                    (("2"
                                      (split -3)
                                      (("1"
                                        (case-replace
                                         "Union(image(IComplement(E!1), fullset[nat]))=IUnion(IComplement(E!1))")
                                        (("1"
                                          (hide-all-but 1)
                                          (("1"
                                            (apply-extensionality
                                             :hide?
                                             t)
                                            (("1"
                                              (expand "fullset")
                                              (("1"
                                                (expand "IComplement")
                                                (("1"
                                                  (expand "complement")
                                                  (("1"
                                                    (expand "member")
                                                    (("1"
                                                      (expand "image")
                                                      (("1"
                                                        (expand
                                                         "IUnion")
                                                        (("1"
                                                          (expand
                                                           "Union")
                                                          (("1"
                                                            (case-replace
                                                             "(EXISTS (i_1: nat): NOT E!1(i_1)(x!1))")
                                                            (("1"
                                                              (skosimp)
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "complement(E!1(i!1))")
                                                                (("1"
                                                                  (expand
                                                                   "complement")
                                                                  (("1"
                                                                    (expand
                                                                     "member")
                                                                    (("1"
                                                                      (propax)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "complement")
                                                                  (("2"
                                                                    (expand
                                                                     "member")
                                                                    (("2"
                                                                      (inst
                                                                       +
                                                                       "i!1")
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (replace
                                                               1
                                                               2)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (typepred
                                                                     "a!1")
                                                                    (("2"
                                                                      (skosimp)
                                                                      (("2"
                                                                        (replace
                                                                         -1)
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             +
                                                                             "x!2")
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide-all-but 1)
                                        (("2"
                                          (lemma
                                           "countable_image[nat,set[T]]")
                                          (("2"
                                            (inst
                                             -
                                             "fullset[nat]"
                                             "IComplement(E!1)")
                                            (("2"
                                              (split)
                                              (("1"
                                                (expand "image" -1)
                                                (("1"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "fullset")
                                                  (("2"
                                                    (expand
                                                     "is_countable")
                                                    (("2"
                                                      (inst
                                                       +
                                                       "lambda (n:nat): n")
                                                      (("2"
                                                        (expand
                                                         "injective?")
                                                        (("2"
                                                          (skosimp)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("3"
                                        (skosimp)
                                        (("3"
                                          (typepred "x!1")
                                          (("3"
                                            (expand "fullset")
                                            (("3"
                                              (expand "image")
                                              (("3"
                                                (skosimp)
                                                (("3"
                                                  (expand
                                                   "IComplement")
                                                  (("3"
                                                    (replace -1)
                                                    (("3"
                                                      (hide-all-but
                                                       (1 -4))
                                                      (("3"
                                                        (typepred
                                                         "A!1")
                                                        (("3"
                                                          (expand
                                                           "sigma_algebra?")
                                                          (("3"
                                                            (flatten)
                                                            (("3"
                                                              (expand
                                                               "subset_algebra_complement?")
                                                              (("3"
                                                                (expand
                                                                 "member")
                                                                (("3"
                                                                  (inst
                                                                   -
                                                                   "E!1(x!2)")
                                                                  (("3"
                                                                    (inst
                                                                     -
                                                                     "x!2")
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (IIntersection const-decl "set[T]" indexed_sets nil)
    (complement const-decl "set" sets nil)
    (A!1 skolem-const-decl "sigma_algebra" subset_algebra_def nil)
    (complement_complement formula-decl nil sets_lemmas nil)
    (IDemorgan2 formula-decl nil indexed_sets_aux "sets_aux/")
    (IComplement const-decl "set[T]" indexed_sets_aux "sets_aux/")
    (i!1 skolem-const-decl "nat" subset_algebra_def nil)
    (x!2 skolem-const-decl "({x | TRUE})" subset_algebra_def nil)
    (member const-decl "bool" sets nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (IUnion const-decl "set[T]" indexed_sets nil)
    (Union const-decl "set" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (i!1 skolem-const-decl "nat" subset_algebra_def nil)
    (E!1 skolem-const-decl "sequence[set[T]]" subset_algebra_def nil)
    (TRUE const-decl "bool" booleans nil)
    (countable_image formula-decl nil countable_image "sets_aux/")
    (image const-decl "set[R]" function_image nil)
    (injective? const-decl "bool" functions nil)
    (is_countable const-decl "bool" countability "sets_aux/")
    (fullset const-decl "set" sets nil)
    (sequence type-eq-decl nil sequences nil)
    (image const-decl "set[R]" function_image nil)
    (set type-eq-decl nil sets 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)
    (monotone? const-decl "bool" subset_algebra_def nil))
   nil))
 (monotone_algebra_is_sigma 0
  (monotone_algebra_is_sigma-1 nil 3449799687
   ("" (skosimp)
    (("" (expand "subset_algebra?")
      (("" (expand "sigma_algebra?")
        (("" (flatten)
          (("" (split)
            (("1" (propax) nil nil) ("2" (propax) nil nil)
             ("3" (expand "sigma_algebra_union?")
              (("3" (skolem + "Y!1")
                (("3" (flatten)
                  (("3" (lemma "Union_IUnion[T]" ("XS" "Y!1"))
                    (("3" (assert)
                      (("3" (skosimp)
                        (("3" (replace -1)
                          (("3" (expand "member")
                            (("3" (expand "monotone?")
                              (("3"
                                (expand "member")
                                (("3"
                                  (lemma
                                   "increasing_IUnion"
                                   ("A" "YS!1"))
                                  (("3"
                                    (skosimp)
                                    (("3"
                                      (inst -12 "B!1")
                                      (("3"
                                        (replace -1)
                                        (("3"
                                          (split -12)
                                          (("1"
                                            (flatten)
                                            (("1" (assertnil nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (induct "n")
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (inst -6 "0")
                                                  (("1"
                                                    (split -6)
                                                    (("1"
                                                      (expand
                                                       "subset_algebra_empty?")
                                                      (("1"
                                                        (expand
                                                         "member")
                                                        (("1"
                                                          (rewrite
                                                           "emptyset_is_empty?")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst
                                                       -8
                                                       "YS!1(0)")
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (skosimp)
                                                (("2"
                                                  (inst -4 "j!1")
                                                  (("2"
                                                    (replace -4)
                                                    (("2"
                                                      (inst -7 "j!1+1")
                                                      (("2"
                                                        (split -7)
                                                        (("1"
                                                          (rewrite
                                                           "emptyset_is_empty?")
                                                          (("1"
                                                            (expand
                                                             "subset_algebra_empty?")
                                                            (("1"
                                                              (expand
                                                               "member")
                                                              (("1"
                                                                (expand
                                                                 "subset_algebra_union?")
                                                                (("1"
                                                                  (expand
                                                                   "member")
                                                                  (("1"
                                                                    (inst
                                                                     -12
                                                                     "B!1(j!1)"
                                                                     "YS!1(j!1 + 1)")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (inst
                                                           -9
                                                           "YS!1(j!1 + 1)")
                                                          (("1"
                                                            (expand
                                                             "subset_algebra_union?")
                                                            (("1"
                                                              (expand
                                                               "member")
                                                              (("1"
                                                                (inst
                                                                 -12
                                                                 "B!1(j!1)"
                                                                 "YS!1(j!1 + 1)")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((subset_algebra? const-decl "bool" subset_algebra_def nil)
    (sigma_algebra_union? const-decl "bool" subset_algebra_def nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (monotone? const-decl "bool" subset_algebra_def nil)
    (sequence type-eq-decl nil sequences nil)
    (set type-eq-decl nil sets 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)
    (increasing_IUnion formula-decl nil nat_indexed_sets "sets_aux/")
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (Y!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (YS!1 skolem-const-decl "sequence[set[T]]" subset_algebra_def nil)
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (emptyset_is_empty? formula-decl nil sets_lemmas nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (j!1 skolem-const-decl "nat" subset_algebra_def nil)
    (B!1 skolem-const-decl "sequence[set[T]]" subset_algebra_def nil)
    (X!1 skolem-const-decl "setofsets[T]" subset_algebra_def nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (member const-decl "bool" sets nil)
    (Union_IUnion formula-decl nil countable_indexed_sets "sets_aux/")
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil))
   shostak))
 (monotone_class_Intersection 0
  (monotone_class_Intersection-1 nil 3449803550
   ("" (skosimp)
    (("" (expand "extend")
      (("" (expand "Intersection")
        (("" (expand "monotone?" 1 1)
          (("" (skosimp*)
            (("" (expand "member")
              (("" (split)
                (("1" (flatten)
                  (("1" (skosimp)
                    (("1" (typepred "a!1")
                      (("1" (assert)
                        (("1" (expand "monotone?")
                          (("1" (expand "member")
                            (("1" (inst - "E!1")
                              (("1"
                                (split -2)
                                (("1"
                                  (flatten)
                                  (("1" (assertnil nil))
                                  nil)
                                 ("2"
                                  (skosimp)
                                  (("2"
                                    (inst - "n!1")
                                    (("2" (inst - "a!1"nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (flatten)
                  (("2" (skosimp)
                    (("2" (typepred "a!1")
                      (("2" (assert)
                        (("2" (expand "monotone?")
                          (("2" (inst - "E!1")
                            (("2" (split -2)
                              (("1"
                                (flatten)
                                (("1"
                                  (expand "member")
                                  (("1" (propax) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp)
                                (("2"
                                  (expand "member")
                                  (("2"
                                    (inst - "n!1")
                                    (("2" (inst - "a!1"nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((extend const-decl "R" extend nil)
    (monotone? const-decl "bool" subset_algebra_def nil)
    (member const-decl "bool" sets nil)
    (FALSE const-decl "bool" booleans nil)
    (set type-eq-decl nil sets nil)
    (monotone_class nonempty-type-eq-decl nil subset_algebra_def nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (T formal-type-decl nil subset_algebra_def nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (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)
    (sequence type-eq-decl nil sequences nil)
    (Intersection const-decl "set" sets nil))
   shostak))
 (monotone_class 0
  (monotone_class-1 nil 3449748340
   ("" (skolem + ("A!1" "C!1"))
    (("" (flatten)
      (("" (typepred "A!1")
        (("" (typepred "C!1")
          (("" (name "MM" "{C | subset?(A!1, C)}")
            (("" (case "nonempty?(MM)")
              (("1" (lemma "monotone_class_Intersection" ("K" "MM"))
                (("1" (expand "extend")
                  (("1"
                    (name "M" "Intersection(LAMBDA (t: setof[setof[T]]):
                               IF monotone?(t) THEN MM(t) ELSE FALSE ENDIF)")
                    (("1" (case "subset?(A!1,M)")
                      (("1" (case "subset?(M,C!1)")
                        (("1"
                          (case "subset?(M,generated_sigma_algebra(A!1))")
                          (("1"
                            (case "subset?(generated_sigma_algebra(A!1), M)")
                            (("1"
                              (lemma "subset_antisymmetric"
                               ("a"
                                "generated_sigma_algebra(A!1)"
                                "b"
                                "M"))
                              (("1" (assertnil nil)) nil)
                             ("2" (hide 2)
                              (("2"
                                (lemma
                                 "monotone_algebra_is_sigma"
                                 ("X" "M"))
                                (("2"
                                  (replace -5 -6)
                                  (("2"
                                    (replace -6 -1)
                                    (("2"
                                      (split -1)
                                      (("1"
                                        (lemma
                                         "generated_sigma_algebra_subset2"
                                         ("X" "A!1" "Y" "M"))
                                        (("1" (assertnil nil))
                                        nil)
                                       ("2"
                                        (hide 2)
                                        (("2"
                                          (expand "subset_algebra?")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (name
                                               "KK"
                                               "lambda (a:set[T]): {b:set[T] | M(union(a,b)) & M(difference(a,b)) & M(difference(b,a))}")
                                              (("2"
                                                (case
                                                 "forall (a,b:set[T]): KK(a)(b) iff KK(b)(a)")
                                                (("1"
                                                  (case
                                                   "FORALL (a, b: (A!1)): KK(b)(a)")
                                                  (("1"
                                                    (case-replace
                                                     "subset_algebra_empty?(M)")
                                                    (("1"
                                                      (case
                                                       "forall (b:set[T]): monotone?(KK(b))")
                                                      (("1"
                                                        (case
                                                         "forall (x:(A!1)): subset?(A!1,KK(x))")
                                                        (("1"
                                                          (case
                                                           "forall (b:(A!1)): subset?(M,KK(b))")
                                                          (("1"
                                                            (case
                                                             "forall (a,b:(M)): M(union(a, b)) & M(difference(a, b)) & M(difference(b, a))")
                                                            (("1"
                                                              (split 1)
                                                              (("1"
                                                                (expand
                                                                 "subset_algebra_complement?")
                                                                (("1"
                                                                  (expand
                                                                   "member")
                                                                  (("1"
                                                                    (skosimp)
                                                                    (("1"
                                                                      (typepred
                                                                       "x!1")
                                                                      (("1"
                                                                        (expand
                                                                         "subset_algebra_empty?"
                                                                         -18)
                                                                        (("1"
                                                                          (expand
                                                                           "member")
                                                                          (("1"
                                                                            (inst-cp
                                                                             -19
                                                                             "emptyset[T]")
                                                                            (("1"
                                                                              (rewrite
                                                                               "complement_emptyset")
                                                                              (("1"
                                                                                (expand
                                                                                 "subset?"
                                                                                 -12)
                                                                                (("1"
                                                                                  (inst
                                                                                   -12
                                                                                   "fullset[T]")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "member")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -2
                                                                                         "fullset[T]"
                                                                                         "x!1")
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (rewrite
                                                                                             "difference_fullset2")
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "subset_algebra_union?")
                                                                (("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (inst
                                                                     -1
                                                                     "x!1"
                                                                     "y!1")
                                                                    (("2"
                                                                      (expand
                                                                       "member")
                                                                      (("2"
                                                                        (flatten)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (typepred
                                                                   "a!1")
                                                                  (("2"
                                                                    (typepred
                                                                     "b!1")
                                                                    (("2"
                                                                      (case
                                                                       "forall (a:(M)): subset?(A!1,KK(a))")
                                                                      (("1"
                                                                        (case
                                                                         "FORALL (a: (M)): subset?(M, KK(a))")
                                                                        (("1"
                                                                          (hide-all-but
                                                                           (-1
                                                                            1
                                                                            -3
                                                                            -4))
                                                                          (("1"
                                                                            (expand
                                                                             "subset?")
                                                                            (("1"
                                                                              (expand
                                                                               "KK")
                                                                              (("1"
                                                                                (expand
                                                                                 "member")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "a!1")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "b!1")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (skosimp)
                                                                            (("2"
                                                                              (typepred
                                                                               "a!2")
                                                                              (("2"
                                                                                (inst
                                                                                 -2
                                                                                 "a!2")
                                                                                (("2"
                                                                                  (expand
                                                                                   "subset?"
                                                                                   1)
                                                                                  (("2"
                                                                                    (skosimp)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "member")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "M"
                                                                                         -2)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "Intersection"
                                                                                           -2)
                                                                                          (("2"
                                                                                            (inst
                                                                                             -2
                                                                                             "KK(a!2)")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -7
                                                                                               "a!2")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "MM"
                                                                                                   1)
                                                                                                  (("2"
                                                                                                    (propax)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         2)
                                                                        (("2"
                                                                          (skosimp)
                                                                          (("2"
                                                                            (typepred
                                                                             "a!2")
                                                                            (("2"
                                                                              (expand
                                                                               "subset?"
                                                                               1)
                                                                              (("2"
                                                                                (skosimp)
                                                                                (("2"
                                                                                  (expand
                                                                                   "member")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -5
                                                                                     "x!1")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "subset?"
                                                                                       -5)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "member")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -5
                                                                                           "a!2")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (inst
                                                                                               -10
                                                                                               "a!2"
                                                                                               "x!1")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (skosimp)
                                                              (("2"
                                                                (typepred
                                                                 "b!1")
                                                                (("2"
                                                                  (inst
                                                                   -3
                                                                   "b!1")
                                                                  (("2"
                                                                    (expand
                                                                     "subset?"
                                                                     1)
                                                                    (("2"
                                                                      (skosimp)
                                                                      (("2"
                                                                        (expand
                                                                         "member")
                                                                        (("2"
                                                                          (replace
                                                                           -12
                                                                           -2
                                                                           rl)
                                                                          (("2"
                                                                            (expand
                                                                             "Intersection"
                                                                             -2)
                                                                            (("2"
                                                                              (inst
                                                                               -2
                                                                               "KK(b!1)")
                                                                              (("2"
                                                                                (replace
                                                                                 -3)
                                                                                (("2"
                                                                                  (hide
                                                                                   2)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "MM"
                                                                                     1)
                                                                                    (("2"
                                                                                      (inst
                                                                                       -2
                                                                                       "b!1")
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (skosimp)
                                                            (("2"
                                                              (expand
                                                               "subset?"
                                                               1)
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (expand
                                                                   "member")
                                                                  (("2"
                                                                    (typepred
                                                                     "x!1")
                                                                    (("2"
                                                                      (inst
                                                                       -5
                                                                       "x!2"
                                                                       "x!1")
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide -1 2)
                                                        (("2"
                                                          (skosimp)
                                                          (("2"
                                                            (expand
                                                             "monotone?"
                                                             1)
                                                            (("2"
                                                              (skosimp)
                                                              (("2"
                                                                (expand
                                                                 "member")
                                                                (("2"
                                                                  (hide
                                                                   -4
                                                                   -8)
                                                                  (("2"
                                                                    (split
                                                                     1)
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (hide-all-but
                                                                         (-1
                                                                          -2
                                                                          -8
                                                                          -12
                                                                          -13
                                                                          -14
                                                                          1))
                                                                        (("1"
                                                                          (expand
                                                                           "KK")
                                                                          (("1"
                                                                            (expand
                                                                             "monotone?")
                                                                            (("1"
                                                                              (expand
                                                                               "member")
                                                                              (("1"
                                                                                (split
                                                                                 1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -3
                                                                                   "lambda n: union(b!1, E!1(n))")
                                                                                  (("1"
                                                                                    (split
                                                                                     -3)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -2)
                                                                                        (("1"
                                                                                          (split
                                                                                           -1)
                                                                                          (("1"
                                                                                            (case-replace
                                                                                             "IUnion(LAMBDA n: union(b!1, E!1(n))) = union(b!1, IUnion(E!1))")
                                                                                            (("1"
                                                                                              (hide-all-but
                                                                                               1)
                                                                                              (("1"
                                                                                                (apply-extensionality
                                                                                                 :hide?
                                                                                                 t)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "union")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "member")
                                                                                                    (("1"
                                                                                                      (case-replace
                                                                                                       "b!1(x!1)")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "IUnion")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           +
                                                                                                           "0")
                                                                                                          (("1"
                                                                                                            (flatten)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "IUnion")
                                                                                                          (("2"
                                                                                                            (propax)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              1))
                                                                                            (("2"
                                                                                              (expand
                                                                                               "union")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "increasing?")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "subset?")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "member")
                                                                                                    (("2"
                                                                                                      (skosimp*)
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "x!1"
                                                                                                         "y!1")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "x!2")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       2)
                                                                                      (("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "n!1")
                                                                                          (("2"
                                                                                            (flatten)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (inst
                                                                                   -3
                                                                                   "lambda n: difference(b!1, E!1(n))")
                                                                                  (("2"
                                                                                    (split
                                                                                     -3)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("1"
                                                                                          (split
                                                                                           -1)
                                                                                          (("1"
                                                                                            (case-replace
                                                                                             "IIntersection(LAMBDA n: difference(b!1, E!1(n)))=difference(b!1, IUnion(E!1))")
                                                                                            (("1"
                                                                                              (hide-all-but
                                                                                               1)
                                                                                              (("1"
                                                                                                (apply-extensionality
                                                                                                 :hide?
                                                                                                 t)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "difference")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "member")
                                                                                                    (("1"
                                                                                                      (case-replace
                                                                                                       "b!1(x!1)")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "IIntersection")
                                                                                                          (("1"
                                                                                                            (case-replace
                                                                                                             "IUnion(E!1)(x!1)")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "IUnion")
                                                                                                                (("1"
                                                                                                                  (skosimp)
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "i!1")
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (skosimp)
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "IUnion")
                                                                                                                  (("2"
                                                                                                                    (inst
                                                                                                                     +
                                                                                                                     "i!1")
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "IIntersection")
                                                                                                          (("2"
                                                                                                            (propax)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              1))
                                                                                            (("2"
                                                                                              (expand
                                                                                               "decreasing?")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "increasing?")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "difference")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "subset?")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "x!1"
                                                                                                           "y!1")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "x!2")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (skosimp)
                                                                                      (("2"
                                                                                        (inst
                                                                                         -2
                                                                                         "n!1")
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (inst
                                                                                   -3
                                                                                   "lambda n: difference(E!1(n),b!1)")
                                                                                  (("3"
                                                                                    (split
                                                                                     -3)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -2)
                                                                                        (("1"
                                                                                          (split
                                                                                           -1)
                                                                                          (("1"
                                                                                            (case-replace
                                                                                             "IUnion(LAMBDA n: difference(E!1(n), b!1))=difference(IUnion(E!1), b!1)")
                                                                                            (("1"
                                                                                              (hide-all-but
                                                                                               1)
                                                                                              (("1"
                                                                                                (apply-extensionality
                                                                                                 :hide?
                                                                                                 t)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "difference")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "member")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "IUnion")
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "b!1(x!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              1))
                                                                                            (("2"
                                                                                              (expand
                                                                                               "increasing?")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "difference")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "subset?")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "member")
                                                                                                    (("2"
                                                                                                      (skosimp*)
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "x!1"
                                                                                                         "y!1")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "x!2")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (skosimp)
                                                                                      (("2"
                                                                                        (inst
                                                                                         -2
                                                                                         "n!1")
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (expand
                                                                         "KK")
                                                                        (("2"
                                                                          (hide
                                                                           -3
                                                                           -4)
                                                                          (("2"
                                                                            (expand
                                                                             "monotone?"
                                                                             -6)
                                                                            (("2"
                                                                              (hide-all-but
                                                                               (-1
                                                                                -2
                                                                                -6
                                                                                1))
                                                                              (("2"
                                                                                (split)
                                                                                (("1"
                                                                                  (inst
                                                                                   -3
                                                                                   "lambda n: union(b!1,E!1(n))")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "member")
                                                                                    (("1"
                                                                                      (split
                                                                                       -3)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -1)
                                                                                          (("1"
                                                                                            (split
                                                                                             -1)
                                                                                            (("1"
                                                                                              (case-replace
                                                                                               "IIntersection(LAMBDA n: union(b!1, E!1(n)))=union(b!1, IIntersection(E!1))")
                                                                                              (("1"
                                                                                                (hide-all-but
                                                                                                 1)
                                                                                                (("1"
                                                                                                  (apply-extensionality
                                                                                                   :hide?
                                                                                                   t)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "union")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "IIntersection")
                                                                                                        (("1"
                                                                                                          (case-replace
                                                                                                           "b!1(x!1)")
                                                                                                          (("1"
                                                                                                            (skosimp)
                                                                                                            nil
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide-all-but
                                                                                               (-1
                                                                                                1))
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "union")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "decreasing?")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "subset?")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "x!1"
                                                                                                           "y!1")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "x!2")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "n!1")
                                                                                          (("2"
                                                                                            (flatten)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (inst
                                                                                   -3
                                                                                   "lambda n: difference(b!1, E!1(n))")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "member")
                                                                                    (("2"
                                                                                      (split
                                                                                       -3)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -2)
                                                                                          (("1"
                                                                                            (split
                                                                                             -1)
                                                                                            (("1"
                                                                                              (case-replace
                                                                                               "IUnion(LAMBDA n: difference(b!1, E!1(n)))=difference(b!1, IIntersection(E!1))")
                                                                                              (("1"
                                                                                                (hide-all-but
                                                                                                 1)
                                                                                                (("1"
                                                                                                  (apply-extensionality
                                                                                                   :hide?
                                                                                                   t)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "difference")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "b!1(x!1)")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "IUnion")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (case-replace
                                                                                                               "IIntersection(E!1)(x!1)")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "IIntersection")
                                                                                                                  (("1"
                                                                                                                    (skosimp)
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "i!1")
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "IIntersection")
                                                                                                                  (("2"
                                                                                                                    (skosimp)
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       +
                                                                                                                       "i!1")
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "IUnion")
                                                                                                            (("2"
                                                                                                              (propax)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide-all-but
                                                                                               (-1
                                                                                                1))
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "decreasing?")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "increasing?")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "difference")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "subset?")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "member")
                                                                                                        (("2"
                                                                                                          (skosimp*)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "x!1"
                                                                                                             "y!1")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "x!2")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "n!1")
                                                                                          (("2"
                                                                                            (flatten)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (expand
                                                                                   "member")
                                                                                  (("3"
                                                                                    (inst
                                                                                     -3
                                                                                     "lambda n: difference(E!1(n),b!1)")
                                                                                    (("3"
                                                                                      (split
                                                                                       -3)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -1)
                                                                                          (("1"
                                                                                            (split
                                                                                             -1)
                                                                                            (("1"
                                                                                              (case-replace
                                                                                               "IIntersection(LAMBDA n: difference(E!1(n), b!1))=difference(IIntersection(E!1), b!1)")
                                                                                              (("1"
                                                                                                (hide-all-but
                                                                                                 1)
                                                                                                (("1"
                                                                                                  (apply-extensionality
                                                                                                   :hide?
                                                                                                   t)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "difference")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "IIntersection")
                                                                                                        (("1"
                                                                                                          (case-replace
                                                                                                           "b!1(x!1)")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide-all-but
                                                                                               (-1
                                                                                                1))
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "decreasing?")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "difference")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "subset?")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "member")
                                                                                                      (("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "x!1"
                                                                                                           "y!1")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "x!2")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "n!1")
                                                                                          (("2"
                                                                                            (flatten)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide-all-but
                                                       (1 -6 -12))
                                                      (("2"
                                                        (expand
                                                         "subset_algebra_empty?")
                                                        (("2"
                                                          (expand
                                                           "member")
                                                          (("2"
                                                            (expand
                                                             "subset?")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "emptyset[T]")
                                                              (("2"
                                                                (expand
                                                                 "member")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but
                                                     (1 -11 -12 -13))
                                                    (("2"
                                                      (skosimp)
                                                      (("2"
                                                        (expand "KK")
                                                        (("2"
                                                          (expand "M")
                                                          (("2"
                                                            (rewrite
                                                             "difference_intersection")
                                                            (("2"
                                                              (rewrite
                                                               "difference_intersection")
                                                              (("2"
                                                                (split)
                                                                (("1"
                                                                  (expand
                                                                   "Intersection")
                                                                  (("1"
                                                                    (skosimp)
                                                                    (("1"
                                                                      (typepred
                                                                       "a!2")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "MM")
                                                                          (("1"
                                                                            (expand
                                                                             "subset_algebra_union?")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "b!1"
                                                                               "a!1")
                                                                              (("1"
                                                                                (expand
                                                                                 "member")
                                                                                (("1"
                                                                                  (expand
                                                                                   "subset?")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "union(b!1, a!1)")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "member")
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "Intersection")
                                                                  (("2"
                                                                    (skosimp)
                                                                    (("2"
                                                                      (typepred
                                                                       "a!2")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (expand
                                                                           "MM")
                                                                          (("2"
                                                                            (expand
                                                                             "subset?")
                                                                            (("2"
                                                                              (expand
                                                                               "member")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "intersection(b!1, complement(a!1))")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (hide
                                                                                     2
                                                                                     -1)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "subset_algebra_complement?")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "subset_algebra_union?")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "member")
                                                                                          (("2"
                                                                                            (lemma
                                                                                             "demorgan1"
                                                                                             ("a"
                                                                                              "complement(b!1)"
                                                                                              "b"
                                                                                              "a!1"))
                                                                                            (("2"
                                                                                              (rewrite
                                                                                               "complement_complement")
                                                                                              (("2"
                                                                                                (replace
                                                                                                 -1
                                                                                                 1
                                                                                                 rl)
                                                                                                (("2"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (inst-cp
                                                                                                     -2
                                                                                                     "b!1")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -4
                                                                                                       "complement(b!1)"
                                                                                                       "a!1")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "union(complement(b!1), a!1)")
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("3"
                                                                  (expand
                                                                   "Intersection")
                                                                  (("3"
                                                                    (skosimp)
                                                                    (("3"
                                                                      (typepred
                                                                       "a!2")
                                                                      (("3"
                                                                        (assert)
                                                                        (("3"
                                                                          (expand
                                                                           "MM")
                                                                          (("3"
                                                                            (expand
                                                                             "subset?")
                                                                            (("3"
                                                                              (expand
                                                                               "member")
                                                                              (("3"
                                                                                (inst
                                                                                 -
                                                                                 "intersection(a!1, complement(b!1))")
                                                                                (("3"
                                                                                  (assert)
                                                                                  (("3"
                                                                                    (hide
                                                                                     -1
                                                                                     2)
                                                                                    (("3"
                                                                                      (lemma
                                                                                       "demorgan1"
                                                                                       ("a"
                                                                                        "complement(a!1)"
                                                                                        "b"
                                                                                        "b!1"))
                                                                                      (("3"
                                                                                        (rewrite
                                                                                         "complement_complement")
                                                                                        (("3"
                                                                                          (replace
                                                                                           -1
                                                                                           1
                                                                                           rl)
                                                                                          (("3"
                                                                                            (hide
                                                                                             -1)
                                                                                            (("3"
                                                                                              (expand
                                                                                               "subset_algebra_complement?")
                                                                                              (("3"
                                                                                                (expand
                                                                                                 "subset_algebra_union?")
                                                                                                (("3"
                                                                                                  (expand
                                                                                                   "member")
                                                                                                  (("3"
                                                                                                    (inst-cp
                                                                                                     -2
                                                                                                     "a!1")
                                                                                                    (("3"
                                                                                                      (inst
                                                                                                       -4
                                                                                                       "complement(a!1)"
                                                                                                       "b!1")
                                                                                                      (("3"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "union(complement(a!1), b!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))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide-all-but 1)
                                                  (("2"
                                                    (skosimp)
                                                    (("2"
                                                      (expand "KK")
                                                      (("2"
                                                        (split)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (rewrite
                                                               "union_commutative")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (rewrite
                                                               "union_commutative")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 2)
                            (("2" (hide -3 -4)
                              (("2"
                                (typepred
                                 "generated_sigma_algebra(A!1)")
                                (("2"
                                  (lemma
                                   "sigma_algebra_is_monotone_class"
                                   ("x"
                                    "generated_sigma_algebra(A!1)"))
                                  (("2"
                                    (lemma
                                     "generated_sigma_algebra_subset1"
                                     ("X" "A!1"))
                                    (("2"
                                      (name-replace
                                       "SA"
                                       "generated_sigma_algebra(A!1)")
                                      (("2"
                                        (expand "subset?" 1)
                                        (("2"
                                          (skosimp)
                                          (("2"
                                            (expand "member")
                                            (("2"
                                              (expand "M" -4)
                                              (("2"
                                                (expand "Intersection")
                                                (("2"
                                                  (inst - "SA")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand "MM")
                                                      (("2"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide 2 -2)
                          (("2" (expand "subset?" 1)
                            (("2" (skosimp)
                              (("2"
                                (expand "member")
                                (("2"
                                  (expand "M" -1)
                                  (("2"
                                    (expand "Intersection")
                                    (("2"
                                      (inst - "C!1")
                                      (("2"
                                        (expand "MM")
                                        (("2" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2)
                        (("2" (expand "subset?" 1)
                          (("2" (skosimp)
                            (("2" (expand "member")
                              (("2"
                                (replace -2 1 rl)
                                (("2"
                                  (hide -2)
                                  (("2"
                                    (expand "Intersection")
                                    (("2"
                                      (skosimp)
                                      (("2"
                                        (typepred "a!1")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (replace -6 -1 rl)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "subset?")
                                                (("2"
                                                  (expand "member")
                                                  (("2"
                                                    (inst - "x!1")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (lemma "powerset_is_monotone")
                (("2" (hide-all-but (-1 1))
                  (("2" (expand "nonempty?")
                    (("2" (expand "empty?")
                      (("2" (expand "member")
                        (("2" (inst - "powerset(fullset[T])")
                          (("2" (hide-all-but 1)
                            (("2" (expand "MM")
                              (("2"
                                (expand "fullset")
                                (("2"
                                  (expand "powerset")
                                  (("2"
                                    (expand "subset?")
                                    (("2"
                                      (expand "member")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((monotone_class nonempty-type-eq-decl nil subset_algebra_def nil)
    (monotone? const-decl "bool" subset_algebra_def nil)
    (nonempty? const-decl "bool" sets nil)
    (extend const-decl "R" extend nil)
    (C!1 skolem-const-decl "monotone_class" subset_algebra_def nil)
    (sigma_algebra? const-decl "bool" subset_algebra_def nil)
    (sigma_algebra nonempty-type-eq-decl nil subset_algebra_def nil)
    (generated_sigma_algebra const-decl "sigma_algebra"
     subset_algebra_def nil)
    (generated_sigma_algebra_subset2 formula-decl nil
     subset_algebra_def nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (union const-decl "set" sets nil)
    (difference const-decl "set" sets nil)
    (union_commutative formula-decl nil sets_lemmas nil)
    (x!2 skolem-const-decl "setof[T]" subset_algebra_def nil)
    (MM skolem-const-decl "[monotone_class -> bool]" subset_algebra_def
     nil)
    (a!2 skolem-const-decl "(M)" subset_algebra_def nil)
    (M skolem-const-decl "set[setof[T]]" subset_algebra_def nil)
    (KK skolem-const-decl "[set[T] -> [set[T] -> boolean]]"
     subset_algebra_def nil)
    (x!1 skolem-const-decl "setof[T]" subset_algebra_def nil)
    (member const-decl "bool" sets nil)
    (complement_emptyset formula-decl nil sets_lemmas nil)
    (fullset const-decl "set" sets nil)
    (difference_fullset2 formula-decl nil sets_lemmas nil)
    (emptyset const-decl "set" sets nil)
    (A!1 skolem-const-decl "subset_algebra" subset_algebra_def nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (finite_emptyset name-judgement "finite_set[T]" countable_props
     "sets_aux/")
    (subset_algebra_complement? const-decl "bool" subset_algebra_def
     nil)
    (subset_algebra_union? const-decl "bool" subset_algebra_def nil)
    (b!1 skolem-const-decl "(A!1)" subset_algebra_def nil)
    (IIntersection const-decl "set[T]" indexed_sets nil)
    (decreasing? const-decl "bool" fun_preds_partial "structures/")
    (sequence type-eq-decl nil sequences 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)
    (IUnion const-decl "set[T]" indexed_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (increasing? const-decl "bool" fun_preds_partial "structures/")
    (subset_algebra_empty? const-decl "bool" subset_algebra_def nil)
    (complement_complement formula-decl nil sets_lemmas nil)
    (b!1 skolem-const-decl "(A!1)" subset_algebra_def nil)
    (a!1 skolem-const-decl "(A!1)" subset_algebra_def nil)
    (demorgan1 formula-decl nil sets_lemmas nil)
    (intersection const-decl "set" sets nil)
    (complement const-decl "set" sets nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (difference_intersection formula-decl nil sets_lemmas nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (monotone_algebra_is_sigma formula-decl nil subset_algebra_def nil)
    (subset_antisymmetric formula-decl nil sets_lemmas nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (Intersection_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (sigma_algebra_is_monotone_class judgement-tcc nil
     subset_algebra_def nil)
    (SA skolem-const-decl "sigma_algebra" subset_algebra_def nil)
    (generated_sigma_algebra_subset1 formula-decl nil
     subset_algebra_def nil)
    (FALSE const-decl "bool" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (Intersection const-decl "set" sets nil)
    (monotone_class_Intersection formula-decl nil subset_algebra_def
     nil)
    (empty? const-decl "bool" sets nil)
    (nonempty_powerset application-judgement "(nonempty?[set[T]])"
     sets_lemmas nil)
    (powerset const-decl "setofsets" sets nil)
    (powerset_is_monotone formula-decl nil subset_algebra_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (set type-eq-decl nil sets nil)
    (subset? const-decl "bool" 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 subset_algebra_def nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (subset_algebra? const-decl "bool" subset_algebra_def nil)
    (subset_algebra nonempty-type-eq-decl nil subset_algebra_def nil))
   shostak)))


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

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.742Bemerkung:  (vorverarbeitet am  2026-04-26) ¤

*Bot Zugriff






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge