Article WAYBEL_8, MML version 4.99.1005

:: WAYBEL_8:funcnot 1 => WAYBEL_8:func 1
definition
  let a1 be non empty reflexive RelStr;
  func CompactSublatt A1 -> strict full SubRelStr of a1 means
    for b1 being Element of the carrier of a1 holds
          b1 in the carrier of it
       iff
          b1 is compact(a1);
end;

:: WAYBEL_8:def 1
theorem
for b1 being non empty reflexive RelStr
for b2 being strict full SubRelStr of b1 holds
      b2 = CompactSublatt b1
   iff
      for b3 being Element of the carrier of b1 holds
            b3 in the carrier of b2
         iff
            b3 is compact(b1);

:: WAYBEL_8:funcreg 1
registration
  let a1 be non empty reflexive antisymmetric lower-bounded RelStr;
  cluster CompactSublatt a1 -> non empty strict full;
end;

:: WAYBEL_8:th 1
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima complete RelStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 <= b4 & b4 <= b3 & b4 in the carrier of CompactSublatt b1
   holds b2 is_way_below b3;

:: WAYBEL_8:th 2
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima complete RelStr
for b2 being Element of the carrier of b1 holds
      uparrow b2 is non empty filtered upper Open Element of bool the carrier of b1
   iff
      b2 is compact(b1);

:: WAYBEL_8:th 3
theorem
for b1 being non empty reflexive transitive antisymmetric with_suprema lower-bounded RelStr holds
   CompactSublatt b1 is join-inheriting(b1) & Bottom b1 in the carrier of CompactSublatt b1;

:: WAYBEL_8:funcnot 2 => WAYBEL_8:func 2
definition
  let a1 be non empty reflexive RelStr;
  let a2 be Element of the carrier of a1;
  func compactbelow A2 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 <= a2 & b1 is compact(a1)};
end;

:: WAYBEL_8:def 2
theorem
for b1 being non empty reflexive RelStr
for b2 being Element of the carrier of b1 holds
   compactbelow b2 = {b3 where b3 is Element of the carrier of b1: b3 <= b2 & b3 is compact(b1)};

:: WAYBEL_8:th 4
theorem
for b1 being non empty reflexive RelStr
for b2, b3 being Element of the carrier of b1 holds
   b3 in compactbelow b2
iff
   b3 <= b2 & b3 is compact(b1);

:: WAYBEL_8:th 5
theorem
for b1 being non empty reflexive RelStr
for b2 being Element of the carrier of b1 holds
   compactbelow b2 = (downarrow b2) /\ the carrier of CompactSublatt b1;

:: WAYBEL_8:th 6
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of the carrier of b1 holds
   compactbelow b2 c= waybelow b2;

:: WAYBEL_8:funcreg 2
registration
  let a1 be non empty reflexive antisymmetric lower-bounded RelStr;
  let a2 be Element of the carrier of a1;
  cluster compactbelow a2 -> non empty;
end;

:: WAYBEL_8:attrnot 1 => WAYBEL_8:attr 1
definition
  let a1 be non empty reflexive RelStr;
  attr a1 is satisfying_axiom_K means
    for b1 being Element of the carrier of a1 holds
       b1 = "\/"(compactbelow b1,a1);
end;

:: WAYBEL_8:dfs 3
definiens
  let a1 be non empty reflexive RelStr;
To prove
     a1 is satisfying_axiom_K
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 = "\/"(compactbelow b1,a1);

:: WAYBEL_8:def 3
theorem
for b1 being non empty reflexive RelStr holds
      b1 is satisfying_axiom_K
   iff
      for b2 being Element of the carrier of b1 holds
         b2 = "\/"(compactbelow b2,b1);

:: WAYBEL_8:attrnot 2 => WAYBEL_8:attr 2
definition
  let a1 be non empty reflexive RelStr;
  attr a1 is algebraic means
    (for b1 being Element of the carrier of a1 holds
        compactbelow b1 is not empty & compactbelow b1 is directed(a1)) &
     a1 is up-complete &
     a1 is satisfying_axiom_K;
end;

:: WAYBEL_8:dfs 4
definiens
  let a1 be non empty reflexive RelStr;
To prove
     a1 is algebraic
it is sufficient to prove
  thus (for b1 being Element of the carrier of a1 holds
        compactbelow b1 is not empty & compactbelow b1 is directed(a1)) &
     a1 is up-complete &
     a1 is satisfying_axiom_K;

:: WAYBEL_8:def 4
theorem
for b1 being non empty reflexive RelStr holds
      b1 is algebraic
   iff
      (for b2 being Element of the carrier of b1 holds
          compactbelow b2 is not empty & compactbelow b2 is directed(b1)) &
       b1 is up-complete &
       b1 is satisfying_axiom_K;

:: WAYBEL_8:th 7
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima RelStr holds
      b1 is algebraic
   iff
      b1 is continuous &
       (for b2, b3 being Element of the carrier of b1
             st b2 is_way_below b3
          holds ex b4 being Element of the carrier of b1 st
             b4 in the carrier of CompactSublatt b1 & b2 <= b4 & b4 <= b3);

:: WAYBEL_8:condreg 1
registration
  cluster reflexive transitive antisymmetric with_suprema with_infima algebraic -> continuous (RelStr);
end;

:: WAYBEL_8:condreg 2
registration
  cluster non empty reflexive algebraic -> up-complete satisfying_axiom_K (RelStr);
end;

:: WAYBEL_8:funcreg 3
registration
  let a1 be non empty reflexive transitive antisymmetric with_suprema RelStr;
  cluster CompactSublatt a1 -> strict full join-inheriting;
end;

:: WAYBEL_8:attrnot 3 => WAYBEL_8:attr 3
definition
  let a1 be non empty reflexive RelStr;
  attr a1 is arithmetic means
    a1 is algebraic & CompactSublatt a1 is meet-inheriting(a1);
end;

:: WAYBEL_8:dfs 5
definiens
  let a1 be non empty reflexive RelStr;
To prove
     a1 is arithmetic
it is sufficient to prove
  thus a1 is algebraic & CompactSublatt a1 is meet-inheriting(a1);

:: WAYBEL_8:def 5
theorem
for b1 being non empty reflexive RelStr holds
      b1 is arithmetic
   iff
      b1 is algebraic & CompactSublatt b1 is meet-inheriting(b1);

:: WAYBEL_8:condreg 3
registration
  cluster reflexive transitive antisymmetric with_suprema with_infima arithmetic -> algebraic (RelStr);
end;

:: WAYBEL_8:condreg 4
registration
  cluster trivial reflexive transitive antisymmetric with_suprema with_infima -> arithmetic (RelStr);
end;

:: WAYBEL_8:exreg 1
registration
  cluster non empty trivial strict reflexive transitive antisymmetric with_suprema with_infima RelStr;
end;

:: WAYBEL_8:th 8
theorem
for b1, b2 being non empty reflexive antisymmetric RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
      b1 is up-complete
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b3 = b5 & b4 = b6 & b3 is_way_below b4
   holds b5 is_way_below b6;

:: WAYBEL_8:th 9
theorem
for b1, b2 being non empty reflexive antisymmetric RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
      b1 is up-complete
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2
      st b3 = b4 & b3 is compact(b1)
   holds b4 is compact(b2);

:: WAYBEL_8:th 10
theorem
for b1, b2 being non empty reflexive antisymmetric up-complete RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#)
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2
      st b3 = b4
   holds compactbelow b3 = compactbelow b4;

:: WAYBEL_8:th 11
theorem
for b1, b2 being RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is not empty
   holds b2 is not empty;

:: WAYBEL_8:th 12
theorem
for b1, b2 being RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is reflexive
   holds b2 is reflexive;

:: WAYBEL_8:th 13
theorem
for b1, b2 being RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is transitive
   holds b2 is transitive;

:: WAYBEL_8:th 14
theorem
for b1, b2 being RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is antisymmetric
   holds b2 is antisymmetric;

:: WAYBEL_8:th 15
theorem
for b1, b2 being non empty reflexive RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is up-complete
   holds b2 is up-complete;

:: WAYBEL_8:th 16
theorem
for b1, b2 being non empty reflexive antisymmetric up-complete RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is satisfying_axiom_K &
         (for b3 being Element of the carrier of b1 holds
            compactbelow b3 is not empty & compactbelow b3 is directed(b1))
   holds b2 is satisfying_axiom_K;

:: WAYBEL_8:th 17
theorem
for b1, b2 being non empty reflexive antisymmetric RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is algebraic
   holds b2 is algebraic;

:: WAYBEL_8:th 18
theorem
for b1, b2 being reflexive transitive antisymmetric with_suprema with_infima RelStr
      st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#) &
         b1 is arithmetic
   holds b2 is arithmetic;

:: WAYBEL_8:funcreg 4
registration
  let a1 be non empty RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> non empty strict;
end;

:: WAYBEL_8:funcreg 5
registration
  let a1 be non empty reflexive RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict reflexive;
end;

:: WAYBEL_8:funcreg 6
registration
  let a1 be transitive RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict transitive;
end;

:: WAYBEL_8:funcreg 7
registration
  let a1 be antisymmetric RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict antisymmetric;
end;

:: WAYBEL_8:funcreg 8
registration
  let a1 be with_infima RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict with_infima;
end;

:: WAYBEL_8:funcreg 9
registration
  let a1 be with_suprema RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict with_suprema;
end;

:: WAYBEL_8:funcreg 10
registration
  let a1 be non empty reflexive up-complete RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict up-complete;
end;

:: WAYBEL_8:funcreg 11
registration
  let a1 be non empty reflexive antisymmetric algebraic RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict algebraic;
end;

:: WAYBEL_8:funcreg 12
registration
  let a1 be reflexive transitive antisymmetric with_suprema with_infima arithmetic RelStr;
  cluster RelStr(#the carrier of a1,the InternalRel of a1#) -> strict arithmetic;
end;

:: WAYBEL_8:th 21
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima algebraic RelStr holds
      b1 is arithmetic
   iff
      CompactSublatt b1 is reflexive transitive antisymmetric with_suprema with_infima RelStr;

:: WAYBEL_8:th 22
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima lower-bounded algebraic RelStr holds
      b1 is arithmetic
   iff
      b1 -waybelow is multiplicative(b1);

:: WAYBEL_8:th 23
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima lower-bounded arithmetic RelStr
for b2 being Element of the carrier of b1
      st b2 is pseudoprime(b1)
   holds b2 is prime(b1);

:: WAYBEL_8:th 24
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima lower-bounded distributive algebraic RelStr
      st for b2 being Element of the carrier of b1
              st b2 is pseudoprime(b1)
           holds b2 is prime(b1)
   holds b1 is arithmetic;

:: WAYBEL_8:exreg 2
registration
  let a1 be reflexive transitive antisymmetric with_suprema with_infima algebraic RelStr;
  let a2 be Function-like quasi_total closure Relation of the carrier of a1,the carrier of a1;
  cluster non empty directed Element of bool the carrier of Image a2;
end;

:: WAYBEL_8:th 25
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima algebraic RelStr
for b2 being Function-like quasi_total closure Relation of the carrier of b1,the carrier of b1
      st b2 is directed-sups-preserving(b1, b1)
   holds b2 .: [#] CompactSublatt b1 c= [#] CompactSublatt Image b2;

:: WAYBEL_8:th 26
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima lower-bounded algebraic RelStr
for b2 being Function-like quasi_total closure Relation of the carrier of b1,the carrier of b1
      st b2 is directed-sups-preserving(b1, b1)
   holds Image b2 is reflexive transitive antisymmetric with_suprema with_infima algebraic RelStr;

:: WAYBEL_8:th 27
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima lower-bounded algebraic RelStr
for b2 being Function-like quasi_total closure Relation of the carrier of b1,the carrier of b1
      st b2 is directed-sups-preserving(b1, b1)
   holds b2 .: [#] CompactSublatt b1 = [#] CompactSublatt Image b2;

:: WAYBEL_8:th 28
theorem
for b1, b2 being set holds
   b2 is Element of the carrier of BoolePoset b1
iff
   b2 c= b1;

:: WAYBEL_8:th 29
theorem
for b1 being set
for b2, b3 being Element of the carrier of BoolePoset b1 holds
   b2 is_way_below b3
iff
   for b4 being Element of bool bool b1
         st b3 c= union b4
      holds ex b5 being finite Element of bool b4 st
         b2 c= union b5;

:: WAYBEL_8:th 30
theorem
for b1 being set
for b2 being Element of the carrier of BoolePoset b1 holds
      b2 is finite
   iff
      b2 is compact(BoolePoset b1);

:: WAYBEL_8:th 31
theorem
for b1 being set
for b2 being Element of the carrier of BoolePoset b1 holds
   compactbelow b2 = {b3 where b3 is finite Element of bool b2: TRUE};

:: WAYBEL_8:th 32
theorem
for b1 being set
for b2 being Element of bool b1 holds
      b2 in the carrier of CompactSublatt BoolePoset b1
   iff
      b2 is finite;

:: WAYBEL_8:funcreg 13
registration
  let a1 be set;
  let a2 be Element of the carrier of BoolePoset a1;
  cluster compactbelow a2 -> directed lower;
end;

:: WAYBEL_8:th 33
theorem
for b1 being set holds
   BoolePoset b1 is algebraic;

:: WAYBEL_8:funcreg 14
registration
  let a1 be set;
  cluster BoolePoset a1 -> strict algebraic;
end;