Article OPENLATT, MML version 4.99.1005

:: OPENLATT:condreg 1
registration
  cluster non empty Lattice-like lower-bounded Heyting -> implicative (LattStr);
end;

:: OPENLATT:condreg 2
registration
  cluster non empty Lattice-like implicative -> upper-bounded (LattStr);
end;

:: OPENLATT:th 1
theorem
for b1 being TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1 holds
b2 /\ Int (b2 ` \/ b3) c= b3;

:: OPENLATT:th 2
theorem
for b1 being TopSpace-like TopStruct
for b2, b3, b4 being Element of bool the carrier of b1
      st b4 is open(b1) & b2 /\ b4 c= b3
   holds b4 c= Int (b2 ` \/ b3);

:: OPENLATT:funcnot 1 => OPENLATT:func 1
definition
  let a1 be TopStruct;
  func Topology_of A1 -> Element of bool bool the carrier of a1 equals
    the topology of a1;
end;

:: OPENLATT:def 1
theorem
for b1 being TopStruct holds
   Topology_of b1 = the topology of b1;

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

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

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

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

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

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

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

:: OPENLATT:th 4
theorem
for b1 being non empty TopSpace-like TopStruct holds
   LattStr(#Topology_of b1,Top_Union b1,Top_Meet b1#) is non empty Lattice-like LattStr;

:: OPENLATT:funcnot 6 => OPENLATT:func 6
definition
  let a1 be non empty TopSpace-like TopStruct;
  func Open_setLatt A1 -> non empty Lattice-like LattStr equals
    LattStr(#Topology_of a1,Top_Union a1,Top_Meet a1#);
end;

:: OPENLATT:def 4
theorem
for b1 being non empty TopSpace-like TopStruct holds
   Open_setLatt b1 = LattStr(#Topology_of b1,Top_Union b1,Top_Meet b1#);

:: OPENLATT:th 5
theorem
for b1 being non empty TopSpace-like TopStruct holds
   the carrier of Open_setLatt b1 = Topology_of b1;

:: OPENLATT:th 6
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of Open_setLatt b1 holds
b2 "\/" b3 = b2 \/ b3 & b2 "/\" b3 = b2 /\ b3;

:: OPENLATT:th 7
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of Open_setLatt b1 holds
   b2 [= b3
iff
   b2 c= b3;

:: OPENLATT:th 8
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of the carrier of Open_setLatt b1
for b4, b5 being Element of Topology_of b1
      st b2 = b4 & b3 = b5
   holds    b2 [= b3
   iff
      b4 c= b5;

:: OPENLATT:th 9
theorem
for b1 being non empty TopSpace-like TopStruct holds
   Open_setLatt b1 is implicative;

:: OPENLATT:th 10
theorem
for b1 being non empty TopSpace-like TopStruct holds
   Open_setLatt b1 is lower-bounded & Bottom Open_setLatt b1 = {};

:: OPENLATT:funcreg 2
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster Open_setLatt a1 -> non empty Lattice-like Heyting;
end;

:: OPENLATT:th 11
theorem
for b1 being non empty TopSpace-like TopStruct holds
   Top Open_setLatt b1 = the carrier of b1;

:: OPENLATT:funcnot 7 => OPENLATT:func 7
definition
  let a1 be non empty Lattice-like distributive LattStr;
  func F_primeSet A1 -> set equals
    {b1 where b1 is Filter of a1: b1 <> the carrier of a1 & b1 is prime(a1)};
end;

:: OPENLATT:def 5
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   F_primeSet b1 = {b2 where b2 is Filter of b1: b2 <> the carrier of b1 & b2 is prime(b1)};

:: OPENLATT:th 12
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Filter of b1 holds
      b2 in F_primeSet b1
   iff
      b2 <> the carrier of b1 & b2 is prime(b1);

:: OPENLATT:funcnot 8 => OPENLATT:func 8
definition
  let a1 be non empty Lattice-like distributive LattStr;
  func StoneH A1 -> Relation-like Function-like set means
    for b1 being Element of the carrier of a1 holds
       proj1 it = the carrier of a1 &
        it . b1 = {b2 where b2 is Filter of a1: b2 in F_primeSet a1 & b1 in b2};
end;

:: OPENLATT:def 6
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Relation-like Function-like set holds
      b2 = StoneH b1
   iff
      for b3 being Element of the carrier of b1 holds
         proj1 b2 = the carrier of b1 &
          b2 . b3 = {b4 where b4 is Filter of b1: b4 in F_primeSet b1 & b3 in b4};

:: OPENLATT:th 13
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Filter of b1
for b3 being Element of the carrier of b1 holds
      b2 in (StoneH b1) . b3
   iff
      b2 in F_primeSet b1 & b3 in b2;

:: OPENLATT:th 14
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b3 in (StoneH b1) . b2
   iff
      ex b4 being Filter of b1 st
         b4 = b3 & b4 <> the carrier of b1 & b4 is prime(b1) & b2 in b4;

:: OPENLATT:funcnot 9 => OPENLATT:func 9
definition
  let a1 be non empty Lattice-like distributive LattStr;
  func StoneS A1 -> set equals
    proj2 StoneH a1;
end;

:: OPENLATT:def 7
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   StoneS b1 = proj2 StoneH b1;

:: OPENLATT:funcreg 3
registration
  let a1 be non empty Lattice-like distributive LattStr;
  cluster StoneS a1 -> non empty;
end;

:: OPENLATT:th 15
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being set holds
      b2 in StoneS b1
   iff
      ex b3 being Element of the carrier of b1 st
         b2 = (StoneH b1) . b3;

:: OPENLATT:th 16
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1 holds
(StoneH b1) . (b2 "\/" b3) = ((StoneH b1) . b2) \/ ((StoneH b1) . b3);

:: OPENLATT:th 17
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1 holds
(StoneH b1) . (b2 "/\" b3) = ((StoneH b1) . b2) /\ ((StoneH b1) . b3);

:: OPENLATT:funcnot 10 => OPENLATT:func 10
definition
  let a1 be non empty Lattice-like distributive LattStr;
  let a2 be Element of the carrier of a1;
  func SF_have A2 -> Element of bool bool the carrier of a1 equals
    {b1 where b1 is Filter of a1: a2 in b1};
end;

:: OPENLATT:def 8
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Element of the carrier of b1 holds
   SF_have b2 = {b3 where b3 is Filter of b1: b2 in b3};

:: OPENLATT:funcreg 4
registration
  let a1 be non empty Lattice-like distributive LattStr;
  let a2 be Element of the carrier of a1;
  cluster SF_have a2 -> non empty;
end;

:: OPENLATT:th 18
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b3 in SF_have b2
   iff
      b3 is Filter of b1 & b2 in b3;

:: OPENLATT:th 19
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1
for b4 being set
      st b4 in (SF_have b2) \ SF_have b3
   holds b4 is Filter of b1 & b2 in b4 & not b3 in b4;

:: OPENLATT:th 20
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1
for b4 being set
      st b4 <> {} & b4 c= (SF_have b2) \ SF_have b3 & b4 is c=-linear
   holds ex b5 being set st
      b5 in (SF_have b2) \ SF_have b3 &
       (for b6 being set
             st b6 in b4
          holds b6 c= b5);

:: OPENLATT:th 21
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1
      st not b2 [= b3
   holds <.b2.) in (SF_have b2) \ SF_have b3;

:: OPENLATT:th 22
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1
      st not b2 [= b3
   holds ex b4 being Filter of b1 st
      b4 in F_primeSet b1 & not b3 in b4 & b2 in b4;

:: OPENLATT:th 23
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1
      st b2 <> b3
   holds ex b4 being Filter of b1 st
      b4 in F_primeSet b1;

:: OPENLATT:th 24
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of b1
      st b2 <> b3
   holds (StoneH b1) . b2 <> (StoneH b1) . b3;

:: OPENLATT:th 25
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   StoneH b1 is one-to-one;

:: OPENLATT:funcnot 11 => OPENLATT:func 11
definition
  let a1 be non empty Lattice-like distributive LattStr;
  let a2, a3 be Element of StoneS a1;
  redefine func a2 \/ a3 -> Element of StoneS a1;
  commutativity;
::  for a1 being non empty Lattice-like distributive LattStr
::  for a2, a3 being Element of StoneS a1 holds
::  a2 \/ a3 = a3 \/ a2;
  idempotence;
::  for a1 being non empty Lattice-like distributive LattStr
::  for a2 being Element of StoneS a1 holds
::     a2 \/ a2 = a2;
end;

:: OPENLATT:funcnot 12 => OPENLATT:func 12
definition
  let a1 be non empty Lattice-like distributive LattStr;
  let a2, a3 be Element of StoneS a1;
  redefine func a2 /\ a3 -> Element of StoneS a1;
  commutativity;
::  for a1 being non empty Lattice-like distributive LattStr
::  for a2, a3 being Element of StoneS a1 holds
::  a2 /\ a3 = a3 /\ a2;
  idempotence;
::  for a1 being non empty Lattice-like distributive LattStr
::  for a2 being Element of StoneS a1 holds
::     a2 /\ a2 = a2;
end;

:: OPENLATT:funcnot 13 => OPENLATT:func 13
definition
  let a1 be non empty Lattice-like distributive LattStr;
  func Set_Union A1 -> Function-like quasi_total Relation of [:StoneS a1,StoneS a1:],StoneS a1 means
    for b1, b2 being Element of StoneS a1 holds
    it .(b1,b2) = b1 \/ b2;
end;

:: OPENLATT:def 9
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Function-like quasi_total Relation of [:StoneS b1,StoneS b1:],StoneS b1 holds
      b2 = Set_Union b1
   iff
      for b3, b4 being Element of StoneS b1 holds
      b2 .(b3,b4) = b3 \/ b4;

:: OPENLATT:funcnot 14 => OPENLATT:func 14
definition
  let a1 be non empty Lattice-like distributive LattStr;
  func Set_Meet A1 -> Function-like quasi_total Relation of [:StoneS a1,StoneS a1:],StoneS a1 means
    for b1, b2 being Element of StoneS a1 holds
    it .(b1,b2) = b1 /\ b2;
end;

:: OPENLATT:def 10
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2 being Function-like quasi_total Relation of [:StoneS b1,StoneS b1:],StoneS b1 holds
      b2 = Set_Meet b1
   iff
      for b3, b4 being Element of StoneS b1 holds
      b2 .(b3,b4) = b3 /\ b4;

:: OPENLATT:th 26
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   LattStr(#StoneS b1,Set_Union b1,Set_Meet b1#) is non empty Lattice-like LattStr;

:: OPENLATT:funcnot 15 => OPENLATT:func 15
definition
  let a1 be non empty Lattice-like distributive LattStr;
  func StoneLatt A1 -> non empty Lattice-like LattStr equals
    LattStr(#StoneS a1,Set_Union a1,Set_Meet a1#);
end;

:: OPENLATT:def 11
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   StoneLatt b1 = LattStr(#StoneS b1,Set_Union b1,Set_Meet b1#);

:: OPENLATT:th 27
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   the carrier of StoneLatt b1 = StoneS b1;

:: OPENLATT:th 28
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of StoneLatt b1 holds
b2 "\/" b3 = b2 \/ b3 & b2 "/\" b3 = b2 /\ b3;

:: OPENLATT:th 29
theorem
for b1 being non empty Lattice-like distributive LattStr
for b2, b3 being Element of the carrier of StoneLatt b1 holds
   b2 [= b3
iff
   b2 c= b3;

:: OPENLATT:funcnot 16 => OPENLATT:func 16
definition
  let a1 be non empty Lattice-like distributive LattStr;
  redefine func StoneH a1 -> Homomorphism of a1,StoneLatt a1;
end;

:: OPENLATT:th 30
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   StoneH b1 is isomorphism(b1, StoneLatt b1);

:: OPENLATT:th 31
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   StoneLatt b1 is distributive;

:: OPENLATT:th 32
theorem
for b1 being non empty Lattice-like distributive LattStr holds
   b1,StoneLatt b1 are_isomorphic;

:: OPENLATT: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 Heyting implicative LattStr;
end;

:: OPENLATT:th 33
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   (StoneH b1) . Top b1 = F_primeSet b1;

:: OPENLATT:th 34
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   (StoneH b1) . Bottom b1 = {};

:: OPENLATT:th 35
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   StoneS b1 c= bool F_primeSet b1;

:: OPENLATT:funcreg 5
registration
  let a1 be non empty non trivial Lattice-like Heyting LattStr;
  cluster F_primeSet a1 -> non empty;
end;

:: OPENLATT:funcnot 17 => OPENLATT:func 17
definition
  let a1 be non empty non trivial Lattice-like Heyting LattStr;
  func HTopSpace A1 -> strict TopStruct means
    the carrier of it = F_primeSet a1 &
     the topology of it = {union b1 where b1 is Element of bool StoneS a1: TRUE};
end;

:: OPENLATT:def 12
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr
for b2 being strict TopStruct holds
      b2 = HTopSpace b1
   iff
      the carrier of b2 = F_primeSet b1 &
       the topology of b2 = {union b3 where b3 is Element of bool StoneS b1: TRUE};

:: OPENLATT:funcreg 6
registration
  let a1 be non empty non trivial Lattice-like Heyting LattStr;
  cluster HTopSpace a1 -> non empty strict TopSpace-like;
end;

:: OPENLATT:th 36
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   the carrier of Open_setLatt HTopSpace b1 = {union b2 where b2 is Element of bool StoneS b1: TRUE};

:: OPENLATT:th 37
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   StoneS b1 c= the carrier of Open_setLatt HTopSpace b1;

:: OPENLATT:funcnot 18 => OPENLATT:func 18
definition
  let a1 be non empty non trivial Lattice-like Heyting LattStr;
  redefine func StoneH a1 -> Homomorphism of a1,Open_setLatt HTopSpace a1;
end;

:: OPENLATT:th 38
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   StoneH b1 is monomorphism(b1, Open_setLatt HTopSpace b1);

:: OPENLATT:th 39
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr
for b2, b3 being Element of the carrier of b1 holds
(StoneH b1) . (b2 => b3) = ((StoneH b1) . b2) => ((StoneH b1) . b3);

:: OPENLATT:th 40
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   StoneH b1 preserves_implication;

:: OPENLATT:th 41
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   StoneH b1 preserves_top;

:: OPENLATT:th 42
theorem
for b1 being non empty non trivial Lattice-like Heyting LattStr holds
   StoneH b1 preserves_bottom;