Article LOPCLSET, MML version 4.99.1005

:: LOPCLSET:funcnot 1 => LOPCLSET:func 1
definition
  let a1 be non empty TopStruct;
  func OpenClosedSet A1 -> Element of bool bool the carrier of a1 equals
    {b1 where b1 is Element of bool the carrier of a1: b1 is open(a1) & b1 is closed(a1)};
end;

:: LOPCLSET:def 1
theorem
for b1 being non empty TopStruct holds
   OpenClosedSet b1 = {b2 where b2 is Element of bool the carrier of b1: b2 is open(b1) & b2 is closed(b1)};

:: LOPCLSET:funcreg 1
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster OpenClosedSet a1 -> non empty;
end;

:: LOPCLSET:th 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 in OpenClosedSet b1
   holds b2 is open(b1);

:: LOPCLSET:th 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 in OpenClosedSet b1
   holds b2 is closed(b1);

:: LOPCLSET:th 4
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 closed(b1)
   holds b2 in OpenClosedSet b1;

:: LOPCLSET:funcnot 2 => LOPCLSET:func 2
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2, a3 be Element of OpenClosedSet a1;
  redefine func a2 \/ a3 -> Element of OpenClosedSet a1;
  commutativity;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2, a3 being Element of OpenClosedSet a1 holds
::  a2 \/ a3 = a3 \/ a2;
  idempotence;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2 being Element of OpenClosedSet a1 holds
::     a2 \/ a2 = a2;
end;

:: LOPCLSET:funcnot 3 => LOPCLSET:func 3
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2, a3 be Element of OpenClosedSet a1;
  redefine func a2 /\ a3 -> Element of OpenClosedSet a1;
  commutativity;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2, a3 being Element of OpenClosedSet a1 holds
::  a2 /\ a3 = a3 /\ a2;
  idempotence;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2 being Element of OpenClosedSet a1 holds
::     a2 /\ a2 = a2;
end;

:: LOPCLSET:funcnot 4 => LOPCLSET:func 4
definition
  let a1 be non empty TopSpace-like TopStruct;
  func T_join A1 -> Function-like quasi_total Relation of [:OpenClosedSet a1,OpenClosedSet a1:],OpenClosedSet a1 means
    for b1, b2 being Element of OpenClosedSet a1 holds
    it .(b1,b2) = b1 \/ b2;
end;

:: LOPCLSET:def 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Function-like quasi_total Relation of [:OpenClosedSet b1,OpenClosedSet b1:],OpenClosedSet b1 holds
      b2 = T_join b1
   iff
      for b3, b4 being Element of OpenClosedSet b1 holds
      b2 .(b3,b4) = b3 \/ b4;

:: LOPCLSET:funcnot 5 => LOPCLSET:func 5
definition
  let a1 be non empty TopSpace-like TopStruct;
  func T_meet A1 -> Function-like quasi_total Relation of [:OpenClosedSet a1,OpenClosedSet a1:],OpenClosedSet a1 means
    for b1, b2 being Element of OpenClosedSet a1 holds
    it .(b1,b2) = b1 /\ b2;
end;

:: LOPCLSET:def 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Function-like quasi_total Relation of [:OpenClosedSet b1,OpenClosedSet b1:],OpenClosedSet b1 holds
      b2 = T_meet b1
   iff
      for b3, b4 being Element of OpenClosedSet b1 holds
      b2 .(b3,b4) = b3 /\ b4;

:: LOPCLSET:th 5
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of LattStr(#OpenClosedSet b1,T_join b1,T_meet b1#)
for b4, b5 being Element of OpenClosedSet b1
      st b2 = b4 & b3 = b5
   holds b2 "\/" b3 = b4 \/ b5;

:: LOPCLSET:th 6
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of LattStr(#OpenClosedSet b1,T_join b1,T_meet b1#)
for b4, b5 being Element of OpenClosedSet b1
      st b2 = b4 & b3 = b5
   holds b2 "/\" b3 = b4 /\ b5;

:: LOPCLSET:th 7
theorem
for b1 being non empty TopSpace-like TopStruct holds
   {} b1 is Element of OpenClosedSet b1;

:: LOPCLSET:th 8
theorem
for b1 being non empty TopSpace-like TopStruct holds
   [#] b1 is Element of OpenClosedSet b1;

:: LOPCLSET:th 9
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of OpenClosedSet b1 holds
   b2 ` is Element of OpenClosedSet b1;

:: LOPCLSET:th 10
theorem
for b1 being non empty TopSpace-like TopStruct holds
   LattStr(#OpenClosedSet b1,T_join b1,T_meet b1#) is non empty Lattice-like LattStr;

:: LOPCLSET:funcnot 6 => LOPCLSET:func 6
definition
  let a1 be non empty TopSpace-like TopStruct;
  func OpenClosedSetLatt A1 -> non empty Lattice-like LattStr equals
    LattStr(#OpenClosedSet a1,T_join a1,T_meet a1#);
end;

:: LOPCLSET:def 4
theorem
for b1 being non empty TopSpace-like TopStruct holds
   OpenClosedSetLatt b1 = LattStr(#OpenClosedSet b1,T_join b1,T_meet b1#);

:: LOPCLSET:th 11
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of OpenClosedSetLatt b1 holds
b2 "\/" b3 = b2 \/ b3;

:: LOPCLSET:th 12
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of OpenClosedSetLatt b1 holds
b2 "/\" b3 = b2 /\ b3;

:: LOPCLSET:th 13
theorem
for b1 being non empty TopSpace-like TopStruct holds
   the carrier of OpenClosedSetLatt b1 = OpenClosedSet b1;

:: LOPCLSET:th 14
theorem
for b1 being non empty TopSpace-like TopStruct holds
   OpenClosedSetLatt b1 is Boolean;

:: LOPCLSET:th 15
theorem
for b1 being non empty TopSpace-like TopStruct holds
   [#] b1 is Element of the carrier of OpenClosedSetLatt b1;

:: LOPCLSET:th 16
theorem
for b1 being non empty TopSpace-like TopStruct holds
   {} b1 is Element of the carrier of OpenClosedSetLatt b1;

:: LOPCLSET:exreg 1
registration
  cluster non empty non trivial join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like distributive modular lower-bounded upper-bounded bounded complemented Boolean LattStr;
end;

:: LOPCLSET:funcnot 7 => LOPCLSET:func 7
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  func ultraset A1 -> Element of bool bool the carrier of a1 equals
    {b1 where b1 is Filter of a1: b1 is being_ultrafilter(a1)};
end;

:: LOPCLSET:def 5
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   ultraset b1 = {b2 where b2 is Filter of b1: b2 is being_ultrafilter(b1)};

:: LOPCLSET:funcreg 2
registration
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  cluster ultraset a1 -> non empty;
end;

:: LOPCLSET:th 18
theorem
for b1 being set
for b2 being non empty non trivial Lattice-like Boolean LattStr holds
      b1 in ultraset b2
   iff
      ex b3 being Filter of b2 st
         b3 = b1 & b3 is being_ultrafilter(b2);

:: LOPCLSET:th 19
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1 holds
   {b3 where b3 is Filter of b1: b3 is being_ultrafilter(b1) & b2 in b3} c= ultraset b1;

:: LOPCLSET:funcnot 8 => LOPCLSET:func 8
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  func UFilter A1 -> Relation-like Function-like set means
    proj1 it = the carrier of a1 &
     (for b1 being Element of the carrier of a1 holds
        it . b1 = {b2 where b2 is Filter of a1: b2 is being_ultrafilter(a1) & b1 in b2});
end;

:: LOPCLSET:def 6
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being Relation-like Function-like set holds
      b2 = UFilter b1
   iff
      proj1 b2 = the carrier of b1 &
       (for b3 being Element of the carrier of b1 holds
          b2 . b3 = {b4 where b4 is Filter of b1: b4 is being_ultrafilter(b1) & b3 in b4});

:: LOPCLSET:th 20
theorem
for b1 being set
for b2 being non empty non trivial Lattice-like Boolean LattStr
for b3 being Element of the carrier of b2 holds
      b1 in (UFilter b2) . b3
   iff
      ex b4 being Filter of b2 st
         b4 = b1 & b4 is being_ultrafilter(b2) & b3 in b4;

:: LOPCLSET:th 21
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1
for b3 being Filter of b1 holds
      b3 in (UFilter b1) . b2
   iff
      b3 is being_ultrafilter(b1) & b2 in b3;

:: LOPCLSET:th 22
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1
      st b4 is being_ultrafilter(b1)
   holds    b2 "\/" b3 in b4
   iff
      (b2 in b4 or b3 in b4);

:: LOPCLSET:th 23
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
(UFilter b1) . (b2 "/\" b3) = ((UFilter b1) . b2) /\ ((UFilter b1) . b3);

:: LOPCLSET:th 24
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
(UFilter b1) . (b2 "\/" b3) = ((UFilter b1) . b2) \/ ((UFilter b1) . b3);

:: LOPCLSET:funcnot 9 => LOPCLSET:func 9
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  redefine func UFilter a1 -> Function-like quasi_total Relation of the carrier of a1,bool ultraset a1;
end;

:: LOPCLSET:funcnot 10 => LOPCLSET:func 10
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  func StoneR A1 -> set equals
    rng UFilter a1;
end;

:: LOPCLSET:def 7
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   StoneR b1 = rng UFilter b1;

:: LOPCLSET:funcreg 3
registration
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  cluster StoneR a1 -> non empty;
end;

:: LOPCLSET:th 25
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   StoneR b1 c= bool ultraset b1;

:: LOPCLSET:th 26
theorem
for b1 being set
for b2 being non empty non trivial Lattice-like Boolean LattStr holds
      b1 in StoneR b2
   iff
      ex b3 being Element of the carrier of b2 st
         (UFilter b2) . b3 = b1;

:: LOPCLSET:funcnot 11 => LOPCLSET:func 11
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  func StoneSpace A1 -> strict TopSpace-like TopStruct means
    the carrier of it = ultraset a1 &
     the topology of it = {union b1 where b1 is Element of bool bool ultraset a1: b1 c= StoneR a1};
end;

:: LOPCLSET:def 8
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being strict TopSpace-like TopStruct holds
      b2 = StoneSpace b1
   iff
      the carrier of b2 = ultraset b1 &
       the topology of b2 = {union b3 where b3 is Element of bool bool ultraset b1: b3 c= StoneR b1};

:: LOPCLSET:funcreg 4
registration
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  cluster StoneSpace a1 -> non empty strict TopSpace-like;
end;

:: LOPCLSET:th 27
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1
for b3 being Filter of b1
      st b3 is being_ultrafilter(b1) & not b3 in (UFilter b1) . b2
   holds not b2 in b3;

:: LOPCLSET:th 28
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1 holds
   (ultraset b1) \ ((UFilter b1) . b2) = (UFilter b1) . (b2 `);

:: LOPCLSET:funcnot 12 => LOPCLSET:func 12
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  func StoneBLattice A1 -> non empty Lattice-like LattStr equals
    OpenClosedSetLatt StoneSpace a1;
end;

:: LOPCLSET:def 9
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   StoneBLattice b1 = OpenClosedSetLatt StoneSpace b1;

:: LOPCLSET:th 29
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   UFilter b1 is one-to-one;

:: LOPCLSET:th 30
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   union StoneR b1 = ultraset b1;

:: LOPCLSET:th 32
theorem
for b1 being non empty set holds
   ex b2 being Element of Fin b1 st
      b2 is not empty;

:: LOPCLSET:exreg 2
registration
  let a1 be non empty set;
  cluster non empty finite Element of Fin a1;
end;

:: LOPCLSET:th 34
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr
for b2 being non empty Element of bool the carrier of b1
      st Bottom b1 in <.b2.)
   holds ex b3 being non empty Element of Fin the carrier of b1 st
      b3 c= b2 & FinMeet b3 = Bottom b1;

:: LOPCLSET:th 35
theorem
for b1 being non empty Lattice-like lower-bounded LattStr
for b2 being Filter of b1
      st b2 is being_ultrafilter(b1)
   holds not Bottom b1 in b2;

:: LOPCLSET:th 36
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   (UFilter b1) . Bottom b1 = {};

:: LOPCLSET:th 37
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   (UFilter b1) . Top b1 = ultraset b1;

:: LOPCLSET:th 38
theorem
for b1 being set
for b2 being non empty non trivial Lattice-like Boolean LattStr
      st ultraset b2 = union b1 & b1 is Element of bool StoneR b2
   holds ex b3 being Element of Fin b1 st
      ultraset b2 = union b3;

:: LOPCLSET:th 40
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   StoneR b1 = OpenClosedSet StoneSpace b1;

:: LOPCLSET:funcnot 13 => LOPCLSET:func 13
definition
  let a1 be non empty non trivial Lattice-like Boolean LattStr;
  redefine func UFilter a1 -> Homomorphism of a1,StoneBLattice a1;
end;

:: LOPCLSET:th 41
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   rng UFilter b1 = the carrier of StoneBLattice b1;

:: LOPCLSET:th 42
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   UFilter b1 is isomorphism(b1, StoneBLattice b1);

:: LOPCLSET:th 43
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   b1,StoneBLattice b1 are_isomorphic;

:: LOPCLSET:th 44
theorem
for b1 being non empty non trivial Lattice-like Boolean LattStr holds
   ex b2 being non empty TopSpace-like TopStruct st
      b1,OpenClosedSetLatt b2 are_isomorphic;