Article TOPGEN_4, MML version 4.99.1005

:: TOPGEN_4:funcnot 1 => TOPGEN_4:func 1
definition
  let a1 be 1-sorted;
  func TotFam A1 -> Element of bool bool the carrier of a1 equals
    bool the carrier of a1;
end;

:: TOPGEN_4:def 1
theorem
for b1 being 1-sorted holds
   TotFam b1 = bool the carrier of b1;

:: TOPGEN_4:th 1
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is countable
   iff
      COMPLEMENT b2 is countable;

:: TOPGEN_4:funcreg 1
registration
  cluster RAT -> countable;
end;

:: TOPGEN_4:sch 1
scheme TOPGEN_4:sch 1
{{b1} where b1 is Element of RAT: P1[b1]} is countable


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

:: TOPGEN_4:condreg 1
registration
  cluster finite -> second-countable (TopStruct);
end;

:: TOPGEN_4:funcreg 2
registration
  cluster REAL -> non countable;
end;

:: TOPGEN_4:condreg 2
registration
  cluster non countable -> infinite (set);
end;

:: TOPGEN_4:condreg 3
registration
  cluster infinite -> non trivial (set);
end;

:: TOPGEN_4:exreg 1
registration
  cluster non empty non countable set;
end;

:: TOPGEN_4:th 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is closed(b1)
   iff
      Der b2 c= b2;

:: TOPGEN_4:th 4
theorem
for b1 being non empty TopStruct
for b2 being Basis of b1
for b3 being Element of bool the carrier of b1
      st b3 is open(b1) & b3 <> {}
   holds ex b4 being Element of bool the carrier of b1 st
      b4 in b2 & b4 c= b3 & b4 <> {};

:: TOPGEN_4:th 5
theorem
for b1 being non empty TopSpace-like TopStruct holds
   density b1 c= weight b1;

:: TOPGEN_4:th 6
theorem
for b1 being non empty TopSpace-like TopStruct holds
      b1 is separable
   iff
      ex b2 being Element of bool the carrier of b1 st
         b2 is dense(b1) & b2 is countable;

:: TOPGEN_4:th 7
theorem
for b1 being non empty TopSpace-like TopStruct
      st b1 is second-countable
   holds b1 is separable;

:: TOPGEN_4:condreg 4
registration
  cluster non empty TopSpace-like second-countable -> separable (TopStruct);
end;

:: TOPGEN_4:th 8
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2,b3 are_separated
   holds Fr (b2 \/ b3) = (Fr b2) \/ Fr b3;

:: TOPGEN_4:th 9
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1
      st b2 is locally_finite(b1)
   holds Fr union b2 c= union Fr b2;

:: TOPGEN_4:th 10
theorem
for b1 being non empty TopSpace-like discrete TopStruct holds
      b1 is separable
   iff
      Card [#] b1 c= alef 0;

:: TOPGEN_4:th 11
theorem
for b1 being non empty TopSpace-like discrete TopStruct holds
      b1 is separable
   iff
      b1 is countable;

:: TOPGEN_4:attrnot 1 => TOPGEN_4:attr 1
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool bool the carrier of a1;
  attr a2 is all-open-containing means
    for b1 being Element of bool the carrier of a1
          st b1 is open(a1)
       holds b1 in a2;
end;

:: TOPGEN_4:dfs 2
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool bool the carrier of a1;
To prove
     a2 is all-open-containing
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 is open(a1)
       holds b1 in a2;

:: TOPGEN_4:def 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is all-open-containing(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 is open(b1)
         holds b3 in b2;

:: TOPGEN_4:attrnot 2 => TOPGEN_4:attr 2
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool bool the carrier of a1;
  attr a2 is all-closed-containing means
    for b1 being Element of bool the carrier of a1
          st b1 is closed(a1)
       holds b1 in a2;
end;

:: TOPGEN_4:dfs 3
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool bool the carrier of a1;
To prove
     a2 is all-closed-containing
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 is closed(a1)
       holds b1 in a2;

:: TOPGEN_4:def 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is all-closed-containing(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 is closed(b1)
         holds b3 in b2;

:: TOPGEN_4:attrnot 3 => TOPGEN_4:attr 3
definition
  let a1 be set;
  let a2 be Element of bool bool a1;
  attr a2 is closed_for_countable_unions means
    for b1 being countable Element of bool bool a1
          st b1 c= a2
       holds union b1 in a2;
end;

:: TOPGEN_4:dfs 4
definiens
  let a1 be set;
  let a2 be Element of bool bool a1;
To prove
     a2 is closed_for_countable_unions
it is sufficient to prove
  thus for b1 being countable Element of bool bool a1
          st b1 c= a2
       holds union b1 in a2;

:: TOPGEN_4:def 4
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is closed_for_countable_unions(b1)
   iff
      for b3 being countable Element of bool bool b1
            st b3 c= b2
         holds union b3 in b2;

:: TOPGEN_4:condreg 5
registration
  let a1 be set;
  cluster non empty compl-closed sigma-multiplicative -> closed_for_countable_unions (Element of bool bool a1);
end;

:: TOPGEN_4:th 12
theorem
for b1 being set
for b2 being Element of bool bool b1
      st b2 is closed_for_countable_unions(b1)
   holds {} in b2;

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

:: TOPGEN_4:th 13
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is non empty compl-closed sigma-multiplicative Element of bool bool b1
   iff
      b2 is compl-closed(b1) & b2 is closed_for_countable_unions(b1);

:: TOPGEN_4:attrnot 4 => TOPGEN_4:attr 4
definition
  let a1 be set;
  let a2 be Element of bool bool a1;
  attr a2 is closed_for_countable_meets means
    for b1 being countable Element of bool bool a1
          st b1 c= a2
       holds meet b1 in a2;
end;

:: TOPGEN_4:dfs 5
definiens
  let a1 be set;
  let a2 be Element of bool bool a1;
To prove
     a2 is closed_for_countable_meets
it is sufficient to prove
  thus for b1 being countable Element of bool bool a1
          st b1 c= a2
       holds meet b1 in a2;

:: TOPGEN_4:def 5
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is closed_for_countable_meets(b1)
   iff
      for b3 being countable Element of bool bool b1
            st b3 c= b2
         holds meet b3 in b2;

:: TOPGEN_4:th 14
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is all-closed-containing(b1) & b2 is compl-closed(the carrier of b1)
   iff
      b2 is all-open-containing(b1) & b2 is compl-closed(the carrier of b1);

:: TOPGEN_4:th 15
theorem
for b1 being set
for b2 being Element of bool bool b1
      st b2 is compl-closed(b1)
   holds b2 = COMPLEMENT b2;

:: TOPGEN_4:th 16
theorem
for b1 being set
for b2, b3 being Element of bool bool b1
      st b2 c= b3 & b3 is compl-closed(b1)
   holds COMPLEMENT b2 c= b3;

:: TOPGEN_4:th 17
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is closed_for_countable_meets(b1) & b2 is compl-closed(b1)
   iff
      b2 is closed_for_countable_unions(b1) & b2 is compl-closed(b1);

:: TOPGEN_4:condreg 7
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster compl-closed all-open-containing closed_for_countable_unions -> all-closed-containing closed_for_countable_meets (Element of bool bool the carrier of a1);
end;

:: TOPGEN_4:condreg 8
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster compl-closed all-closed-containing closed_for_countable_meets -> all-open-containing closed_for_countable_unions (Element of bool bool the carrier of a1);
end;

:: TOPGEN_4:funcreg 3
registration
  let a1 be set;
  let a2 be countable Element of bool bool a1;
  cluster COMPLEMENT a2 -> countable;
end;

:: TOPGEN_4:condreg 9
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster empty -> open closed (Element of bool bool the carrier of a1);
end;

:: TOPGEN_4:exreg 2
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster countable open closed Element of bool bool the carrier of a1;
end;

:: TOPGEN_4:th 18
theorem
for b1 being set holds
   {} is empty Element of bool bool b1;

:: TOPGEN_4:condreg 10
registration
  cluster empty -> countable (set);
end;

:: TOPGEN_4:th 19
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of bool bool the carrier of b1
      st b3 = {b2}
   holds    b2 is open(b1)
   iff
      b3 is open(b1);

:: TOPGEN_4:th 20
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of bool bool the carrier of b1
      st b3 = {b2}
   holds    b2 is closed(b1)
   iff
      b3 is closed(b1);

:: TOPGEN_4:funcnot 2 => TOPGEN_4:func 2
definition
  let a1 be set;
  let a2, a3 be Element of bool bool a1;
  redefine func INTERSECTION(a2,a3) -> Element of bool bool a1;
  commutativity;
::  for a1 being set
::  for a2, a3 being Element of bool bool a1 holds
::  INTERSECTION(a2,a3) = INTERSECTION(a3,a2);
end;

:: TOPGEN_4:funcnot 3 => TOPGEN_4:func 3
definition
  let a1 be set;
  let a2, a3 be Element of bool bool a1;
  redefine func UNION(a2,a3) -> Element of bool bool a1;
  commutativity;
::  for a1 being set
::  for a2, a3 being Element of bool bool a1 holds
::  UNION(a2,a3) = UNION(a3,a2);
end;

:: TOPGEN_4:th 21
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
      st b2 is closed(b1) & b3 is closed(b1)
   holds INTERSECTION(b2,b3) is closed(b1);

:: TOPGEN_4:th 22
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
      st b2 is closed(b1) & b3 is closed(b1)
   holds UNION(b2,b3) is closed(b1);

:: TOPGEN_4:th 23
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
      st b2 is open(b1) & b3 is open(b1)
   holds INTERSECTION(b2,b3) is open(b1);

:: TOPGEN_4:th 24
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
      st b2 is open(b1) & b3 is open(b1)
   holds UNION(b2,b3) is open(b1);

:: TOPGEN_4:th 25
theorem
for b1 being set
for b2, b3 being Element of bool bool b1 holds
Card INTERSECTION(b2,b3) c= Card [:b2,b3:];

:: TOPGEN_4:th 26
theorem
for b1 being set
for b2, b3 being Element of bool bool b1 holds
Card UNION(b2,b3) c= Card [:b2,b3:];

:: TOPGEN_4:th 27
theorem
for b1, b2 being set holds
union UNION(b1,b2) c= (union b1) \/ union b2;

:: TOPGEN_4:th 28
theorem
for b1, b2 being set
      st b1 <> {} & b2 <> {}
   holds (union b1) \/ union b2 = union UNION(b1,b2);

:: TOPGEN_4:th 29
theorem
for b1 being set holds
   UNION({},b1) = {};

:: TOPGEN_4:th 30
theorem
for b1, b2 being set
      st UNION(b1,b2) = {} & b1 <> {}
   holds b2 = {};

:: TOPGEN_4:th 31
theorem
for b1, b2 being set
      st INTERSECTION(b1,b2) = {} & b1 <> {}
   holds b2 = {};

:: TOPGEN_4:th 32
theorem
for b1, b2 being set holds
meet UNION(b1,b2) c= (meet b1) \/ meet b2;

:: TOPGEN_4:th 33
theorem
for b1, b2 being set
      st b1 <> {} & b2 <> {}
   holds meet UNION(b1,b2) = (meet b1) \/ meet b2;

:: TOPGEN_4:th 34
theorem
for b1, b2 being set
      st b1 <> {} & b2 <> {}
   holds (meet b1) /\ meet b2 = meet INTERSECTION(b1,b2);

:: TOPGEN_4:attrnot 5 => TOPGEN_4:attr 5
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is F_sigma means
    ex b1 being countable closed Element of bool bool the carrier of a1 st
       a2 = union b1;
end;

:: TOPGEN_4:dfs 6
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is F_sigma
it is sufficient to prove
  thus ex b1 being countable closed Element of bool bool the carrier of a1 st
       a2 = union b1;

:: TOPGEN_4:def 6
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is F_sigma(b1)
   iff
      ex b3 being countable closed Element of bool bool the carrier of b1 st
         b2 = union b3;

:: TOPGEN_4:attrnot 6 => TOPGEN_4:attr 6
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is G_delta means
    ex b1 being countable open Element of bool bool the carrier of a1 st
       a2 = meet b1;
end;

:: TOPGEN_4:dfs 7
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is G_delta
it is sufficient to prove
  thus ex b1 being countable open Element of bool bool the carrier of a1 st
       a2 = meet b1;

:: TOPGEN_4:def 7
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is G_delta(b1)
   iff
      ex b3 being countable open Element of bool bool the carrier of b1 st
         b2 = meet b3;

:: TOPGEN_4:th 35
theorem
for b1 being non empty TopSpace-like TopStruct holds
   {} b1 is F_sigma(b1);

:: TOPGEN_4:th 36
theorem
for b1 being non empty TopSpace-like TopStruct holds
   {} b1 is G_delta(b1);

:: TOPGEN_4:funcreg 4
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster {} a1 -> F_sigma G_delta;
end;

:: TOPGEN_4:th 37
theorem
for b1 being non empty TopSpace-like TopStruct holds
   [#] b1 is F_sigma(b1);

:: TOPGEN_4:th 38
theorem
for b1 being non empty TopSpace-like TopStruct holds
   [#] b1 is G_delta(b1);

:: TOPGEN_4:funcreg 5
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster [#] a1 -> F_sigma G_delta;
end;

:: TOPGEN_4:th 39
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is F_sigma(b1)
   holds b2 ` is G_delta(b1);

:: TOPGEN_4:th 40
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is G_delta(b1)
   holds b2 ` is F_sigma(b1);

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

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

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

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

:: TOPGEN_4:th 45
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 b2 is F_sigma(b1);

:: TOPGEN_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 open(b1)
   holds b2 is G_delta(b1);

:: TOPGEN_4:th 47
theorem
for b1 being Element of bool the carrier of R^1
      st b1 = RAT
   holds b1 is F_sigma(R^1);

:: TOPGEN_4:attrnot 7 => TOPGEN_4:attr 7
definition
  let a1 be TopSpace-like TopStruct;
  attr a1 is T_1/2 means
    for b1 being Element of bool the carrier of a1 holds
       Der b1 is closed(a1);
end;

:: TOPGEN_4:dfs 8
definiens
  let a1 be TopSpace-like TopStruct;
To prove
     a1 is T_1/2
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1 holds
       Der b1 is closed(a1);

:: TOPGEN_4:def 8
theorem
for b1 being TopSpace-like TopStruct holds
      b1 is T_1/2
   iff
      for b2 being Element of bool the carrier of b1 holds
         Der b2 is closed(b1);

:: TOPGEN_4:th 48
theorem
for b1 being TopSpace-like TopStruct
      st b1 is being_T1
   holds b1 is T_1/2;

:: TOPGEN_4:th 49
theorem
for b1 being non empty TopSpace-like TopStruct
      st b1 is T_1/2
   holds b1 is discerning;

:: TOPGEN_4:condreg 11
registration
  cluster TopSpace-like T_1/2 -> discerning (TopStruct);
end;

:: TOPGEN_4:condreg 12
registration
  cluster TopSpace-like being_T1 -> T_1/2 (TopStruct);
end;

:: TOPGEN_4:prednot 1 => TOPGEN_4:pred 1
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
  pred A3 is_a_condensation_point_of A2 means
    for b1 being a_neighborhood of a3 holds
       b1 /\ a2 is not countable;
end;

:: TOPGEN_4:dfs 9
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
To prove
     a3 is_a_condensation_point_of a2
it is sufficient to prove
  thus for b1 being a_neighborhood of a3 holds
       b1 /\ a2 is not countable;

:: TOPGEN_4:def 9
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      b3 is_a_condensation_point_of b2
   iff
      for b4 being a_neighborhood of b3 holds
         b4 /\ b2 is not countable;

:: TOPGEN_4:th 51
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1
      st b4 is_a_condensation_point_of b2 & b2 c= b3
   holds b4 is_a_condensation_point_of b3;

:: TOPGEN_4:funcnot 4 => TOPGEN_4:func 4
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  func A2 ^0 -> Element of bool the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
          b1 in it
       iff
          b1 is_a_condensation_point_of a2;
end;

:: TOPGEN_4:def 10
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1 holds
   b3 = b2 ^0
iff
   for b4 being Element of the carrier of b1 holds
         b4 in b3
      iff
         b4 is_a_condensation_point_of b2;

:: TOPGEN_4:th 52
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b3 is_a_condensation_point_of b2
   holds b3 is_an_accumulation_point_of b2;

:: TOPGEN_4:th 53
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   b2 ^0 c= Der b2;

:: TOPGEN_4:th 54
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   b2 ^0 = Cl (b2 ^0);

:: TOPGEN_4:th 55
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds b2 ^0 c= b3 ^0;

:: TOPGEN_4:th 56
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1
      st b4 is_a_condensation_point_of b2 \/ b3 & not b4 is_a_condensation_point_of b2
   holds b4 is_a_condensation_point_of b3;

:: TOPGEN_4:th 57
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1 holds
(b2 \/ b3) ^0 = b2 ^0 \/ (b3 ^0);

:: TOPGEN_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 countable
for b3 being Element of the carrier of b1 holds
   not b3 is_a_condensation_point_of b2;

:: TOPGEN_4:th 59
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is countable
   holds b2 ^0 = {};

:: TOPGEN_4:funcreg 6
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be countable Element of bool the carrier of a1;
  cluster a2 ^0 -> empty;
end;

:: TOPGEN_4:th 60
theorem
for b1 being non empty TopSpace-like TopStruct
      st b1 is second-countable
   holds ex b2 being Basis of b1 st
      b2 is countable;

:: TOPGEN_4:exreg 3
registration
  cluster non empty TopSpace-like second-countable TopStruct;
end;

:: TOPGEN_4:funcreg 7
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster TotFam a1 -> non empty compl-closed all-open-containing closed_for_countable_unions;
end;

:: TOPGEN_4:th 61
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of NAT,bool b1 holds
   rng b2 is non empty countable Element of bool bool b1;

:: TOPGEN_4:th 63
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
      st b2 is all-open-containing(b1) & b2 c= b3
   holds b3 is all-open-containing(b1);

:: TOPGEN_4:th 64
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
      st b2 is all-closed-containing(b1) & b2 c= b3
   holds b3 is all-closed-containing(b1);

:: TOPGEN_4:modenot 1
definition
  let a1 be 1-sorted;
  mode SigmaField of a1 is non empty compl-closed sigma-multiplicative Element of bool bool the carrier of a1;
end;

:: TOPGEN_4:exreg 4
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster compl-closed all-open-containing all-closed-containing closed_for_countable_unions closed_for_countable_meets Element of bool bool the carrier of a1;
end;

:: TOPGEN_4:th 65
theorem
for b1 being non empty TopSpace-like TopStruct holds
   sigma TotFam b1 is all-open-containing(b1) & sigma TotFam b1 is compl-closed(the carrier of b1) & sigma TotFam b1 is closed_for_countable_unions(the carrier of b1);

:: TOPGEN_4:funcreg 8
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster sigma TotFam a1 -> non empty compl-closed sigma-multiplicative all-open-containing closed_for_countable_unions;
end;

:: TOPGEN_4:exreg 5
registration
  let a1 be non empty 1-sorted;
  cluster non empty compl-closed sigma-additive closed_for_countable_unions Element of bool bool the carrier of a1;
end;

:: TOPGEN_4:condreg 13
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty compl-closed sigma-multiplicative -> closed_for_countable_unions (Element of bool bool the carrier of a1);
end;

:: TOPGEN_4:th 66
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1
      st b2 is compl-closed(the carrier of b1) & b2 is closed_for_countable_unions(the carrier of b1)
   holds b2 is non empty compl-closed sigma-multiplicative Element of bool bool the carrier of b1;

:: TOPGEN_4:exreg 6
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty cup-closed cap-closed compl-closed sigma-multiplicative sigma-additive all-open-containing closed_for_countable_unions Element of bool bool the carrier of a1;
end;

:: TOPGEN_4:funcreg 9
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster Topology_of a1 -> open all-open-containing;
end;

:: TOPGEN_4:th 67
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1 holds
   ex b3 being compl-closed all-open-containing closed_for_countable_unions Element of bool bool the carrier of b1 st
      b2 c= b3 &
       (for b4 being compl-closed all-open-containing closed_for_countable_unions Element of bool bool the carrier of b1
             st b2 c= b4
          holds b3 c= b4);

:: TOPGEN_4:funcnot 5 => TOPGEN_4:func 5
definition
  let a1 be non empty TopSpace-like TopStruct;
  func BorelSets A1 -> compl-closed all-open-containing closed_for_countable_unions Element of bool bool the carrier of a1 means
    for b1 being compl-closed all-open-containing closed_for_countable_unions Element of bool bool the carrier of a1 holds
       it c= b1;
end;

:: TOPGEN_4:def 11
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being compl-closed all-open-containing closed_for_countable_unions Element of bool bool the carrier of b1 holds
      b2 = BorelSets b1
   iff
      for b3 being compl-closed all-open-containing closed_for_countable_unions Element of bool bool the carrier of b1 holds
         b2 c= b3;

:: TOPGEN_4:th 68
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being closed Element of bool bool the carrier of b1 holds
   b2 c= BorelSets b1;

:: TOPGEN_4:th 69
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being open Element of bool bool the carrier of b1 holds
   b2 c= BorelSets b1;

:: TOPGEN_4:th 70
theorem
for b1 being non empty TopSpace-like TopStruct holds
   BorelSets b1 = sigma Topology_of b1;

:: TOPGEN_4:attrnot 8 => TOPGEN_4:attr 8
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is Borel means
    a2 in BorelSets a1;
end;

:: TOPGEN_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 Borel
it is sufficient to prove
  thus a2 in BorelSets a1;

:: TOPGEN_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 Borel(b1)
   iff
      b2 in BorelSets b1;

:: TOPGEN_4:condreg 14
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster F_sigma -> Borel (Element of bool the carrier of a1);
end;

:: TOPGEN_4:condreg 15
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster G_delta -> Borel (Element of bool the carrier of a1);
end;