Article MEMBERED, MML version 4.99.1005

:: MEMBERED:attrnot 1 => MEMBERED:attr 1
definition
  let a1 be set;
  attr a1 is complex-membered means
    for b1 being set
          st b1 in a1
       holds b1 is complex;
end;

:: MEMBERED:dfs 1
definiens
  let a1 be set;
To prove
     a1 is complex-membered
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is complex;

:: MEMBERED:def 1
theorem
for b1 being set holds
      b1 is complex-membered
   iff
      for b2 being set
            st b2 in b1
         holds b2 is complex;

:: MEMBERED:attrnot 2 => MEMBERED:attr 2
definition
  let a1 be set;
  attr a1 is ext-real-membered means
    for b1 being set
          st b1 in a1
       holds b1 is ext-real;
end;

:: MEMBERED:dfs 2
definiens
  let a1 be set;
To prove
     a1 is ext-real-membered
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is ext-real;

:: MEMBERED:def 2
theorem
for b1 being set holds
      b1 is ext-real-membered
   iff
      for b2 being set
            st b2 in b1
         holds b2 is ext-real;

:: MEMBERED:attrnot 3 => MEMBERED:attr 3
definition
  let a1 be set;
  attr a1 is real-membered means
    for b1 being set
          st b1 in a1
       holds b1 is real;
end;

:: MEMBERED:dfs 3
definiens
  let a1 be set;
To prove
     a1 is real-membered
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is real;

:: MEMBERED:def 3
theorem
for b1 being set holds
      b1 is real-membered
   iff
      for b2 being set
            st b2 in b1
         holds b2 is real;

:: MEMBERED:attrnot 4 => MEMBERED:attr 4
definition
  let a1 be set;
  attr a1 is rational-membered means
    for b1 being set
          st b1 in a1
       holds b1 is rational;
end;

:: MEMBERED:dfs 4
definiens
  let a1 be set;
To prove
     a1 is rational-membered
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is rational;

:: MEMBERED:def 4
theorem
for b1 being set holds
      b1 is rational-membered
   iff
      for b2 being set
            st b2 in b1
         holds b2 is rational;

:: MEMBERED:attrnot 5 => MEMBERED:attr 5
definition
  let a1 be set;
  attr a1 is integer-membered means
    for b1 being set
          st b1 in a1
       holds b1 is integer;
end;

:: MEMBERED:dfs 5
definiens
  let a1 be set;
To prove
     a1 is integer-membered
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is integer;

:: MEMBERED:def 5
theorem
for b1 being set holds
      b1 is integer-membered
   iff
      for b2 being set
            st b2 in b1
         holds b2 is integer;

:: MEMBERED:attrnot 6 => MEMBERED:attr 6
definition
  let a1 be set;
  attr a1 is natural-membered means
    for b1 being set
          st b1 in a1
       holds b1 is natural;
end;

:: MEMBERED:dfs 6
definiens
  let a1 be set;
To prove
     a1 is natural-membered
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is natural;

:: MEMBERED:def 6
theorem
for b1 being set holds
      b1 is natural-membered
   iff
      for b2 being set
            st b2 in b1
         holds b2 is natural;

:: MEMBERED:condreg 1
registration
  cluster natural-membered -> integer-membered (set);
end;

:: MEMBERED:condreg 2
registration
  cluster integer-membered -> rational-membered (set);
end;

:: MEMBERED:condreg 3
registration
  cluster rational-membered -> real-membered (set);
end;

:: MEMBERED:condreg 4
registration
  cluster real-membered -> ext-real-membered (set);
end;

:: MEMBERED:condreg 5
registration
  cluster real-membered -> complex-membered (set);
end;

:: MEMBERED:exreg 1
registration
  cluster non empty natural-membered set;
end;

:: MEMBERED:condreg 6
registration
  cluster -> complex-membered (Element of bool COMPLEX);
end;

:: MEMBERED:condreg 7
registration
  cluster -> ext-real-membered (Element of bool ExtREAL);
end;

:: MEMBERED:condreg 8
registration
  cluster -> real-membered (Element of bool REAL);
end;

:: MEMBERED:condreg 9
registration
  cluster -> rational-membered (Element of bool RAT);
end;

:: MEMBERED:condreg 10
registration
  cluster -> integer-membered (Element of bool INT);
end;

:: MEMBERED:condreg 11
registration
  cluster -> natural-membered (Element of bool NAT);
end;

:: MEMBERED:funcreg 1
registration
  cluster COMPLEX -> complex-membered;
end;

:: MEMBERED:funcreg 2
registration
  cluster ExtREAL -> ext-real-membered;
end;

:: MEMBERED:funcreg 3
registration
  cluster REAL -> real-membered;
end;

:: MEMBERED:funcreg 4
registration
  cluster RAT -> rational-membered;
end;

:: MEMBERED:funcreg 5
registration
  cluster INT -> integer-membered;
end;

:: MEMBERED:funcreg 6
registration
  cluster omega -> natural-membered;
end;

:: MEMBERED:th 1
theorem
for b1 being set
      st b1 is complex-membered
   holds b1 c= COMPLEX;

:: MEMBERED:th 2
theorem
for b1 being set
      st b1 is ext-real-membered
   holds b1 c= ExtREAL;

:: MEMBERED:th 3
theorem
for b1 being set
      st b1 is real-membered
   holds b1 c= REAL;

:: MEMBERED:th 4
theorem
for b1 being set
      st b1 is rational-membered
   holds b1 c= RAT;

:: MEMBERED:th 5
theorem
for b1 being set
      st b1 is integer-membered
   holds b1 c= INT;

:: MEMBERED:th 6
theorem
for b1 being set
      st b1 is natural-membered
   holds b1 c= NAT;

:: MEMBERED:condreg 12
registration
  let a1 be complex-membered set;
  cluster -> complex (Element of a1);
end;

:: MEMBERED:condreg 13
registration
  let a1 be ext-real-membered set;
  cluster -> ext-real (Element of a1);
end;

:: MEMBERED:condreg 14
registration
  let a1 be real-membered set;
  cluster -> real (Element of a1);
end;

:: MEMBERED:condreg 15
registration
  let a1 be rational-membered set;
  cluster -> rational (Element of a1);
end;

:: MEMBERED:condreg 16
registration
  let a1 be integer-membered set;
  cluster -> integer (Element of a1);
end;

:: MEMBERED:condreg 17
registration
  let a1 be natural-membered set;
  cluster -> natural (Element of a1);
end;

:: MEMBERED:th 7
theorem
for b1 being non empty complex-membered set holds
   ex b2 being complex set st
      b2 in b1;

:: MEMBERED:th 8
theorem
for b1 being non empty ext-real-membered set holds
   ex b2 being ext-real set st
      b2 in b1;

:: MEMBERED:th 9
theorem
for b1 being non empty real-membered set holds
   ex b2 being real set st
      b2 in b1;

:: MEMBERED:th 10
theorem
for b1 being non empty rational-membered set holds
   ex b2 being rational set st
      b2 in b1;

:: MEMBERED:th 11
theorem
for b1 being non empty integer-membered set holds
   ex b2 being integer set st
      b2 in b1;

:: MEMBERED:th 12
theorem
for b1 being non empty natural-membered set holds
   ex b2 being natural set st
      b2 in b1;

:: MEMBERED:th 13
theorem
for b1 being complex-membered set
      st for b2 being complex set holds
           b2 in b1
   holds b1 = COMPLEX;

:: MEMBERED:th 14
theorem
for b1 being ext-real-membered set
      st for b2 being ext-real set holds
           b2 in b1
   holds b1 = ExtREAL;

:: MEMBERED:th 15
theorem
for b1 being real-membered set
      st for b2 being real set holds
           b2 in b1
   holds b1 = REAL;

:: MEMBERED:th 16
theorem
for b1 being rational-membered set
      st for b2 being rational set holds
           b2 in b1
   holds b1 = RAT;

:: MEMBERED:th 17
theorem
for b1 being integer-membered set
      st for b2 being integer set holds
           b2 in b1
   holds b1 = INT;

:: MEMBERED:th 18
theorem
for b1 being natural-membered set
      st for b2 being natural set holds
           b2 in b1
   holds b1 = NAT;

:: MEMBERED:th 19
theorem
for b1 being set
for b2 being complex-membered set
      st b1 c= b2
   holds b1 is complex-membered;

:: MEMBERED:th 20
theorem
for b1 being set
for b2 being ext-real-membered set
      st b1 c= b2
   holds b1 is ext-real-membered;

:: MEMBERED:th 21
theorem
for b1 being set
for b2 being real-membered set
      st b1 c= b2
   holds b1 is real-membered;

:: MEMBERED:th 22
theorem
for b1 being set
for b2 being rational-membered set
      st b1 c= b2
   holds b1 is rational-membered;

:: MEMBERED:th 23
theorem
for b1 being set
for b2 being integer-membered set
      st b1 c= b2
   holds b1 is integer-membered;

:: MEMBERED:th 24
theorem
for b1 being set
for b2 being natural-membered set
      st b1 c= b2
   holds b1 is natural-membered;

:: MEMBERED:funcreg 7
registration
  cluster {} -> natural-membered;
end;

:: MEMBERED:condreg 18
registration
  cluster empty -> natural-membered (set);
end;

:: MEMBERED:funcreg 8
registration
  let a1 be complex set;
  cluster {a1} -> complex-membered;
end;

:: MEMBERED:funcreg 9
registration
  let a1 be ext-real set;
  cluster {a1} -> ext-real-membered;
end;

:: MEMBERED:funcreg 10
registration
  let a1 be real set;
  cluster {a1} -> real-membered;
end;

:: MEMBERED:funcreg 11
registration
  let a1 be rational set;
  cluster {a1} -> rational-membered;
end;

:: MEMBERED:funcreg 12
registration
  let a1 be integer set;
  cluster {a1} -> integer-membered;
end;

:: MEMBERED:funcreg 13
registration
  let a1 be natural set;
  cluster {a1} -> natural-membered;
end;

:: MEMBERED:funcreg 14
registration
  let a1, a2 be complex set;
  cluster {a1,a2} -> complex-membered;
end;

:: MEMBERED:funcreg 15
registration
  let a1, a2 be ext-real set;
  cluster {a1,a2} -> ext-real-membered;
end;

:: MEMBERED:funcreg 16
registration
  let a1, a2 be real set;
  cluster {a1,a2} -> real-membered;
end;

:: MEMBERED:funcreg 17
registration
  let a1, a2 be rational set;
  cluster {a1,a2} -> rational-membered;
end;

:: MEMBERED:funcreg 18
registration
  let a1, a2 be integer set;
  cluster {a1,a2} -> integer-membered;
end;

:: MEMBERED:funcreg 19
registration
  let a1, a2 be natural set;
  cluster {a1,a2} -> natural-membered;
end;

:: MEMBERED:funcreg 20
registration
  let a1, a2, a3 be complex set;
  cluster {a1,a2,a3} -> complex-membered;
end;

:: MEMBERED:funcreg 21
registration
  let a1, a2, a3 be ext-real set;
  cluster {a1,a2,a3} -> ext-real-membered;
end;

:: MEMBERED:funcreg 22
registration
  let a1, a2, a3 be real set;
  cluster {a1,a2,a3} -> real-membered;
end;

:: MEMBERED:funcreg 23
registration
  let a1, a2, a3 be rational set;
  cluster {a1,a2,a3} -> rational-membered;
end;

:: MEMBERED:funcreg 24
registration
  let a1, a2, a3 be integer set;
  cluster {a1,a2,a3} -> integer-membered;
end;

:: MEMBERED:funcreg 25
registration
  let a1, a2, a3 be natural set;
  cluster {a1,a2,a3} -> natural-membered;
end;

:: MEMBERED:condreg 19
registration
  let a1 be complex-membered set;
  cluster -> complex-membered (Element of bool a1);
end;

:: MEMBERED:condreg 20
registration
  let a1 be ext-real-membered set;
  cluster -> ext-real-membered (Element of bool a1);
end;

:: MEMBERED:condreg 21
registration
  let a1 be real-membered set;
  cluster -> real-membered (Element of bool a1);
end;

:: MEMBERED:condreg 22
registration
  let a1 be rational-membered set;
  cluster -> rational-membered (Element of bool a1);
end;

:: MEMBERED:condreg 23
registration
  let a1 be integer-membered set;
  cluster -> integer-membered (Element of bool a1);
end;

:: MEMBERED:condreg 24
registration
  let a1 be natural-membered set;
  cluster -> natural-membered (Element of bool a1);
end;

:: MEMBERED:funcreg 26
registration
  let a1, a2 be complex-membered set;
  cluster a1 \/ a2 -> complex-membered;
end;

:: MEMBERED:funcreg 27
registration
  let a1, a2 be ext-real-membered set;
  cluster a1 \/ a2 -> ext-real-membered;
end;

:: MEMBERED:funcreg 28
registration
  let a1, a2 be real-membered set;
  cluster a1 \/ a2 -> real-membered;
end;

:: MEMBERED:funcreg 29
registration
  let a1, a2 be rational-membered set;
  cluster a1 \/ a2 -> rational-membered;
end;

:: MEMBERED:funcreg 30
registration
  let a1, a2 be integer-membered set;
  cluster a1 \/ a2 -> integer-membered;
end;

:: MEMBERED:funcreg 31
registration
  let a1, a2 be natural-membered set;
  cluster a1 \/ a2 -> natural-membered;
end;

:: MEMBERED:funcreg 32
registration
  let a1 be complex-membered set;
  let a2 be set;
  cluster a1 /\ a2 -> complex-membered;
end;

:: MEMBERED:funcreg 33
registration
  let a1 be complex-membered set;
  let a2 be set;
  cluster a2 /\ a1 -> complex-membered;
end;

:: MEMBERED:funcreg 34
registration
  let a1 be ext-real-membered set;
  let a2 be set;
  cluster a1 /\ a2 -> ext-real-membered;
end;

:: MEMBERED:funcreg 35
registration
  let a1 be ext-real-membered set;
  let a2 be set;
  cluster a2 /\ a1 -> ext-real-membered;
end;

:: MEMBERED:funcreg 36
registration
  let a1 be real-membered set;
  let a2 be set;
  cluster a1 /\ a2 -> real-membered;
end;

:: MEMBERED:funcreg 37
registration
  let a1 be real-membered set;
  let a2 be set;
  cluster a2 /\ a1 -> real-membered;
end;

:: MEMBERED:funcreg 38
registration
  let a1 be rational-membered set;
  let a2 be set;
  cluster a1 /\ a2 -> rational-membered;
end;

:: MEMBERED:funcreg 39
registration
  let a1 be rational-membered set;
  let a2 be set;
  cluster a2 /\ a1 -> rational-membered;
end;

:: MEMBERED:funcreg 40
registration
  let a1 be integer-membered set;
  let a2 be set;
  cluster a1 /\ a2 -> integer-membered;
end;

:: MEMBERED:funcreg 41
registration
  let a1 be integer-membered set;
  let a2 be set;
  cluster a2 /\ a1 -> integer-membered;
end;

:: MEMBERED:funcreg 42
registration
  let a1 be natural-membered set;
  let a2 be set;
  cluster a1 /\ a2 -> natural-membered;
end;

:: MEMBERED:funcreg 43
registration
  let a1 be natural-membered set;
  let a2 be set;
  cluster a2 /\ a1 -> natural-membered;
end;

:: MEMBERED:funcreg 44
registration
  let a1 be complex-membered set;
  let a2 be set;
  cluster a1 \ a2 -> complex-membered;
end;

:: MEMBERED:funcreg 45
registration
  let a1 be ext-real-membered set;
  let a2 be set;
  cluster a1 \ a2 -> ext-real-membered;
end;

:: MEMBERED:funcreg 46
registration
  let a1 be real-membered set;
  let a2 be set;
  cluster a1 \ a2 -> real-membered;
end;

:: MEMBERED:funcreg 47
registration
  let a1 be rational-membered set;
  let a2 be set;
  cluster a1 \ a2 -> rational-membered;
end;

:: MEMBERED:funcreg 48
registration
  let a1 be integer-membered set;
  let a2 be set;
  cluster a1 \ a2 -> integer-membered;
end;

:: MEMBERED:funcreg 49
registration
  let a1 be natural-membered set;
  let a2 be set;
  cluster a1 \ a2 -> natural-membered;
end;

:: MEMBERED:funcreg 50
registration
  let a1, a2 be complex-membered set;
  cluster a1 \+\ a2 -> complex-membered;
end;

:: MEMBERED:funcreg 51
registration
  let a1, a2 be ext-real-membered set;
  cluster a1 \+\ a2 -> ext-real-membered;
end;

:: MEMBERED:funcreg 52
registration
  let a1, a2 be real-membered set;
  cluster a1 \+\ a2 -> real-membered;
end;

:: MEMBERED:funcreg 53
registration
  let a1, a2 be rational-membered set;
  cluster a1 \+\ a2 -> rational-membered;
end;

:: MEMBERED:funcreg 54
registration
  let a1, a2 be integer-membered set;
  cluster a1 \+\ a2 -> integer-membered;
end;

:: MEMBERED:funcreg 55
registration
  let a1, a2 be natural-membered set;
  cluster a1 \+\ a2 -> natural-membered;
end;

:: MEMBERED:prednot 1 => TARSKI:pred 1
definition
  let a1, a2 be set;
  pred A1 c= A2 means
    for b1 being complex set
          st b1 in a1
       holds b1 in a2;
  reflexivity;
::  for a1 being set holds
::     a1 c= a1;
end;

:: MEMBERED:dfs 7
definiens
  let a1, a2 be complex-membered set;
To prove
     a1 c= a2
it is sufficient to prove
  thus for b1 being complex set
          st b1 in a1
       holds b1 in a2;

:: MEMBERED:def 7
theorem
for b1, b2 being complex-membered set holds
   b1 c= b2
iff
   for b3 being complex set
         st b3 in b1
      holds b3 in b2;

:: MEMBERED:prednot 2 => TARSKI:pred 1
definition
  let a1, a2 be set;
  pred A1 c= A2 means
    for b1 being ext-real set
          st b1 in a1
       holds b1 in a2;
  reflexivity;
::  for a1 being set holds
::     a1 c= a1;
end;

:: MEMBERED:dfs 8
definiens
  let a1, a2 be ext-real-membered set;
To prove
     a1 c= a2
it is sufficient to prove
  thus for b1 being ext-real set
          st b1 in a1
       holds b1 in a2;

:: MEMBERED:def 8
theorem
for b1, b2 being ext-real-membered set holds
   b1 c= b2
iff
   for b3 being ext-real set
         st b3 in b1
      holds b3 in b2;

:: MEMBERED:prednot 3 => TARSKI:pred 1
definition
  let a1, a2 be set;
  pred A1 c= A2 means
    for b1 being real set
          st b1 in a1
       holds b1 in a2;
  reflexivity;
::  for a1 being set holds
::     a1 c= a1;
end;

:: MEMBERED:dfs 9
definiens
  let a1, a2 be real-membered set;
To prove
     a1 c= a2
it is sufficient to prove
  thus for b1 being real set
          st b1 in a1
       holds b1 in a2;

:: MEMBERED:def 9
theorem
for b1, b2 being real-membered set holds
   b1 c= b2
iff
   for b3 being real set
         st b3 in b1
      holds b3 in b2;

:: MEMBERED:prednot 4 => TARSKI:pred 1
definition
  let a1, a2 be set;
  pred A1 c= A2 means
    for b1 being rational set
          st b1 in a1
       holds b1 in a2;
  reflexivity;
::  for a1 being set holds
::     a1 c= a1;
end;

:: MEMBERED:dfs 10
definiens
  let a1, a2 be rational-membered set;
To prove
     a1 c= a2
it is sufficient to prove
  thus for b1 being rational set
          st b1 in a1
       holds b1 in a2;

:: MEMBERED:def 10
theorem
for b1, b2 being rational-membered set holds
   b1 c= b2
iff
   for b3 being rational set
         st b3 in b1
      holds b3 in b2;

:: MEMBERED:prednot 5 => TARSKI:pred 1
definition
  let a1, a2 be set;
  pred A1 c= A2 means
    for b1 being integer set
          st b1 in a1
       holds b1 in a2;
  reflexivity;
::  for a1 being set holds
::     a1 c= a1;
end;

:: MEMBERED:dfs 11
definiens
  let a1, a2 be integer-membered set;
To prove
     a1 c= a2
it is sufficient to prove
  thus for b1 being integer set
          st b1 in a1
       holds b1 in a2;

:: MEMBERED:def 11
theorem
for b1, b2 being integer-membered set holds
   b1 c= b2
iff
   for b3 being integer set
         st b3 in b1
      holds b3 in b2;

:: MEMBERED:prednot 6 => TARSKI:pred 1
definition
  let a1, a2 be set;
  pred A1 c= A2 means
    for b1 being natural set
          st b1 in a1
       holds b1 in a2;
  reflexivity;
::  for a1 being set holds
::     a1 c= a1;
end;

:: MEMBERED:dfs 12
definiens
  let a1, a2 be natural-membered set;
To prove
     a1 c= a2
it is sufficient to prove
  thus for b1 being natural set
          st b1 in a1
       holds b1 in a2;

:: MEMBERED:def 12
theorem
for b1, b2 being natural-membered set holds
   b1 c= b2
iff
   for b3 being natural set
         st b3 in b1
      holds b3 in b2;

:: MEMBERED:prednot 7 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    for b1 being complex set holds
          b1 in a1
       iff
          b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: MEMBERED:dfs 13
definiens
  let a1, a2 be complex-membered set;
To prove
     a1 = a2
it is sufficient to prove
  thus for b1 being complex set holds
          b1 in a1
       iff
          b1 in a2;

:: MEMBERED:def 13
theorem
for b1, b2 being complex-membered set holds
   b1 = b2
iff
   for b3 being complex set holds
         b3 in b1
      iff
         b3 in b2;

:: MEMBERED:prednot 8 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    for b1 being ext-real set holds
          b1 in a1
       iff
          b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: MEMBERED:dfs 14
definiens
  let a1, a2 be ext-real-membered set;
To prove
     a1 = a2
it is sufficient to prove
  thus for b1 being ext-real set holds
          b1 in a1
       iff
          b1 in a2;

:: MEMBERED:def 14
theorem
for b1, b2 being ext-real-membered set holds
   b1 = b2
iff
   for b3 being ext-real set holds
         b3 in b1
      iff
         b3 in b2;

:: MEMBERED:prednot 9 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    for b1 being real set holds
          b1 in a1
       iff
          b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: MEMBERED:dfs 15
definiens
  let a1, a2 be real-membered set;
To prove
     a1 = a2
it is sufficient to prove
  thus for b1 being real set holds
          b1 in a1
       iff
          b1 in a2;

:: MEMBERED:def 15
theorem
for b1, b2 being real-membered set holds
   b1 = b2
iff
   for b3 being real set holds
         b3 in b1
      iff
         b3 in b2;

:: MEMBERED:prednot 10 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    for b1 being rational set holds
          b1 in a1
       iff
          b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: MEMBERED:dfs 16
definiens
  let a1, a2 be rational-membered set;
To prove
     a1 = a2
it is sufficient to prove
  thus for b1 being rational set holds
          b1 in a1
       iff
          b1 in a2;

:: MEMBERED:def 16
theorem
for b1, b2 being rational-membered set holds
   b1 = b2
iff
   for b3 being rational set holds
         b3 in b1
      iff
         b3 in b2;

:: MEMBERED:prednot 11 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    for b1 being integer set holds
          b1 in a1
       iff
          b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: MEMBERED:dfs 17
definiens
  let a1, a2 be integer-membered set;
To prove
     a1 = a2
it is sufficient to prove
  thus for b1 being integer set holds
          b1 in a1
       iff
          b1 in a2;

:: MEMBERED:def 17
theorem
for b1, b2 being integer-membered set holds
   b1 = b2
iff
   for b3 being integer set holds
         b3 in b1
      iff
         b3 in b2;

:: MEMBERED:prednot 12 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    for b1 being natural set holds
          b1 in a1
       iff
          b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: MEMBERED:dfs 18
definiens
  let a1, a2 be natural-membered set;
To prove
     a1 = a2
it is sufficient to prove
  thus for b1 being natural set holds
          b1 in a1
       iff
          b1 in a2;

:: MEMBERED:def 18
theorem
for b1, b2 being natural-membered set holds
   b1 = b2
iff
   for b3 being natural set holds
         b3 in b1
      iff
         b3 in b2;

:: MEMBERED:prednot 13 => not XBOOLE_0:pred 1
definition
  let a1, a2 be set;
  pred A1 meets A2 means
    for b1 being complex set
          st b1 in a1
       holds not b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 misses a2
::     holds a2 misses a1;
end;

:: MEMBERED:dfs 19
definiens
  let a1, a2 be complex-membered set;
To prove
     a1 misses a2
it is sufficient to prove
  thus for b1 being complex set
          st b1 in a1
       holds not b1 in a2;

:: MEMBERED:def 19
theorem
for b1, b2 being complex-membered set holds
   b1 misses b2
iff
   for b3 being complex set
         st b3 in b1
      holds not b3 in b2;

:: MEMBERED:prednot 14 => not XBOOLE_0:pred 1
definition
  let a1, a2 be set;
  pred A1 meets A2 means
    for b1 being ext-real set
          st b1 in a1
       holds not b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 misses a2
::     holds a2 misses a1;
end;

:: MEMBERED:dfs 20
definiens
  let a1, a2 be ext-real-membered set;
To prove
     a1 misses a2
it is sufficient to prove
  thus for b1 being ext-real set
          st b1 in a1
       holds not b1 in a2;

:: MEMBERED:def 20
theorem
for b1, b2 being ext-real-membered set holds
   b1 misses b2
iff
   for b3 being ext-real set
         st b3 in b1
      holds not b3 in b2;

:: MEMBERED:prednot 15 => not XBOOLE_0:pred 1
definition
  let a1, a2 be set;
  pred A1 meets A2 means
    for b1 being real set
          st b1 in a1
       holds not b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 misses a2
::     holds a2 misses a1;
end;

:: MEMBERED:dfs 21
definiens
  let a1, a2 be real-membered set;
To prove
     a1 misses a2
it is sufficient to prove
  thus for b1 being real set
          st b1 in a1
       holds not b1 in a2;

:: MEMBERED:def 21
theorem
for b1, b2 being real-membered set holds
   b1 misses b2
iff
   for b3 being real set
         st b3 in b1
      holds not b3 in b2;

:: MEMBERED:prednot 16 => not XBOOLE_0:pred 1
definition
  let a1, a2 be set;
  pred A1 meets A2 means
    for b1 being rational set
          st b1 in a1
       holds not b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 misses a2
::     holds a2 misses a1;
end;

:: MEMBERED:dfs 22
definiens
  let a1, a2 be rational-membered set;
To prove
     a1 misses a2
it is sufficient to prove
  thus for b1 being rational set
          st b1 in a1
       holds not b1 in a2;

:: MEMBERED:def 22
theorem
for b1, b2 being rational-membered set holds
   b1 misses b2
iff
   for b3 being rational set
         st b3 in b1
      holds not b3 in b2;

:: MEMBERED:prednot 17 => not XBOOLE_0:pred 1
definition
  let a1, a2 be set;
  pred A1 meets A2 means
    for b1 being integer set
          st b1 in a1
       holds not b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 misses a2
::     holds a2 misses a1;
end;

:: MEMBERED:dfs 23
definiens
  let a1, a2 be integer-membered set;
To prove
     a1 misses a2
it is sufficient to prove
  thus for b1 being integer set
          st b1 in a1
       holds not b1 in a2;

:: MEMBERED:def 23
theorem
for b1, b2 being integer-membered set holds
   b1 misses b2
iff
   for b3 being integer set
         st b3 in b1
      holds not b3 in b2;

:: MEMBERED:prednot 18 => not XBOOLE_0:pred 1
definition
  let a1, a2 be set;
  pred A1 meets A2 means
    for b1 being natural set
          st b1 in a1
       holds not b1 in a2;
  symmetry;
::  for a1, a2 being set
::        st a1 misses a2
::     holds a2 misses a1;
end;

:: MEMBERED:dfs 24
definiens
  let a1, a2 be natural-membered set;
To prove
     a1 misses a2
it is sufficient to prove
  thus for b1 being natural set
          st b1 in a1
       holds not b1 in a2;

:: MEMBERED:def 24
theorem
for b1, b2 being natural-membered set holds
   b1 misses b2
iff
   for b3 being natural set
         st b3 in b1
      holds not b3 in b2;

:: MEMBERED:th 25
theorem
for b1 being set
      st for b2 being set
              st b2 in b1
           holds b2 is complex-membered
   holds union b1 is complex-membered;

:: MEMBERED:th 26
theorem
for b1 being set
      st for b2 being set
              st b2 in b1
           holds b2 is ext-real-membered
   holds union b1 is ext-real-membered;

:: MEMBERED:th 27
theorem
for b1 being set
      st for b2 being set
              st b2 in b1
           holds b2 is real-membered
   holds union b1 is real-membered;

:: MEMBERED:th 28
theorem
for b1 being set
      st for b2 being set
              st b2 in b1
           holds b2 is rational-membered
   holds union b1 is rational-membered;

:: MEMBERED:th 29
theorem
for b1 being set
      st for b2 being set
              st b2 in b1
           holds b2 is integer-membered
   holds union b1 is integer-membered;

:: MEMBERED:th 30
theorem
for b1 being set
      st for b2 being set
              st b2 in b1
           holds b2 is natural-membered
   holds union b1 is natural-membered;

:: MEMBERED:th 31
theorem
for b1, b2 being set
      st b2 in b1 & b2 is complex-membered
   holds meet b1 is complex-membered;

:: MEMBERED:th 32
theorem
for b1, b2 being set
      st b2 in b1 & b2 is ext-real-membered
   holds meet b1 is ext-real-membered;

:: MEMBERED:th 33
theorem
for b1, b2 being set
      st b2 in b1 & b2 is real-membered
   holds meet b1 is real-membered;

:: MEMBERED:th 34
theorem
for b1, b2 being set
      st b2 in b1 & b2 is rational-membered
   holds meet b1 is rational-membered;

:: MEMBERED:th 35
theorem
for b1, b2 being set
      st b2 in b1 & b2 is integer-membered
   holds meet b1 is integer-membered;

:: MEMBERED:th 36
theorem
for b1, b2 being set
      st b2 in b1 & b2 is natural-membered
   holds meet b1 is natural-membered;

:: MEMBERED:sch 1
scheme MEMBERED:sch 1
ex b1 being complex-membered set st
   for b2 being complex set holds
         b2 in b1
      iff
         P1[b2]


:: MEMBERED:sch 2
scheme MEMBERED:sch 2
ex b1 being ext-real-membered set st
   for b2 being ext-real set holds
         b2 in b1
      iff
         P1[b2]


:: MEMBERED:sch 3
scheme MEMBERED:sch 3
ex b1 being real-membered set st
   for b2 being real set holds
         b2 in b1
      iff
         P1[b2]


:: MEMBERED:sch 4
scheme MEMBERED:sch 4
ex b1 being rational-membered set st
   for b2 being rational set holds
         b2 in b1
      iff
         P1[b2]


:: MEMBERED:sch 5
scheme MEMBERED:sch 5
ex b1 being integer-membered set st
   for b2 being integer set holds
         b2 in b1
      iff
         P1[b2]


:: MEMBERED:sch 6
scheme MEMBERED:sch 6
ex b1 being natural-membered set st
   for b2 being natural set holds
         b2 in b1
      iff
         P1[b2]


:: MEMBERED:exreg 2
registration
  cluster non empty natural-membered set;
end;

:: MEMBERED:condreg 25
registration
  cluster -> natural-membered (Element of NAT);
end;