Article TOPGEN_3, MML version 4.99.1005

:: TOPGEN_3:attrnot 1 => TOPGEN_3:attr 1
definition
  let a1 be set;
  let a2 be Element of bool bool a1;
  attr a2 is point-filtered means
    for b1, b2, b3 being set
          st b2 in a2 & b3 in a2 & b1 in b2 /\ b3
       holds ex b4 being Element of bool a1 st
          b4 in a2 & b1 in b4 & b4 c= b2 /\ b3;
end;

:: TOPGEN_3:dfs 1
definiens
  let a1 be set;
  let a2 be Element of bool bool a1;
To prove
     a2 is point-filtered
it is sufficient to prove
  thus for b1, b2, b3 being set
          st b2 in a2 & b3 in a2 & b1 in b2 /\ b3
       holds ex b4 being Element of bool a1 st
          b4 in a2 & b1 in b4 & b4 c= b2 /\ b3;

:: TOPGEN_3:def 1
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is point-filtered(b1)
   iff
      for b3, b4, b5 being set
            st b4 in b2 & b5 in b2 & b3 in b4 /\ b5
         holds ex b6 being Element of bool b1 st
            b6 in b2 & b3 in b6 & b6 c= b4 /\ b5;

:: TOPGEN_3:th 1
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is covering(bool bool b1)
   iff
      for b3 being set
            st b3 in b1
         holds ex b4 being Element of bool b1 st
            b4 in b2 & b3 in b4;

:: TOPGEN_3:th 2
theorem
for b1 being set
for b2 being Element of bool bool b1
   st b2 is point-filtered(b1) & b2 is covering(bool bool b1)
for b3 being TopStruct
      st the carrier of b3 = b1 & the topology of b3 = UniCl b2
   holds b3 is TopSpace-like TopStruct & b2 is Basis of b3;

:: TOPGEN_3:th 3
theorem
for b1 being set
for b2 being non-empty ManySortedSet of b1
      st proj2 b2 c= bool bool b1 &
         (for b3, b4 being set
               st b3 in b1 & b4 in b2 . b3
            holds b3 in b4) &
         (for b3, b4, b5 being set
               st b3 in b5 & b5 in b2 . b4 & b4 in b1
            holds ex b6 being set st
               b6 in b2 . b3 & b6 c= b5) &
         (for b3, b4, b5 being set
               st b3 in b1 & b4 in b2 . b3 & b5 in b2 . b3
            holds ex b6 being set st
               b6 in b2 . b3 & b6 c= b4 /\ b5)
   holds ex b3 being Element of bool bool b1 st
      b3 = Union b2 &
       (for b4 being TopStruct
             st the carrier of b4 = b1 & the topology of b4 = UniCl b3
          holds b4 is TopSpace-like TopStruct &
           (for b5 being non empty TopSpace-like TopStruct
                 st b5 = b4
              holds b2 is Neighborhood_System of b5));

:: TOPGEN_3:th 4
theorem
for b1 being set
for b2 being Element of bool bool b1
   st {} in b2 &
      b1 in b2 &
      (for b3, b4 being set
            st b3 in b2 & b4 in b2
         holds b3 \/ b4 in b2) &
      (for b3 being Element of bool bool b1
            st b3 c= b2
         holds Intersect b3 in b2)
for b3 being TopStruct
      st the carrier of b3 = b1 & the topology of b3 = COMPLEMENT b2
   holds b3 is TopSpace-like TopStruct &
    (for b4 being Element of bool the carrier of b3 holds
          b4 is closed(b3)
       iff
          b4 in b2);

:: TOPGEN_3:sch 1
scheme TOPGEN_3:sch 1
{F1 -> set}:
ex b1 being strict TopSpace-like TopStruct st
   the carrier of b1 = F1() &
    (for b2 being Element of bool the carrier of b1 holds
          b2 is closed(b1)
       iff
          P1[b2])
provided
   P1[{}] & P1[F1()]
and
   for b1, b2 being set
         st P1[b1] & P1[b2]
      holds P1[b1 \/ b2]
and
   for b1 being Element of bool bool F1()
         st for b2 being set
                 st b2 in b1
              holds P1[b2]
      holds P1[Intersect b1];


:: TOPGEN_3:th 5
theorem
for b1, b2 being TopSpace-like TopStruct
      st for b3 being set holds
              b3 is open Element of bool the carrier of b1
           iff
              b3 is open Element of bool the carrier of b2
   holds TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#);

:: TOPGEN_3:th 6
theorem
for b1, b2 being TopSpace-like TopStruct
      st for b3 being set holds
              b3 is closed Element of bool the carrier of b1
           iff
              b3 is closed Element of bool the carrier of b2
   holds TopStruct(#the carrier of b1,the topology of b1#) = TopStruct(#the carrier of b2,the topology of b2#);

:: TOPGEN_3:funcnot 1 => TOPGEN_3:func 1
definition
  let a1, a2 be set;
  let a3 be Element of bool [:a1,bool a2:];
  redefine func rng a3 -> Element of bool bool a2;
end;

:: TOPGEN_3:th 7
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of bool b1,bool b1
   st b2 . {} = {} &
      (for b3 being Element of bool b1 holds
         b3 c= b2 . b3) &
      (for b3, b4 being Element of bool b1 holds
      b2 . (b3 \/ b4) = (b2 . b3) \/ (b2 . b4)) &
      (for b3 being Element of bool b1 holds
         b2 . (b2 . b3) = b2 . b3)
for b3 being TopStruct
      st the carrier of b3 = b1 & the topology of b3 = COMPLEMENT rng b2
   holds b3 is TopSpace-like TopStruct &
    (for b4 being Element of bool the carrier of b3 holds
       Cl b4 = b2 . b4);

:: TOPGEN_3:sch 2
scheme TOPGEN_3:sch 2
{F1 -> set,
  F2 -> set}:
ex b1 being strict TopSpace-like TopStruct st
   the carrier of b1 = F1() &
    (for b2 being Element of bool the carrier of b1 holds
       Cl b2 = F2(b2))
provided
   F2({}) = {}
and
   for b1 being Element of bool F1() holds
      b1 c= F2(b1) & F2(b1) c= F1()
and
   for b1, b2 being Element of bool F1() holds
   F2(b1 \/ b2) = F2(b1) \/ F2(b2)
and
   for b1 being Element of bool F1() holds
      F2(F2(b1)) = F2(b1);


:: TOPGEN_3:th 8
theorem
for b1, b2 being TopSpace-like TopStruct
      st the carrier of b1 = the carrier of b2 &
         (for b3 being Element of bool the carrier of b1
         for b4 being Element of bool the carrier of b2
               st b3 = b4
            holds Cl b3 = Cl b4)
   holds the topology of b1 = the topology of b2;

:: TOPGEN_3:th 9
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of bool b1,bool b1
   st b2 . b1 = b1 &
      (for b3 being Element of bool b1 holds
         b2 . b3 c= b3) &
      (for b3, b4 being Element of bool b1 holds
      b2 . (b3 /\ b4) = (b2 . b3) /\ (b2 . b4)) &
      (for b3 being Element of bool b1 holds
         b2 . (b2 . b3) = b2 . b3)
for b3 being TopStruct
      st the carrier of b3 = b1 & the topology of b3 = rng b2
   holds b3 is TopSpace-like TopStruct &
    (for b4 being Element of bool the carrier of b3 holds
       Int b4 = b2 . b4);

:: TOPGEN_3:sch 3
scheme TOPGEN_3:sch 3
{F1 -> set,
  F2 -> set}:
ex b1 being strict TopSpace-like TopStruct st
   the carrier of b1 = F1() &
    (for b2 being Element of bool the carrier of b1 holds
       Int b2 = F2(b2))
provided
   F2(F1()) = F1()
and
   for b1 being Element of bool F1() holds
      F2(b1) c= b1
and
   for b1, b2 being Element of bool F1() holds
   F2(b1 /\ b2) = F2(b1) /\ F2(b2)
and
   for b1 being Element of bool F1() holds
      F2(F2(b1)) = F2(b1);


:: TOPGEN_3:th 10
theorem
for b1, b2 being TopSpace-like TopStruct
      st the carrier of b1 = the carrier of b2 &
         (for b3 being Element of bool the carrier of b1
         for b4 being Element of bool the carrier of b2
               st b3 = b4
            holds Int b3 = Int b4)
   holds the topology of b1 = the topology of b2;

:: TOPGEN_3:funcnot 2 => TOPGEN_3:func 2
definition
  func Sorgenfrey-line -> non empty strict TopSpace-like TopStruct means
    the carrier of it = REAL &
     (ex b1 being Element of bool bool REAL st
        the topology of it = UniCl b1 &
         b1 = {[.b2,b3.[ where b2 is Element of REAL, b3 is Element of REAL: b2 < b3 & b3 is rational});
end;

:: TOPGEN_3:def 2
theorem
for b1 being non empty strict TopSpace-like TopStruct holds
      b1 = Sorgenfrey-line
   iff
      the carrier of b1 = REAL &
       (ex b2 being Element of bool bool REAL st
          the topology of b1 = UniCl b2 &
           b2 = {[.b3,b4.[ where b3 is Element of REAL, b4 is Element of REAL: b3 < b4 & b4 is rational});

:: TOPGEN_3:th 11
theorem
for b1, b2 being real set holds
[.b1,b2.[ is open Element of bool the carrier of Sorgenfrey-line;

:: TOPGEN_3:th 12
theorem
for b1, b2 being real set holds
].b1,b2.[ is open Element of bool the carrier of Sorgenfrey-line;

:: TOPGEN_3:th 13
theorem
for b1 being real set holds
   halfline b1 is open Element of bool the carrier of Sorgenfrey-line;

:: TOPGEN_3:th 14
theorem
for b1 being real set holds
   right_open_halfline b1 is open Element of bool the carrier of Sorgenfrey-line;

:: TOPGEN_3:th 15
theorem
for b1 being real set holds
   right_closed_halfline b1 is open Element of bool the carrier of Sorgenfrey-line;

:: TOPGEN_3:th 16
theorem
Card INT = alef 0;

:: TOPGEN_3:th 17
theorem
Card RAT = alef 0;

:: TOPGEN_3:th 18
theorem
for b1 being set
      st b1 is mutually-disjoint &
         (for b2 being set
               st b2 in b1
            holds ex b3, b4 being real set st
               b3 < b4 & ].b3,b4.[ c= b2)
   holds b1 is countable;

:: TOPGEN_3:prednot 1 => TOPGEN_3:pred 1
definition
  let a1 be set;
  let a2 be real set;
  pred A2 is_local_minimum_of A1 means
    a2 in a1 &
     (ex b1 being real set st
        b1 < a2 & ].b1,a2.[ misses a1);
end;

:: TOPGEN_3:dfs 3
definiens
  let a1 be set;
  let a2 be real set;
To prove
     a2 is_local_minimum_of a1
it is sufficient to prove
  thus a2 in a1 &
     (ex b1 being real set st
        b1 < a2 & ].b1,a2.[ misses a1);

:: TOPGEN_3:def 3
theorem
for b1 being set
for b2 being real set holds
      b2 is_local_minimum_of b1
   iff
      b2 in b1 &
       (ex b3 being real set st
          b3 < b2 & ].b3,b2.[ misses b1);

:: TOPGEN_3:th 19
theorem
for b1 being Element of bool REAL holds
   {b2 where b2 is Element of REAL: b2 is_local_minimum_of b1} is countable;

:: TOPGEN_3:funcreg 1
registration
  let a1 be infinite cardinal set;
  cluster exp(2,a1) -> infinite cardinal;
end;

:: TOPGEN_3:funcnot 3 => TOPGEN_3:func 3
definition
  func continuum -> infinite cardinal set equals
    Card REAL;
end;

:: TOPGEN_3:def 4
theorem
continuum = Card REAL;

:: TOPGEN_3:th 20
theorem
Card {[.b1,b2.[ where b1 is Element of REAL, b2 is Element of REAL: b1 < b2 & b2 is rational} = continuum;

:: TOPGEN_3:funcnot 4 => TOPGEN_3:func 4
definition
  let a1 be set;
  let a2 be real set;
  func A1 -powers A2 -> Function-like quasi_total Relation of NAT,REAL means
    for b1 being natural set
          st (b1 in a1 implies it . b1 <> a2 |^ b1)
       holds not b1 in a1 & it . b1 = 0;
end;

:: TOPGEN_3:def 5
theorem
for b1 being set
for b2 being real set
for b3 being Function-like quasi_total Relation of NAT,REAL holds
      b3 = b1 -powers b2
   iff
      for b4 being natural set
            st (b4 in b1 implies b3 . b4 <> b2 |^ b4)
         holds not b4 in b1 & b3 . b4 = 0;

:: TOPGEN_3:th 21
theorem
for b1 being set
for b2 being real set
      st 0 < b2 & b2 < 1
   holds b1 -powers b2 is summable;

:: TOPGEN_3:th 22
theorem
for b1 being real set
for b2 being Element of NAT
      st 0 < b1 & b1 < 1
   holds Sum (b1 GeoSeq ^\ b2) = (b1 |^ b2) / (1 - b1);

:: TOPGEN_3:th 23
theorem
for b1 being Element of NAT holds
   Sum ((1 / 2) GeoSeq ^\ (b1 + 1)) = (1 / 2) |^ b1;

:: TOPGEN_3:th 24
theorem
for b1 being real set
for b2 being set
      st 0 < b1 & b1 < 1
   holds Sum (b2 -powers b1) <= Sum (b1 GeoSeq);

:: TOPGEN_3:th 25
theorem
for b1 being set
for b2 being Element of NAT holds
   Sum ((b1 -powers (1 / 2)) ^\ (b2 + 1)) <= (1 / 2) |^ b2;

:: TOPGEN_3:th 26
theorem
for b1 being infinite Element of bool NAT
for b2 being natural set holds
   (Partial_Sums (b1 -powers (1 / 2))) . b2 < Sum (b1 -powers (1 / 2));

:: TOPGEN_3:th 27
theorem
for b1, b2 being infinite Element of bool NAT
      st Sum (b1 -powers (1 / 2)) = Sum (b2 -powers (1 / 2))
   holds b1 = b2;

:: TOPGEN_3:th 28
theorem
for b1 being set
      st b1 is countable
   holds Fin b1 is countable;

:: TOPGEN_3:th 29
theorem
continuum = exp(2,alef 0);

:: TOPGEN_3:th 30
theorem
alef 0 in continuum;

:: TOPGEN_3:th 31
theorem
for b1 being Element of bool bool REAL
      st Card b1 in continuum
   holds Card {b2 where b2 is Element of REAL: ex b3 being set st
      b3 in UniCl b1 & b2 is_local_minimum_of b3} in continuum;

:: TOPGEN_3:th 32
theorem
for b1 being Element of bool bool REAL
      st Card b1 in continuum
   holds ex b2 being real set st
      ex b3 being rational set st
         b2 < b3 & not [.b2,b3.[ in UniCl b1;

:: TOPGEN_3:th 33
theorem
weight Sorgenfrey-line = continuum;

:: TOPGEN_3:funcnot 5 => TOPGEN_3:func 5
definition
  let a1 be set;
  func ClFinTop A1 -> strict TopSpace-like TopStruct means
    the carrier of it = a1 &
     (for b1 being Element of bool the carrier of it holds
           b1 is closed(it)
        iff
           (b1 is finite or b1 = a1));
end;

:: TOPGEN_3:def 6
theorem
for b1 being set
for b2 being strict TopSpace-like TopStruct holds
      b2 = ClFinTop b1
   iff
      the carrier of b2 = b1 &
       (for b3 being Element of bool the carrier of b2 holds
             b3 is closed(b2)
          iff
             (b3 is finite or b3 = b1));

:: TOPGEN_3:th 34
theorem
for b1 being set
for b2 being Element of bool the carrier of ClFinTop b1 holds
      b2 is open(ClFinTop b1)
   iff
      (b2 = {} or b2 ` is finite);

:: TOPGEN_3:th 35
theorem
for b1 being infinite set
for b2 being Element of bool b1
      st b2 is finite
   holds b2 ` is infinite;

:: TOPGEN_3:funcreg 2
registration
  let a1 be non empty set;
  cluster ClFinTop a1 -> non empty strict TopSpace-like;
end;

:: TOPGEN_3:th 36
theorem
for b1 being infinite set
for b2, b3 being non empty open Element of bool the carrier of ClFinTop b1 holds
b2 meets b3;

:: TOPGEN_3:funcnot 6 => TOPGEN_3:func 6
definition
  let a1, a2 be set;
  func A2 -PointClTop A1 -> strict TopSpace-like TopStruct means
    the carrier of it = a1 &
     (for b1 being Element of bool the carrier of it holds
        Cl b1 = IFEQ(b1,{},b1,b1 \/ ({a2} /\ a1)));
end;

:: TOPGEN_3:def 7
theorem
for b1, b2 being set
for b3 being strict TopSpace-like TopStruct holds
      b3 = b2 -PointClTop b1
   iff
      the carrier of b3 = b1 &
       (for b4 being Element of bool the carrier of b3 holds
          Cl b4 = IFEQ(b4,{},b4,b4 \/ ({b2} /\ b1)));

:: TOPGEN_3:funcreg 3
registration
  let a1 be non empty set;
  let a2 be set;
  cluster a2 -PointClTop a1 -> non empty strict TopSpace-like;
end;

:: TOPGEN_3:th 37
theorem
for b1 being non empty set
for b2 being Element of b1
for b3 being non empty Element of bool the carrier of b2 -PointClTop b1 holds
   Cl b3 = b3 \/ {b2};

:: TOPGEN_3:th 38
theorem
for b1 being non empty set
for b2 being Element of b1
for b3 being non empty Element of bool the carrier of b2 -PointClTop b1 holds
      b3 is closed(b2 -PointClTop b1)
   iff
      b2 in b3;

:: TOPGEN_3:th 39
theorem
for b1 being non empty set
for b2 being Element of b1
for b3 being proper Element of bool the carrier of b2 -PointClTop b1 holds
      b3 is open(b2 -PointClTop b1)
   iff
      not b2 in b3;

:: TOPGEN_3:th 40
theorem
for b1, b2, b3 being set
      st b2 in b1
   holds    {b3} is closed Element of bool the carrier of b2 -PointClTop b1
   iff
      b3 = b2;

:: TOPGEN_3:th 41
theorem
for b1, b2, b3 being set
      st {b2} c< b1
   holds    {b3} is open Element of bool the carrier of b2 -PointClTop b1
   iff
      b3 in b1 & b3 <> b2;

:: TOPGEN_3:funcnot 7 => TOPGEN_3:func 7
definition
  let a1, a2 be set;
  func A2 -DiscreteTop A1 -> strict TopSpace-like TopStruct means
    the carrier of it = a1 &
     (for b1 being Element of bool the carrier of it holds
        Int b1 = IFEQ(b1,a1,b1,b1 /\ a2));
end;

:: TOPGEN_3:def 8
theorem
for b1, b2 being set
for b3 being strict TopSpace-like TopStruct holds
      b3 = b2 -DiscreteTop b1
   iff
      the carrier of b3 = b1 &
       (for b4 being Element of bool the carrier of b3 holds
          Int b4 = IFEQ(b4,b1,b4,b4 /\ b2));

:: TOPGEN_3:funcreg 4
registration
  let a1 be non empty set;
  let a2 be set;
  cluster a2 -DiscreteTop a1 -> non empty strict TopSpace-like;
end;

:: TOPGEN_3:th 42
theorem
for b1 being non empty set
for b2 being set
for b3 being proper Element of bool the carrier of b2 -DiscreteTop b1 holds
   Int b3 = b3 /\ b2;

:: TOPGEN_3:th 43
theorem
for b1 being non empty set
for b2 being set
for b3 being proper Element of bool the carrier of b2 -DiscreteTop b1 holds
      b3 is open(b2 -DiscreteTop b1)
   iff
      b3 c= b2;

:: TOPGEN_3:th 44
theorem
for b1 being set
for b2 being Element of bool b1 holds
   the topology of b2 -DiscreteTop b1 = {b1} \/ bool b2;

:: TOPGEN_3:th 45
theorem
for b1 being set holds
   ADTS b1 = {} -DiscreteTop b1;

:: TOPGEN_3:th 46
theorem
for b1 being set holds
   1TopSp b1 = b1 -DiscreteTop b1;