Article TEX_4, MML version 4.99.1005

:: TEX_4:funcreg 1
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non empty Element of bool the carrier of a1;
  cluster Cl a2 -> non empty;
end;

:: TEX_4:funcreg 2
registration
  let a1 be TopSpace-like TopStruct;
  let a2 be empty Element of bool the carrier of a1;
  cluster Cl a2 -> empty;
end;

:: TEX_4:funcreg 3
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non proper Element of bool the carrier of a1;
  cluster Cl a2 -> non proper;
end;

:: TEX_4:funcreg 4
registration
  let a1 be non empty non trivial TopSpace-like TopStruct;
  let a2 be non empty non trivial Element of bool the carrier of a1;
  cluster Cl a2 -> non trivial;
end;

:: TEX_4:th 1
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Cl b2 = meet {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 c= b3};

:: TEX_4:th 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   Cl {b2} = meet {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 in b3};

:: TEX_4:funcreg 5
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non proper Element of bool the carrier of a1;
  cluster Int a2 -> non proper;
end;

:: TEX_4:funcreg 6
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be proper Element of bool the carrier of a1;
  cluster Int a2 -> proper;
end;

:: TEX_4:funcreg 7
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be empty Element of bool the carrier of a1;
  cluster Int a2 -> empty;
end;

:: TEX_4:th 4
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Int b2 = union {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b3 c= b2};

:: TEX_4:attrnot 1 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1 being Element of the carrier of a1
    for b2 being Element of bool the carrier of a1
          st b2 is open(a1) & b1 in b2 & b1 in a2
       holds a2 c= b2;
end;

:: TEX_4:dfs 1
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Element of bool the carrier of a1
          st b2 is open(a1) & b1 in b2 & b1 in a2
       holds a2 c= b2;

:: TEX_4:def 1
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3 being Element of the carrier of b1
      for b4 being Element of bool the carrier of b1
            st b4 is open(b1) & b3 in b4 & b3 in b2
         holds b2 c= b4;

:: TEX_4:attrnot 2 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1 being Element of the carrier of a1
    for b2 being Element of bool the carrier of a1
          st b2 is closed(a1) & b1 in b2 & b1 in a2
       holds a2 c= b2;
end;

:: TEX_4:dfs 2
definiens
  let a1 be non empty TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Element of bool the carrier of a1
          st b2 is closed(a1) & b1 in b2 & b1 in a2
       holds a2 c= b2;

:: TEX_4:def 2
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3 being Element of the carrier of b1
      for b4 being Element of bool the carrier of b1
            st b4 is closed(b1) & b3 in b4 & b3 in b2
         holds b2 c= b4;

:: TEX_4:attrnot 3 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1 being Element of bool the carrier of a1
          st b1 is open(a1) & a2 meets b1
       holds a2 c= b1;
end;

:: TEX_4:dfs 3
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 is open(a1) & a2 meets b1
       holds a2 c= b1;

:: TEX_4:def 3
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 is open(b1) & b2 meets b3
         holds b2 c= b3;

:: TEX_4:attrnot 4 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1 being Element of bool the carrier of a1
          st b1 is closed(a1) & a2 meets b1
       holds a2 c= b1;
end;

:: TEX_4:dfs 4
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 is closed(a1) & a2 meets b1
       holds a2 c= b1;

:: TEX_4:def 4
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 is closed(b1) & b2 meets b3
         holds b2 c= b3;

:: TEX_4:th 6
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 anti-discrete(b1)
   holds b4 is anti-discrete(b2);

:: TEX_4:th 7
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b3 c= b2 & b2 is anti-discrete(b1)
   holds b3 is anti-discrete(b1);

:: TEX_4:th 8
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   {b2} is anti-discrete(b1);

:: TEX_4:th 9
theorem
for b1 being non empty TopStruct
for b2 being empty Element of bool the carrier of b1 holds
   b2 is anti-discrete(b1);

:: TEX_4:attrnot 5 => TEX_4:attr 2
definition
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
  attr a2 is anti-discrete-set-family means
    for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds b1 is anti-discrete(a1);
end;

:: TEX_4:dfs 5
definiens
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
To prove
     a2 is anti-discrete-set-family
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds b1 is anti-discrete(a1);

:: TEX_4:def 5
theorem
for b1 being TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is anti-discrete-set-family(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 in b2
         holds b3 is anti-discrete(b1);

:: TEX_4:th 10
theorem
for b1 being non empty TopStruct
for b2 being Element of bool bool the carrier of b1
      st b2 is anti-discrete-set-family(b1) & meet b2 <> {}
   holds union b2 is anti-discrete(b1);

:: TEX_4:th 11
theorem
for b1 being non empty TopStruct
for b2 being Element of bool bool the carrier of b1
      st b2 is anti-discrete-set-family(b1)
   holds meet b2 is anti-discrete(b1);

:: TEX_4:funcnot 1 => TEX_4:func 1
definition
  let a1 be TopStruct;
  let a2 be Element of the carrier of a1;
  func MaxADSF A2 -> Element of bool bool the carrier of a1 equals
    {b1 where b1 is Element of bool the carrier of a1: b1 is anti-discrete(a1) & a2 in b1};
end;

:: TEX_4:def 6
theorem
for b1 being TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSF b2 = {b3 where b3 is Element of bool the carrier of b1: b3 is anti-discrete(b1) & b2 in b3};

:: TEX_4:funcreg 8
registration
  let a1 be non empty TopStruct;
  let a2 be Element of the carrier of a1;
  cluster MaxADSF a2 -> non empty;
end;

:: TEX_4:th 12
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSF b2 is anti-discrete-set-family(b1);

:: TEX_4:th 13
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   {b2} = meet MaxADSF b2;

:: TEX_4:th 14
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   {b2} c= union MaxADSF b2;

:: TEX_4:th 15
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   union MaxADSF b2 is anti-discrete(b1);

:: TEX_4:attrnot 6 => TEX_4:attr 3
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is maximal_anti-discrete means
    a2 is anti-discrete(a1) &
     (for b1 being Element of bool the carrier of a1
           st b1 is anti-discrete(a1) & a2 c= b1
        holds a2 = b1);
end;

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

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

:: TEX_4:th 16
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_anti-discrete(b1)
   holds b4 is maximal_anti-discrete(b2);

:: TEX_4:th 17
theorem
for b1 being non empty TopStruct
for b2 being empty Element of bool the carrier of b1 holds
   b2 is not maximal_anti-discrete(b1);

:: TEX_4:th 18
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1
      st b2 is anti-discrete(b1) & b2 is open(b1)
   holds b2 is maximal_anti-discrete(b1);

:: TEX_4:th 19
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1
      st b2 is anti-discrete(b1) & b2 is closed(b1)
   holds b2 is maximal_anti-discrete(b1);

:: TEX_4:funcnot 2 => TEX_4:func 2
definition
  let a1 be TopStruct;
  let a2 be Element of the carrier of a1;
  func MaxADSet A2 -> Element of bool the carrier of a1 equals
    union MaxADSF a2;
end;

:: TEX_4:def 8
theorem
for b1 being TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 = union MaxADSF b2;

:: TEX_4:funcreg 9
registration
  let a1 be non empty TopStruct;
  let a2 be Element of the carrier of a1;
  cluster MaxADSet a2 -> non empty;
end;

:: TEX_4:th 20
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   {b2} c= MaxADSet b2;

:: TEX_4:th 21
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b2 is anti-discrete(b1) & b3 in b2
   holds b2 c= MaxADSet b3;

:: TEX_4:th 22
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 is maximal_anti-discrete(b1);

:: TEX_4:th 23
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of the carrier of b1 holds
   b3 in MaxADSet b2
iff
   MaxADSet b3 = MaxADSet b2;

:: TEX_4:th 24
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of the carrier of b1
      st not MaxADSet b2 misses MaxADSet b3
   holds MaxADSet b2 = MaxADSet b3;

:: TEX_4:th 25
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b2 is closed(b1) & b3 in b2
   holds MaxADSet b3 c= b2;

:: TEX_4:th 26
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b2 is open(b1) & b3 in b2
   holds MaxADSet b3 c= b2;

:: TEX_4:th 27
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1
      st {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 in b3} <> {}
   holds MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 in b3};

:: TEX_4:th 28
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1
      st {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 in b3} <> {}
   holds MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 in b3};

:: TEX_4:attrnot 7 => TEX_4:attr 3
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is maximal_anti-discrete means
    ex b1 being Element of the carrier of a1 st
       b1 in a2 & a2 = MaxADSet b1;
end;

:: TEX_4:dfs 9
definiens
  let a1 be non empty TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is maximal_anti-discrete
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 in a2 & a2 = MaxADSet b1;

:: TEX_4:def 9
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is maximal_anti-discrete(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b3 in b2 & b2 = MaxADSet b3;

:: TEX_4:th 29
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b3 in b2 & b2 is maximal_anti-discrete(b1)
   holds b2 = MaxADSet b3;

:: TEX_4:attrnot 8 => TEX_4:attr 3
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is maximal_anti-discrete means
    for b1 being Element of the carrier of a1
          st b1 in a2
       holds a2 = MaxADSet b1;
end;

:: TEX_4:dfs 10
definiens
  let a1 be non empty TopStruct;
  let a2 be non empty Element of bool the carrier of a1;
To prove
     a2 is maximal_anti-discrete
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a2
       holds a2 = MaxADSet b1;

:: TEX_4:def 10
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
      b2 is maximal_anti-discrete(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in b2
         holds b2 = MaxADSet b3;

:: TEX_4:funcnot 3 => TEX_4:func 3
definition
  let a1 be non empty TopStruct;
  let a2 be Element of bool the carrier of a1;
  func MaxADSet A2 -> Element of bool the carrier of a1 equals
    union {MaxADSet b1 where b1 is Element of the carrier of a1: b1 in a2};
end;

:: TEX_4:def 11
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet b2 = union {MaxADSet b3 where b3 is Element of the carrier of b1: b3 in b2};

:: TEX_4:th 30
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 = MaxADSet {b2};

:: TEX_4:th 31
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st MaxADSet b3 meets MaxADSet b2
   holds MaxADSet b3 meets b2;

:: TEX_4:th 32
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st MaxADSet b3 meets MaxADSet b2
   holds MaxADSet b3 c= MaxADSet b2;

:: TEX_4:th 33
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds MaxADSet b2 c= MaxADSet b3;

:: TEX_4:th 34
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1 holds
   b2 c= MaxADSet b2;

:: TEX_4:th 35
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet b2 = MaxADSet MaxADSet b2;

:: TEX_4:th 36
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 c= MaxADSet b3
   holds MaxADSet b2 c= MaxADSet b3;

:: TEX_4:th 37
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b3 c= MaxADSet b2 & b2 c= MaxADSet b3
   holds MaxADSet b2 = MaxADSet b3;

:: TEX_4:th 38
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1 holds
MaxADSet (b2 \/ b3) = (MaxADSet b2) \/ MaxADSet b3;

:: TEX_4:th 39
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1 holds
MaxADSet (b2 /\ b3) c= (MaxADSet b2) /\ MaxADSet b3;

:: TEX_4:funcreg 10
registration
  let a1 be non empty TopStruct;
  let a2 be non empty Element of bool the carrier of a1;
  cluster MaxADSet a2 -> non empty;
end;

:: TEX_4:funcreg 11
registration
  let a1 be non empty TopStruct;
  let a2 be empty Element of bool the carrier of a1;
  cluster MaxADSet a2 -> empty;
end;

:: TEX_4:funcreg 12
registration
  let a1 be non empty TopStruct;
  let a2 be non proper Element of bool the carrier of a1;
  cluster MaxADSet a2 -> non proper;
end;

:: TEX_4:funcreg 13
registration
  let a1 be non empty non trivial TopStruct;
  let a2 be non empty non trivial Element of bool the carrier of a1;
  cluster MaxADSet a2 -> non trivial;
end;

:: TEX_4:th 40
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 is open(b1) & b3 c= b2
   holds MaxADSet b3 c= b2;

:: TEX_4:th 41
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
      st {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 c= b3} <> {}
   holds MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 c= b3};

:: TEX_4:th 42
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 is closed(b1) & b3 c= b2
   holds MaxADSet b3 c= b2;

:: TEX_4:th 43
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
      st {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 c= b3} <> {}
   holds MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 c= b3};

:: TEX_4:attrnot 9 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1 being Element of the carrier of a1
          st b1 in a2
       holds a2 c= Cl {b1};
end;

:: TEX_4:dfs 12
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a2
       holds a2 c= Cl {b1};

:: TEX_4:def 12
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in b2
         holds b2 c= Cl {b3};

:: TEX_4:attrnot 10 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1 being Element of the carrier of a1
          st b1 in a2
       holds Cl a2 = Cl {b1};
end;

:: TEX_4:dfs 13
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a2
       holds Cl a2 = Cl {b1};

:: TEX_4:def 13
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in b2
         holds Cl b2 = Cl {b3};

:: TEX_4:attrnot 11 => TEX_4:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is anti-discrete means
    for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds Cl {b1} = Cl {b2};
end;

:: TEX_4:dfs 14
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is anti-discrete
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds Cl {b1} = Cl {b2};

:: TEX_4:def 14
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds Cl {b3} = Cl {b4};

:: TEX_4:th 44
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1
      st b3 is anti-discrete(b1) & Cl {b2} c= b3
   holds b3 = Cl {b2};

:: TEX_4:th 45
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is anti-discrete(b1) & b2 is closed(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in b2
         holds b2 = Cl {b3};

:: TEX_4:th 46
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is anti-discrete(b1) & b2 is not open(b1)
   holds b2 is boundary(b1);

:: TEX_4:th 47
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1
      st Cl {b2} = {b2}
   holds {b2} is maximal_anti-discrete(b1);

:: TEX_4:th 48
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 in b3};

:: TEX_4:th 49
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 in b3};

:: TEX_4:th 50
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 c= Cl {b2};

:: TEX_4:th 51
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of b1 holds
   MaxADSet b2 = MaxADSet b3
iff
   Cl {b2} = Cl {b3};

:: TEX_4:th 52
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of b1 holds
   MaxADSet b2 misses MaxADSet b3
iff
   Cl {b2} <> Cl {b3};

:: TEX_4:funcnot 4 => TEX_4:func 4
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  redefine func MaxADSet A2 -> non empty Element of bool the carrier of a1 equals
    (Cl {a2}) /\ meet {b1 where b1 is Element of bool the carrier of a1: b1 is open(a1) & a2 in b1};
end;

:: TEX_4:def 15
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   MaxADSet b2 = (Cl {b2}) /\ meet {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 in b3};

:: TEX_4:th 53
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of b1 holds
   Cl {b2} c= Cl {b3}
iff
   meet {b4 where b4 is Element of bool the carrier of b1: b4 is open(b1) & b3 in b4} c= meet {b4 where b4 is Element of bool the carrier of b1: b4 is open(b1) & b2 in b4};

:: TEX_4:th 54
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of b1 holds
   Cl {b2} c= Cl {b3}
iff
   MaxADSet b3 c= meet {b4 where b4 is Element of bool the carrier of b1: b4 is open(b1) & b2 in b4};

:: TEX_4:th 55
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of b1 holds
   MaxADSet b2 misses MaxADSet b3
iff
   (for b4 being Element of bool the carrier of b1
         st b4 is open(b1) & MaxADSet b2 c= b4
      holds b4 meets MaxADSet b3 implies ex b4 being Element of bool the carrier of b1 st
      b4 is open(b1) & b4 misses MaxADSet b2 & MaxADSet b3 c= b4);

:: TEX_4:th 56
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of b1 holds
   MaxADSet b2 misses MaxADSet b3
iff
   (for b4 being Element of bool the carrier of b1
         st b4 is closed(b1) & MaxADSet b2 c= b4
      holds b4 meets MaxADSet b3 implies ex b4 being Element of bool the carrier of b1 st
      b4 is closed(b1) & b4 misses MaxADSet b2 & MaxADSet b3 c= b4);

:: TEX_4:th 57
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is open(b1) & b2 c= b3};

:: TEX_4:th 58
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is open(b1)
   holds MaxADSet b2 = b2;

:: TEX_4:th 59
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet Int b2 = Int b2;

:: TEX_4:th 60
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet b2 c= meet {b3 where b3 is Element of bool the carrier of b1: b3 is closed(b1) & b2 c= b3};

:: TEX_4:th 61
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet b2 c= Cl b2;

:: TEX_4:th 62
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is closed(b1)
   holds MaxADSet b2 = b2;

:: TEX_4:th 63
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   MaxADSet Cl b2 = Cl b2;

:: TEX_4:th 64
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Cl MaxADSet b2 = Cl b2;

:: TEX_4:th 65
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st MaxADSet b2 = MaxADSet b3
   holds Cl b2 = Cl b3;

:: TEX_4:th 66
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) or b3 is closed(b1))
   holds MaxADSet (b2 /\ b3) = (MaxADSet b2) /\ MaxADSet b3;

:: TEX_4:th 67
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) or b3 is open(b1))
   holds MaxADSet (b2 /\ b3) = (MaxADSet b2) /\ MaxADSet b3;

:: TEX_4:th 68
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 & b2 is anti-discrete
   holds b3 is anti-discrete(b1);

:: TEX_4:th 69
theorem
for b1 being non empty TopStruct
for b2 being SubSpace of b1
   st b2 is TopSpace-like
for b3 being Element of bool the carrier of b1
      st b3 = the carrier of b2 & b3 is anti-discrete(b1)
   holds b2 is anti-discrete;

:: TEX_4:th 70
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty SubSpace of b1
      st for b3 being open SubSpace of b1
              st b2 meets b3
           holds b2 is SubSpace of b3
   holds b2 is anti-discrete;

:: TEX_4:th 71
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty SubSpace of b1
      st for b3 being closed SubSpace of b1
              st b2 meets b3
           holds b2 is SubSpace of b3
   holds b2 is anti-discrete;

:: TEX_4:th 72
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being anti-discrete SubSpace of b1
for b3 being open SubSpace of b1
      st b2 meets b3
   holds b2 is SubSpace of b3;

:: TEX_4:th 73
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being anti-discrete SubSpace of b1
for b3 being closed SubSpace of b1
      st b2 meets b3
   holds b2 is SubSpace of b3;

:: TEX_4:attrnot 12 => TEX_4:attr 4
definition
  let a1 be non empty TopStruct;
  let a2 be SubSpace of a1;
  attr a2 is maximal_anti-discrete means
    a2 is anti-discrete &
     (for b1 being SubSpace of a1
           st b1 is anti-discrete & the carrier of a2 c= the carrier of b1
        holds the carrier of a2 = the carrier of b1);
end;

:: TEX_4:dfs 16
definiens
  let a1 be non empty TopStruct;
  let a2 be SubSpace of a1;
To prove
     a2 is maximal_anti-discrete
it is sufficient to prove
  thus a2 is anti-discrete &
     (for b1 being SubSpace of a1
           st b1 is anti-discrete & the carrier of a2 c= the carrier of b1
        holds the carrier of a2 = the carrier of b1);

:: TEX_4:def 16
theorem
for b1 being non empty TopStruct
for b2 being SubSpace of b1 holds
      b2 is maximal_anti-discrete(b1)
   iff
      b2 is anti-discrete &
       (for b3 being SubSpace of b1
             st b3 is anti-discrete & the carrier of b2 c= the carrier of b3
          holds the carrier of b2 = the carrier of b3);

:: TEX_4:condreg 1
registration
  let a1 be non empty TopStruct;
  cluster maximal_anti-discrete -> anti-discrete (SubSpace of a1);
end;

:: TEX_4:condreg 2
registration
  let a1 be non empty TopStruct;
  cluster non anti-discrete -> non maximal_anti-discrete (SubSpace of a1);
end;

:: TEX_4:th 74
theorem
for b1 being non empty TopSpace-like 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    b2 is maximal_anti-discrete(b1)
   iff
      b3 is maximal_anti-discrete(b1);

:: TEX_4:condreg 3
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty open anti-discrete -> maximal_anti-discrete (SubSpace of a1);
end;

:: TEX_4:condreg 4
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty open non maximal_anti-discrete -> non anti-discrete (SubSpace of a1);
end;

:: TEX_4:condreg 5
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty anti-discrete non maximal_anti-discrete -> non open (SubSpace of a1);
end;

:: TEX_4:condreg 6
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty closed anti-discrete -> maximal_anti-discrete (SubSpace of a1);
end;

:: TEX_4:condreg 7
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty closed non maximal_anti-discrete -> non anti-discrete (SubSpace of a1);
end;

:: TEX_4:condreg 8
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty anti-discrete non maximal_anti-discrete -> non closed (SubSpace of a1);
end;

:: TEX_4:funcnot 5 => TEX_4:func 5
definition
  let a1 be TopStruct;
  let a2 be Element of the carrier of a1;
  func MaxADSspace A2 -> strict SubSpace of a1 means
    the carrier of it = MaxADSet a2;
end;

:: TEX_4:def 17
theorem
for b1 being TopStruct
for b2 being Element of the carrier of b1
for b3 being strict SubSpace of b1 holds
      b3 = MaxADSspace b2
   iff
      the carrier of b3 = MaxADSet b2;

:: TEX_4:funcreg 14
registration
  let a1 be non empty TopStruct;
  let a2 be Element of the carrier of a1;
  cluster MaxADSspace a2 -> non empty strict;
end;

:: TEX_4:th 75
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   Sspace b2 is SubSpace of MaxADSspace b2;

:: TEX_4:th 76
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of the carrier of b1 holds
   b3 is Element of the carrier of MaxADSspace b2
iff
   TopStruct(#the carrier of MaxADSspace b3,the topology of MaxADSspace b3#) = TopStruct(#the carrier of MaxADSspace b2,the topology of MaxADSspace b2#);

:: TEX_4:th 77
theorem
for b1 being non empty TopStruct
for b2, b3 being Element of the carrier of b1
      st not the carrier of MaxADSspace b2 misses the carrier of MaxADSspace b3
   holds TopStruct(#the carrier of MaxADSspace b2,the topology of MaxADSspace b2#) = TopStruct(#the carrier of MaxADSspace b3,the topology of MaxADSspace b3#);

:: TEX_4:exreg 1
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster strict TopSpace-like maximal_anti-discrete SubSpace of a1;
end;

:: TEX_4:funcreg 15
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  cluster MaxADSspace a2 -> strict maximal_anti-discrete;
end;

:: TEX_4:th 78
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty closed SubSpace of b1
for b3 being Element of the carrier of b1
      st b3 is Element of the carrier of b2
   holds MaxADSspace b3 is SubSpace of b2;

:: TEX_4:th 79
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty open SubSpace of b1
for b3 being Element of the carrier of b1
      st b3 is Element of the carrier of b2
   holds MaxADSspace b3 is SubSpace of b2;

:: TEX_4:th 80
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1
      st Cl {b2} = {b2}
   holds Sspace b2 is maximal_anti-discrete(b1);

:: TEX_4:funcnot 6 => PRE_TOPC:func 1
notation
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  synonym Sspace a2 for a1 | a2;
end;

:: TEX_4:funcreg 16
registration
  let a1 be non empty TopStruct;
  let a2 be non empty Element of bool the carrier of a1;
  cluster a1 | a2 -> non empty strict;
end;

:: TEX_4:th 81
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
   b2 is Element of bool the carrier of b1 | b2;

:: TEX_4:th 82
theorem
for b1 being non empty TopStruct
for b2 being SubSpace of b1
for b3 being non empty Element of bool the carrier of b1
      st b3 is Element of bool the carrier of b2
   holds b1 | b3 is SubSpace of b2;

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

:: TEX_4:funcreg 17
registration
  let a1 be non empty non trivial TopStruct;
  let a2 be non empty non trivial Element of bool the carrier of a1;
  cluster a1 | a2 -> non trivial strict;
end;

:: TEX_4:funcreg 18
registration
  let a1 be non empty TopStruct;
  let a2 be non empty non proper Element of bool the carrier of a1;
  cluster a1 | a2 -> strict non proper;
end;

:: TEX_4:funcnot 7 => TEX_4:func 6
definition
  let a1 be non empty TopStruct;
  let a2 be Element of bool the carrier of a1;
  func MaxADSspace A2 -> strict SubSpace of a1 means
    the carrier of it = MaxADSet a2;
end;

:: TEX_4:def 18
theorem
for b1 being non empty TopStruct
for b2 being Element of bool the carrier of b1
for b3 being strict SubSpace of b1 holds
      b3 = MaxADSspace b2
   iff
      the carrier of b3 = MaxADSet b2;

:: TEX_4:funcreg 19
registration
  let a1 be non empty TopStruct;
  let a2 be non empty Element of bool the carrier of a1;
  cluster MaxADSspace a2 -> non empty strict;
end;

:: TEX_4:th 83
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
   b2 is Element of bool the carrier of MaxADSspace b2;

:: TEX_4:th 84
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
   b1 | b2 is SubSpace of MaxADSspace b2;

:: TEX_4:th 85
theorem
for b1 being non empty TopStruct
for b2 being Element of the carrier of b1 holds
   TopStruct(#the carrier of MaxADSspace b2,the topology of MaxADSspace b2#) = TopStruct(#the carrier of MaxADSspace {b2},the topology of MaxADSspace {b2}#);

:: TEX_4:th 86
theorem
for b1 being non empty TopStruct
for b2, b3 being non empty Element of bool the carrier of b1
      st b2 c= b3
   holds MaxADSspace b2 is SubSpace of MaxADSspace b3;

:: TEX_4:th 87
theorem
for b1 being non empty TopStruct
for b2 being non empty Element of bool the carrier of b1 holds
   TopStruct(#the carrier of MaxADSspace b2,the topology of MaxADSspace b2#) = TopStruct(#the carrier of MaxADSspace MaxADSet b2,the topology of MaxADSspace MaxADSet b2#);

:: TEX_4:th 88
theorem
for b1 being non empty TopStruct
for b2, b3 being non empty Element of bool the carrier of b1
      st b2 is Element of bool the carrier of MaxADSspace b3
   holds MaxADSspace b2 is SubSpace of MaxADSspace b3;

:: TEX_4:th 89
theorem
for b1 being non empty TopStruct
for b2, b3 being non empty Element of bool the carrier of b1 holds
   b3 is Element of bool the carrier of MaxADSspace b2 & b2 is Element of bool the carrier of MaxADSspace b3
iff
   TopStruct(#the carrier of MaxADSspace b2,the topology of MaxADSspace b2#) = TopStruct(#the carrier of MaxADSspace b3,the topology of MaxADSspace b3#);

:: TEX_4:funcreg 20
registration
  let a1 be non empty non trivial TopStruct;
  let a2 be non empty non trivial Element of bool the carrier of a1;
  cluster MaxADSspace a2 -> non trivial strict;
end;

:: TEX_4:funcreg 21
registration
  let a1 be non empty TopStruct;
  let a2 be non empty non proper Element of bool the carrier of a1;
  cluster MaxADSspace a2 -> strict non proper;
end;

:: TEX_4:th 90
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being open SubSpace of b1
for b3 being non empty Element of bool the carrier of b1
      st b3 is Element of bool the carrier of b2
   holds MaxADSspace b3 is SubSpace of b2;

:: TEX_4:th 91
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being closed SubSpace of b1
for b3 being non empty Element of bool the carrier of b1
      st b3 is Element of bool the carrier of b2
   holds MaxADSspace b3 is SubSpace of b2;