Article TEX_2, MML version 4.99.1005

:: TEX_2:attrnot 1 => REALSET1:attr 1
definition
  let a1 be set;
  attr a1 is trivial means
    ex b1 being Element of a1 st
       a1 = {b1};
end;

:: TEX_2:dfs 1
definiens
  let a1 be non empty set;
To prove
     a1 is trivial
it is sufficient to prove
  thus ex b1 being Element of a1 st
       a1 = {b1};

:: TEX_2:def 1
theorem
for b1 being non empty set holds
      b1 is trivial
   iff
      ex b2 being Element of b1 st
         b1 = {b2};

:: TEX_2:th 1
theorem
for b1 being non empty set
for b2 being non empty trivial set
      st b1 c= b2
   holds b1 = b2;

:: TEX_2:th 2
theorem
for b1 being non empty trivial set
for b2 being set
      st b1 /\ b2 is not empty
   holds b1 c= b2;

:: TEX_2:th 4
theorem
for b1, b2 being 1-sorted
      st the carrier of b1 = the carrier of b2 & b1 is trivial
   holds b2 is trivial;

:: TEX_2:attrnot 2 => TEX_2:attr 1
definition
  let a1 be set;
  let a2 be Element of a1;
  attr a2 is proper means
    a2 <> union a1;
end;

:: TEX_2:dfs 2
definiens
  let a1 be set;
  let a2 be Element of a1;
To prove
     a2 is proper
it is sufficient to prove
  thus a2 <> union a1;

:: TEX_2:def 2
theorem
for b1 being set
for b2 being Element of b1 holds
      b2 is proper(b1)
   iff
      b2 <> union b1;

:: TEX_2:exreg 1
registration
  let a1 be set;
  cluster non proper Element of bool a1;
end;

:: TEX_2:th 5
theorem
for b1 being set
for b2 being Element of bool b1 holds
      b2 is proper(bool b1)
   iff
      b2 <> b1;

:: TEX_2:condreg 1
registration
  let a1 be non empty set;
  cluster non proper -> non empty (Element of bool a1);
end;

:: TEX_2:condreg 2
registration
  let a1 be non empty set;
  cluster empty -> proper (Element of bool a1);
end;

:: TEX_2:condreg 3
registration
  let a1 be non empty trivial set;
  cluster proper -> empty (Element of bool a1);
end;

:: TEX_2:condreg 4
registration
  let a1 be non empty trivial set;
  cluster non empty -> non proper (Element of bool a1);
end;

:: TEX_2:exreg 2
registration
  let a1 be non empty set;
  cluster proper Element of bool a1;
end;

:: TEX_2:exreg 3
registration
  let a1 be non empty set;
  cluster non proper Element of bool a1;
end;

:: TEX_2:exreg 4
registration
  let a1 be non empty set;
  cluster non empty trivial Element of bool a1;
end;

:: TEX_2:funcreg 1
registration
  let a1 be set;
  cluster {a1} -> trivial;
end;

:: TEX_2:th 6
theorem
for b1 being non empty set
for b2 being Element of b1
      st {b2} is proper(bool b1)
   holds b1 is not trivial;

:: TEX_2:th 7
theorem
for b1 being non empty non trivial set
for b2 being Element of b1 holds
   {b2} is proper(bool b1);

:: TEX_2:condreg 5
registration
  let a1 be non empty trivial set;
  cluster non empty non proper -> trivial (Element of bool a1);
end;

:: TEX_2:condreg 6
registration
  let a1 be non empty non trivial set;
  cluster non empty trivial -> proper (Element of bool a1);
end;

:: TEX_2:condreg 7
registration
  let a1 be non empty non trivial set;
  cluster non empty non proper -> non trivial (Element of bool a1);
end;

:: TEX_2:exreg 5
registration
  let a1 be non empty non trivial set;
  cluster non empty trivial proper Element of bool a1;
end;

:: TEX_2:exreg 6
registration
  let a1 be non empty non trivial set;
  cluster non empty non trivial non proper Element of bool a1;
end;

:: TEX_2:th 8
theorem
for b1 being non empty 1-sorted
for b2 being Element of the carrier of b1
      st {b2} is proper(bool the carrier of b1)
   holds b1 is not trivial;

:: TEX_2:th 9
theorem
for b1 being non empty non trivial 1-sorted
for b2 being Element of the carrier of b1 holds
   {b2} is proper(bool the carrier of b1);

:: TEX_2:condreg 8
registration
  let a1 be non empty trivial 1-sorted;
  cluster non empty -> non proper (Element of bool the carrier of a1);
end;

:: TEX_2:condreg 9
registration
  let a1 be non empty trivial 1-sorted;
  cluster non empty non proper -> trivial (Element of bool the carrier of a1);
end;

:: TEX_2:condreg 10
registration
  let a1 be non empty non trivial 1-sorted;
  cluster non empty trivial -> proper (Element of bool the carrier of a1);
end;

:: TEX_2:condreg 11
registration
  let a1 be non empty non trivial 1-sorted;
  cluster non empty non proper -> non trivial (Element of bool the carrier of a1);
end;

:: TEX_2:exreg 7
registration
  let a1 be non empty non trivial 1-sorted;
  cluster non empty trivial proper Element of bool the carrier of a1;
end;

:: TEX_2:exreg 8
registration
  let a1 be non empty non trivial 1-sorted;
  cluster non empty non trivial non proper Element of bool the carrier of a1;
end;

:: TEX_2:exreg 9
registration
  let a1 be non empty non trivial 1-sorted;
  cluster non empty trivial proper Element of bool the carrier of a1;
end;

:: TEX_2:funcreg 2
registration
  let a1 be non empty set;
  let a2 be proper Element of bool a1;
  cluster a2 ` -> non empty;
end;

:: TEX_2:th 12
theorem
for b1, b2 being TopStruct
      st TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#) &
         b1 is TopSpace-like
   holds b2 is TopSpace-like;

:: TEX_2:attrnot 3 => TEX_2:attr 2
definition
  let a1 be TopStruct;
  let a2 be SubSpace of a1;
  attr a2 is proper means
    for b1 being Element of bool the carrier of a1
          st b1 = the carrier of a2
       holds b1 is proper(bool the carrier of a1);
end;

:: TEX_2:dfs 3
definiens
  let a1 be TopStruct;
  let a2 be SubSpace of a1;
To prove
     a2 is proper
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 = the carrier of a2
       holds b1 is proper(bool the carrier of a1);

:: TEX_2:def 3
theorem
for b1 being TopStruct
for b2 being SubSpace of b1 holds
      b2 is proper(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 = the carrier of b2
         holds b3 is proper(bool the carrier of b1);

:: TEX_2:th 13
theorem
for b1 being TopStruct
for b2 being SubSpace of b1
for b3 being Element of bool the carrier of b1
      st b3 = the carrier of b2
   holds    b3 is proper(bool the carrier of b1)
   iff
      b2 is proper(b1);

:: TEX_2:th 14
theorem
for b1 being TopStruct
for b2, b3 being SubSpace of b1
      st TopStruct(#the carrier of b2,the topology of b2#) = TopStruct(#the carrier of b3,the topology of b3#) &
         b2 is proper(b1)
   holds b3 is proper(b1);

:: TEX_2:th 15
theorem
for b1 being TopStruct
for b2 being SubSpace of b1
      st the carrier of b2 = the carrier of b1
   holds b2 is not proper(b1);

:: TEX_2:condreg 12
registration
  let a1 be non empty trivial TopStruct;
  cluster non empty -> non proper (SubSpace of a1);
end;

:: TEX_2:condreg 13
registration
  let a1 be non empty trivial TopStruct;
  cluster non empty non proper -> trivial (SubSpace of a1);
end;

:: TEX_2:condreg 14
registration
  let a1 be non empty non trivial TopStruct;
  cluster non empty trivial -> proper (SubSpace of a1);
end;

:: TEX_2:condreg 15
registration
  let a1 be non empty non trivial TopStruct;
  cluster non empty non proper -> non trivial (SubSpace of a1);
end;

:: TEX_2:exreg 10
registration
  let a1 be non empty TopStruct;
  cluster non empty strict non proper SubSpace of a1;
end;

:: TEX_2:th 16
theorem
for b1 being non empty TopStruct
for b2 being non proper SubSpace of b1 holds
   TopStruct(#the carrier of b2,the topology of b2#) = TopStruct(#the carrier of b1,the topology of b1#);

:: TEX_2:condreg 16
registration
  let a1 be non empty TopStruct;
  cluster discrete -> TopSpace-like (SubSpace of a1);
end;

:: TEX_2:condreg 17
registration
  let a1 be non empty TopStruct;
  cluster anti-discrete -> TopSpace-like (SubSpace of a1);
end;

:: TEX_2:condreg 18
registration
  let a1 be non empty TopStruct;
  cluster non TopSpace-like -> non discrete (SubSpace of a1);
end;

:: TEX_2:condreg 19
registration
  let a1 be non empty TopStruct;
  cluster non TopSpace-like -> non anti-discrete (SubSpace of a1);
end;

:: TEX_2:th 17
theorem
for b1, b2 being TopStruct
      st TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#) &
         b1 is discrete
   holds b2 is discrete;

:: TEX_2:th 18
theorem
for b1, b2 being TopStruct
      st TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#) &
         b1 is anti-discrete
   holds b2 is anti-discrete;

:: TEX_2:condreg 20
registration
  let a1 be non empty TopStruct;
  cluster discrete -> almost_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 21
registration
  let a1 be non empty TopStruct;
  cluster non almost_discrete -> non discrete (SubSpace of a1);
end;

:: TEX_2:condreg 22
registration
  let a1 be non empty TopStruct;
  cluster anti-discrete -> almost_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 23
registration
  let a1 be non empty TopStruct;
  cluster non almost_discrete -> non anti-discrete (SubSpace of a1);
end;

:: TEX_2:th 19
theorem
for b1, b2 being TopStruct
      st TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#) &
         b1 is almost_discrete
   holds b2 is almost_discrete;

:: TEX_2:condreg 24
registration
  let a1 be non empty TopStruct;
  cluster non empty discrete anti-discrete -> trivial (SubSpace of a1);
end;

:: TEX_2:condreg 25
registration
  let a1 be non empty TopStruct;
  cluster non empty non trivial anti-discrete -> non discrete (SubSpace of a1);
end;

:: TEX_2:condreg 26
registration
  let a1 be non empty TopStruct;
  cluster non empty non trivial discrete -> non anti-discrete (SubSpace of a1);
end;

:: TEX_2:funcnot 1 => TEX_2:func 1
definition
  let a1 be non empty TopStruct;
  let a2 be Element of the carrier of a1;
  func Sspace A2 -> non empty strict SubSpace of a1 means
    the carrier of it = {a2};
end;

:: TEX_2:def 4
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1
for b3 being non empty strict SubSpace of b1 holds
      b3 = Sspace b2
   iff
      the carrier of b3 = {b2};

:: TEX_2:exreg 11
registration
  let a1 be non empty TopStruct;
  cluster non empty trivial strict SubSpace of a1;
end;

:: TEX_2:funcreg 3
registration
  let a1 be non empty TopStruct;
  let a2 be Element of the carrier of a1;
  cluster Sspace a2 -> non empty trivial strict;
end;

:: TEX_2:th 20
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
      Sspace b2 is proper(b1)
   iff
      {b2} is proper(bool the carrier of b1);

:: TEX_2:th 21
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1
      st Sspace b2 is proper(b1)
   holds b1 is not trivial;

:: TEX_2:exreg 12
registration
  let a1 be non empty non trivial TopStruct;
  cluster non empty trivial strict proper SubSpace of a1;
end;

:: TEX_2:th 23
theorem
for b1 being non empty TopStruct
for b2 being non empty trivial SubSpace of b1 holds
   ex b3 being Element of the carrier of b1 st
      TopStruct(#the carrier of b2,the topology of b2#) = TopStruct(#the carrier of Sspace b3,the topology of Sspace b3#);

:: TEX_2:th 24
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1
      st Sspace b2 is TopSpace-like
   holds Sspace b2 is discrete & Sspace b2 is anti-discrete;

:: TEX_2:condreg 27
registration
  let a1 be non empty TopStruct;
  cluster non empty trivial TopSpace-like -> discrete anti-discrete (SubSpace of a1);
end;

:: TEX_2:exreg 13
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty trivial strict TopSpace-like SubSpace of a1;
end;

:: TEX_2:funcreg 4
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  cluster Sspace a2 -> non empty strict TopSpace-like;
end;

:: TEX_2:exreg 14
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty strict TopSpace-like discrete anti-discrete SubSpace of a1;
end;

:: TEX_2:funcreg 5
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  cluster Sspace a2 -> non empty strict discrete anti-discrete;
end;

:: TEX_2:condreg 28
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non proper -> closed open (SubSpace of a1);
end;

:: TEX_2:condreg 29
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non open -> proper (SubSpace of a1);
end;

:: TEX_2:condreg 30
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non closed -> proper (SubSpace of a1);
end;

:: TEX_2:exreg 15
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster strict TopSpace-like closed open SubSpace of a1;
end;

:: TEX_2:condreg 31
registration
  let a1 be non empty TopSpace-like discrete TopStruct;
  cluster non empty anti-discrete -> trivial (SubSpace of a1);
end;

:: TEX_2:condreg 32
registration
  let a1 be non empty TopSpace-like discrete TopStruct;
  cluster non empty non trivial -> non anti-discrete (SubSpace of a1);
end;

:: TEX_2:exreg 16
registration
  let a1 be non empty non trivial TopSpace-like discrete TopStruct;
  cluster strict TopSpace-like closed open discrete almost_discrete proper SubSpace of a1;
end;

:: TEX_2:condreg 33
registration
  let a1 be non empty TopSpace-like anti-discrete TopStruct;
  cluster non empty discrete -> trivial (SubSpace of a1);
end;

:: TEX_2:condreg 34
registration
  let a1 be non empty TopSpace-like anti-discrete TopStruct;
  cluster non empty non trivial -> non discrete (SubSpace of a1);
end;

:: TEX_2:condreg 35
registration
  let a1 be non empty non trivial TopSpace-like anti-discrete TopStruct;
  cluster non empty proper -> non closed non open (SubSpace of a1);
end;

:: TEX_2:condreg 36
registration
  let a1 be non empty non trivial TopSpace-like anti-discrete TopStruct;
  cluster non empty discrete -> trivial proper (SubSpace of a1);
end;

:: TEX_2:exreg 17
registration
  let a1 be non empty non trivial TopSpace-like anti-discrete TopStruct;
  cluster strict TopSpace-like non closed non open anti-discrete almost_discrete proper SubSpace of a1;
end;

:: TEX_2:exreg 18
registration
  let a1 be non empty non trivial TopSpace-like almost_discrete TopStruct;
  cluster non empty strict TopSpace-like almost_discrete proper SubSpace of a1;
end;

:: TEX_2:attrnot 4 => TEX_2:attr 3
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is discrete means
    for b1 being Element of bool the carrier of a1
          st b1 c= a2
       holds ex b2 being Element of bool the carrier of a1 st
          b2 is open(a1) & a2 /\ b2 = b1;
end;

:: TEX_2:dfs 5
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is discrete
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 c= a2
       holds ex b2 being Element of bool the carrier of a1 st
          b2 is open(a1) & a2 /\ b2 = b1;

:: TEX_2:def 5
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is discrete(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 c= b2
         holds ex b4 being Element of bool the carrier of b1 st
            b4 is open(b1) & b2 /\ b4 = b3;

:: TEX_2:attrnot 5 => TEX_2:attr 3
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is discrete means
    for b1 being Element of bool the carrier of a1
          st b1 c= a2
       holds ex b2 being Element of bool the carrier of a1 st
          b2 is closed(a1) & a2 /\ b2 = b1;
end;

:: TEX_2:dfs 6
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is discrete
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 c= a2
       holds ex b2 being Element of bool the carrier of a1 st
          b2 is closed(a1) & a2 /\ b2 = b1;

:: TEX_2:def 6
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is discrete(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 c= b2
         holds ex b4 being Element of bool the carrier of b1 st
            b4 is closed(b1) & b2 /\ b4 = b3;

:: TEX_2:th 25
theorem
for b1, b2 being TopStruct
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
      st TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#) &
         b3 = b4 &
         b3 is discrete(b1)
   holds b4 is discrete(b2);

:: TEX_2:th 26
theorem
for b1 being non empty TopStruct
for b2 being non empty SubSpace of b1
for b3 being Element of bool the carrier of b1
      st b3 = the carrier of b2
   holds    b3 is discrete(b1)
   iff
      b2 is discrete;

:: TEX_2:th 27
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
      st b2 = the carrier of b1
   holds    b2 is discrete(b1)
   iff
      b1 is discrete;

:: TEX_2:th 28
theorem
for b1 being TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b3 c= b2 & b2 is discrete(b1)
   holds b3 is discrete(b1);

:: TEX_2:th 29
theorem
for b1 being TopStruct
for b2, b3 being Element of bool the carrier of b1
      st (b2 is discrete(b1) or b3 is discrete(b1))
   holds b2 /\ b3 is discrete(b1);

:: TEX_2:th 30
theorem
for b1 being TopStruct
   st for b2, b3 being Element of bool the carrier of b1
           st b2 is open(b1) & b3 is open(b1)
        holds b2 /\ b3 is open(b1) & b2 \/ b3 is open(b1)
for b2, b3 being Element of bool the carrier of b1
      st b2 is open(b1) & b3 is open(b1) & b2 is discrete(b1) & b3 is discrete(b1)
   holds b2 \/ b3 is discrete(b1);

:: TEX_2:th 31
theorem
for b1 being TopStruct
   st for b2, b3 being Element of bool the carrier of b1
           st b2 is closed(b1) & b3 is closed(b1)
        holds b2 /\ b3 is closed(b1) & b2 \/ b3 is closed(b1)
for b2, b3 being Element of bool the carrier of b1
      st b2 is closed(b1) & b3 is closed(b1) & b2 is discrete(b1) & b3 is discrete(b1)
   holds b2 \/ b3 is discrete(b1);

:: TEX_2:th 32
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1
   st b2 is discrete(b1)
for b3 being Element of the carrier of b1
      st b3 in b2
   holds ex b4 being Element of bool the carrier of b1 st
      b4 is open(b1) & b2 /\ b4 = {b3};

:: TEX_2:th 33
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1
   st b2 is discrete(b1)
for b3 being Element of the carrier of b1
      st b3 in b2
   holds ex b4 being Element of bool the carrier of b1 st
      b4 is closed(b1) & b2 /\ b4 = {b3};

:: TEX_2:th 34
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty Element of bool the carrier of b1
      st b2 is discrete(b1)
   holds ex b3 being non empty strict discrete SubSpace of b1 st
      b2 = the carrier of b3;

:: TEX_2:th 35
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being empty Element of bool the carrier of b1 holds
   b2 is discrete(b1);

:: TEX_2:th 36
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   {b2} is discrete(b1);

:: TEX_2:th 37
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st for b3 being Element of the carrier of b1
              st b3 in b2
           holds ex b4 being Element of bool the carrier of b1 st
              b4 is open(b1) & b2 /\ b4 = {b3}
   holds b2 is discrete(b1);

:: TEX_2:th 38
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 is open(b1) & b3 is open(b1) & b2 is discrete(b1) & b3 is discrete(b1)
   holds b2 \/ b3 is discrete(b1);

:: TEX_2:th 39
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 is closed(b1) & b3 is closed(b1) & b2 is discrete(b1) & b3 is discrete(b1)
   holds b2 \/ b3 is discrete(b1);

:: TEX_2:th 40
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is everywhere_dense(b1) & b2 is discrete(b1)
   holds b2 is open(b1);

:: TEX_2:th 41
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is discrete(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 c= b2
         holds b2 /\ Cl b3 = b3;

:: TEX_2:th 42
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
   st b2 is discrete(b1)
for b3 being Element of the carrier of b1
      st b3 in b2
   holds b2 /\ Cl {b3} = {b3};

:: TEX_2:th 43
theorem
for b1 being non empty TopSpace-like discrete TopStruct
for b2 being Element of bool the carrier of b1 holds
   b2 is discrete(b1);

:: TEX_2:th 44
theorem
for b1 being non empty TopSpace-like anti-discrete TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
      b2 is discrete(b1)
   iff
      b2 is trivial;

:: TEX_2:attrnot 6 => TEX_2:attr 4
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is maximal_discrete means
    a2 is discrete(a1) &
     (for b1 being Element of bool the carrier of a1
           st b1 is discrete(a1) & a2 c= b1
        holds a2 = b1);
end;

:: TEX_2:dfs 7
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is maximal_discrete
it is sufficient to prove
  thus a2 is discrete(a1) &
     (for b1 being Element of bool the carrier of a1
           st b1 is discrete(a1) & a2 c= b1
        holds a2 = b1);

:: TEX_2:def 7
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is maximal_discrete(b1)
   iff
      b2 is discrete(b1) &
       (for b3 being Element of bool the carrier of b1
             st b3 is discrete(b1) & b2 c= b3
          holds b2 = b3);

:: TEX_2:th 45
theorem
for b1, b2 being TopStruct
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
      st TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#) &
         b3 = b4 &
         b3 is maximal_discrete(b1)
   holds b4 is maximal_discrete(b2);

:: TEX_2:th 46
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being empty Element of bool the carrier of b1 holds
   b2 is not maximal_discrete(b1);

:: TEX_2:th 47
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is open(b1) & b2 is maximal_discrete(b1)
   holds b2 is dense(b1);

:: TEX_2:th 48
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is dense(b1) & b2 is discrete(b1)
   holds b2 is maximal_discrete(b1);

:: TEX_2:th 49
theorem
for b1 being non empty TopSpace-like discrete TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is maximal_discrete(b1)
   iff
      b2 is proper(not bool the carrier of b1);

:: TEX_2:th 50
theorem
for b1 being non empty TopSpace-like anti-discrete TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
      b2 is maximal_discrete(b1)
   iff
      b2 is trivial;

:: TEX_2:attrnot 7 => TEX_2:attr 5
definition
  let a1 be non empty TopStruct;
  let a2 be SubSpace of a1;
  attr a2 is maximal_discrete means
    for b1 being Element of bool the carrier of a1
          st b1 = the carrier of a2
       holds b1 is maximal_discrete(a1);
end;

:: TEX_2:dfs 8
definiens
  let a1 be non empty TopStruct;
  let a2 be SubSpace of a1;
To prove
     a2 is maximal_discrete
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 = the carrier of a2
       holds b1 is maximal_discrete(a1);

:: TEX_2:def 8
theorem
for b1 being non empty TopStruct
for b2 being SubSpace of b1 holds
      b2 is maximal_discrete(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 = the carrier of b2
         holds b3 is maximal_discrete(b1);

:: TEX_2:th 51
theorem
for b1 being non empty TopStruct
for b2 being SubSpace of b1
for b3 being Element of bool the carrier of b1
      st b3 = the carrier of b2
   holds    b3 is maximal_discrete(b1)
   iff
      b2 is maximal_discrete(b1);

:: TEX_2:condreg 37
registration
  let a1 be non empty TopStruct;
  cluster non empty maximal_discrete -> discrete (SubSpace of a1);
end;

:: TEX_2:condreg 38
registration
  let a1 be non empty TopStruct;
  cluster non empty non discrete -> non maximal_discrete (SubSpace of a1);
end;

:: TEX_2:th 52
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty SubSpace of b1 holds
      b2 is maximal_discrete(b1)
   iff
      b2 is discrete &
       (for b3 being non empty discrete SubSpace of b1
             st b2 is SubSpace of b3
          holds TopStruct(#the carrier of b2,the topology of b2#) = TopStruct(#the carrier of b3,the topology of b3#));

:: TEX_2:th 53
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty Element of bool the carrier of b1
      st b2 is maximal_discrete(b1)
   holds ex b3 being non empty strict SubSpace of b1 st
      b3 is maximal_discrete(b1) & b2 = the carrier of b3;

:: TEX_2:condreg 39
registration
  let a1 be non empty TopSpace-like discrete TopStruct;
  cluster maximal_discrete -> non proper (SubSpace of a1);
end;

:: TEX_2:condreg 40
registration
  let a1 be non empty TopSpace-like discrete TopStruct;
  cluster proper -> non maximal_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 41
registration
  let a1 be non empty TopSpace-like discrete TopStruct;
  cluster non proper -> maximal_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 42
registration
  let a1 be non empty TopSpace-like discrete TopStruct;
  cluster non maximal_discrete -> proper (SubSpace of a1);
end;

:: TEX_2:condreg 43
registration
  let a1 be non empty TopSpace-like anti-discrete TopStruct;
  cluster non empty maximal_discrete -> trivial (SubSpace of a1);
end;

:: TEX_2:condreg 44
registration
  let a1 be non empty TopSpace-like anti-discrete TopStruct;
  cluster non empty non trivial -> non maximal_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 45
registration
  let a1 be non empty TopSpace-like anti-discrete TopStruct;
  cluster non empty trivial -> maximal_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 46
registration
  let a1 be non empty TopSpace-like anti-discrete TopStruct;
  cluster non empty non maximal_discrete -> non trivial (SubSpace of a1);
end;

:: TEX_2:sch 1
scheme TEX_2:sch 1
{F1 -> non empty TopStruct,
  F2 -> Element of bool bool the carrier of F1()}:
ex b1 being Function-like quasi_total Relation of F2(),the carrier of F1() st
   for b2 being Element of bool the carrier of F1()
         st b2 in F2()
      holds P1[b2, b1 . b2]
provided
   for b1 being Element of bool the carrier of F1()
         st b1 in F2()
      holds ex b2 being Element of the carrier of F1() st
         P1[b1, b2];


:: TEX_2:th 54
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1 holds
   Cl b2 = union {Cl {b3} where b3 is Element of the carrier of b1: b3 in b2};

:: TEX_2:th 55
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2, b3 being Element of the carrier of b1
      st b2 in Cl {b3}
   holds Cl {b2} = Cl {b3};

:: TEX_2:th 56
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2, b3 being Element of the carrier of b1
      st Cl {b2} meets Cl {b3}
   holds Cl {b2} = Cl {b3};

:: TEX_2:th 57
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1
      st for b3 being Element of the carrier of b1
              st b3 in b2
           holds ex b4 being Element of bool the carrier of b1 st
              b4 is closed(b1) & b2 /\ b4 = {b3}
   holds b2 is discrete(b1);

:: TEX_2:th 58
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1
      st for b3 being Element of the carrier of b1
              st b3 in b2
           holds b2 /\ Cl {b3} = {b3}
   holds b2 is discrete(b1);

:: TEX_2:th 59
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is discrete(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2 & b3 <> b4
         holds Cl {b3} misses Cl {b4};

:: TEX_2:th 60
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is discrete(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in Cl b2
         holds ex b4 being Element of the carrier of b1 st
            b4 in b2 &
             b2 /\ Cl {b3} = {b4};

:: TEX_2:th 61
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1
      st (b2 is open(b1) or b2 is closed(b1)) & b2 is maximal_discrete(b1)
   holds b2 is proper(not bool the carrier of b1);

:: TEX_2:th 62
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is maximal_discrete(b1)
   holds b2 is dense(b1);

:: TEX_2:th 63
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is maximal_discrete(b1)
   holds union {Cl {b3} where b3 is Element of the carrier of b1: b3 in b2} = the carrier of b1;

:: TEX_2:th 64
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is maximal_discrete(b1)
   iff
      for b3 being Element of the carrier of b1 holds
         ex b4 being Element of the carrier of b1 st
            b4 in b2 &
             b2 /\ Cl {b3} = {b4};

:: TEX_2:th 65
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is discrete(b1)
   holds ex b3 being Element of bool the carrier of b1 st
      b2 c= b3 & b3 is maximal_discrete(b1);

:: TEX_2:th 66
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct holds
   ex b2 being Element of bool the carrier of b1 st
      b2 is maximal_discrete(b1);

:: TEX_2:th 67
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty discrete SubSpace of b1 holds
   ex b3 being non empty strict SubSpace of b1 st
      b2 is SubSpace of b3 & b3 is maximal_discrete(b1);

:: TEX_2:condreg 47
registration
  let a1 be non empty TopSpace-like non discrete almost_discrete TopStruct;
  cluster non empty maximal_discrete -> proper (SubSpace of a1);
end;

:: TEX_2:condreg 48
registration
  let a1 be non empty TopSpace-like non discrete almost_discrete TopStruct;
  cluster non empty non proper -> non maximal_discrete (SubSpace of a1);
end;

:: TEX_2:condreg 49
registration
  let a1 be non empty TopSpace-like non anti-discrete almost_discrete TopStruct;
  cluster non empty maximal_discrete -> non trivial (SubSpace of a1);
end;

:: TEX_2:condreg 50
registration
  let a1 be non empty TopSpace-like non anti-discrete almost_discrete TopStruct;
  cluster non empty trivial -> non maximal_discrete (SubSpace of a1);
end;

:: TEX_2:exreg 19
registration
  let a1 be non empty TopSpace-like almost_discrete TopStruct;
  cluster non empty strict TopSpace-like maximal_discrete SubSpace of a1;
end;

:: TEX_2:th 68
theorem
for b1 being TopSpace-like discrete TopStruct
for b2 being TopSpace-like TopStruct
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
   b3 is continuous(b1, b2);

:: TEX_2:th 69
theorem
for b1 being non empty TopSpace-like TopStruct
      st for b2 being non empty TopSpace-like TopStruct
        for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
           b3 is continuous(b1, b2)
   holds b1 is discrete;

:: TEX_2:th 70
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty TopSpace-like anti-discrete TopStruct
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
   b3 is continuous(b1, b2);

:: TEX_2:th 71
theorem
for b1 being non empty TopSpace-like TopStruct
      st for b2 being non empty TopSpace-like TopStruct
        for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
           b3 is continuous(b2, b1)
   holds b1 is anti-discrete;

:: TEX_2:th 72
theorem
for b1 being non empty TopSpace-like discrete TopStruct
for b2 being non empty SubSpace of b1 holds
   ex b3 being Function-like quasi_total continuous Relation of the carrier of b1,the carrier of b2 st
      b3 is being_a_retraction(b1, b2);

:: TEX_2:th 73
theorem
for b1 being non empty TopSpace-like discrete TopStruct
for b2 being non empty SubSpace of b1 holds
   b2 is_a_retract_of b1;

:: TEX_2:th 74
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty maximal_discrete SubSpace of b1 holds
   ex b3 being Function-like quasi_total continuous Relation of the carrier of b1,the carrier of b2 st
      b3 is being_a_retraction(b1, b2);

:: TEX_2:th 75
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty maximal_discrete SubSpace of b1 holds
   b2 is_a_retract_of b1;

:: TEX_2:th 76
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty maximal_discrete SubSpace of b1
for b3 being Function-like quasi_total continuous Relation of the carrier of b1,the carrier of b2
   st b3 is being_a_retraction(b1, b2)
for b4 being Element of bool the carrier of b2
for b5 being Element of bool the carrier of b1
      st b4 = b5
   holds b3 " b4 = Cl b5;

:: TEX_2:th 77
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty maximal_discrete SubSpace of b1
for b3 being Function-like quasi_total continuous Relation of the carrier of b1,the carrier of b2
   st b3 is being_a_retraction(b1, b2)
for b4 being Element of the carrier of b2
for b5 being Element of the carrier of b1
      st b4 = b5
   holds b3 " {b4} = Cl {b5};

:: TEX_2:th 78
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty discrete SubSpace of b1 holds
   ex b3 being Function-like quasi_total continuous Relation of the carrier of b1,the carrier of b2 st
      b3 is being_a_retraction(b1, b2);

:: TEX_2:th 79
theorem
for b1 being non empty TopSpace-like almost_discrete TopStruct
for b2 being non empty discrete SubSpace of b1 holds
   b2 is_a_retract_of b1;