Article YELLOW_0, MML version 4.99.1005

:: YELLOW_0:sch 1
scheme YELLOW_0:sch 1
{F1 -> non empty set}:
ex b1 being non empty strict RelStr st
   the carrier of b1 = F1() &
    (for b2, b3 being Element of the carrier of b1 holds
       b2 <= b3
    iff
       P1[b2, b3])


:: YELLOW_0:attrnot 1 => ORDERS_2:attr 3
definition
  let a1 be RelStr;
  attr a1 is reflexive means
    for b1 being Element of the carrier of a1 holds
       b1 <= b1;
end;

:: YELLOW_0:dfs 1
definiens
  let a1 be non empty RelStr;
To prove
     a1 is reflexive
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 <= b1;

:: YELLOW_0:def 1
theorem
for b1 being non empty RelStr holds
      b1 is reflexive
   iff
      for b2 being Element of the carrier of b1 holds
         b2 <= b2;

:: YELLOW_0:attrnot 2 => ORDERS_2:attr 4
definition
  let a1 be RelStr;
  attr a1 is transitive means
    for b1, b2, b3 being Element of the carrier of a1
          st b1 <= b2 & b2 <= b3
       holds b1 <= b3;
end;

:: YELLOW_0:dfs 2
definiens
  let a1 be RelStr;
To prove
     a1 is transitive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
          st b1 <= b2 & b2 <= b3
       holds b1 <= b3;

:: YELLOW_0:def 2
theorem
for b1 being RelStr holds
      b1 is transitive
   iff
      for b2, b3, b4 being Element of the carrier of b1
            st b2 <= b3 & b3 <= b4
         holds b2 <= b4;

:: YELLOW_0:attrnot 3 => ORDERS_2:attr 5
definition
  let a1 be RelStr;
  attr a1 is antisymmetric means
    for b1, b2 being Element of the carrier of a1
          st b1 <= b2 & b2 <= b1
       holds b1 = b2;
end;

:: YELLOW_0:dfs 3
definiens
  let a1 be RelStr;
To prove
     a1 is antisymmetric
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 <= b2 & b2 <= b1
       holds b1 = b2;

:: YELLOW_0:def 3
theorem
for b1 being RelStr holds
      b1 is antisymmetric
   iff
      for b2, b3 being Element of the carrier of b1
            st b2 <= b3 & b3 <= b2
         holds b2 = b3;

:: YELLOW_0:condreg 1
registration
  cluster non empty complete -> with_suprema with_infima (RelStr);
end;

:: YELLOW_0:condreg 2
registration
  cluster non empty trivial reflexive -> transitive antisymmetric complete (RelStr);
end;

:: YELLOW_0:funcreg 1
registration
  let a1 be set;
  let a2 be Relation of {a1},{a1};
  cluster RelStr(#{a1},a2#) -> trivial strict;
end;

:: YELLOW_0:exreg 1
registration
  cluster non empty trivial strict reflexive RelStr;
end;

:: YELLOW_0:th 1
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#)
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
   holds (b3 <= b4 implies b5 <= b6) & (b3 < b4 implies b5 < b6);

:: YELLOW_0:th 2
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#)
for b3 being set
for b4 being Element of the carrier of b1
for b5 being Element of the carrier of b2
      st b4 = b5
   holds (b3 is_<=_than b4 implies b3 is_<=_than b5) & (b4 is_<=_than b3 implies b5 is_<=_than b3);

:: YELLOW_0:th 3
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 complete
   holds b2 is complete;

:: YELLOW_0:th 4
theorem
for b1 being transitive RelStr
for b2, b3 being Element of the carrier of b1
   st b2 <= b3
for b4 being set holds
   (b3 is_<=_than b4 implies b2 is_<=_than b4) & (b4 is_<=_than b2 implies b4 is_<=_than b3);

:: YELLOW_0:th 5
theorem
for b1 being non empty RelStr
for b2 being set
for b3 being Element of the carrier of b1 holds
   (b2 is_<=_than b3 implies b2 /\ the carrier of b1 is_<=_than b3) &
    (b2 /\ the carrier of b1 is_<=_than b3 implies b2 is_<=_than b3) &
    (b3 is_<=_than b2 implies b3 is_<=_than b2 /\ the carrier of b1) &
    (b3 is_<=_than b2 /\ the carrier of b1 implies b3 is_<=_than b2);

:: YELLOW_0:th 6
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1 holds
   {} is_<=_than b2 & b2 is_<=_than {};

:: YELLOW_0:th 7
theorem
for b1 being RelStr
for b2, b3 being Element of the carrier of b1 holds
(b2 is_<=_than {b3} implies b2 <= b3) & (b2 <= b3 implies b2 is_<=_than {b3}) & ({b3} is_<=_than b2 implies b3 <= b2) & (b3 <= b2 implies {b3} is_<=_than b2);

:: YELLOW_0:th 8
theorem
for b1 being RelStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 is_<=_than {b3,b4} implies b2 <= b3 & b2 <= b4) &
 (b2 <= b3 & b2 <= b4 implies b2 is_<=_than {b3,b4}) &
 ({b3,b4} is_<=_than b2 implies b3 <= b2 & b4 <= b2) &
 (b3 <= b2 & b4 <= b2 implies {b3,b4} is_<=_than b2);

:: YELLOW_0:th 9
theorem
for b1 being RelStr
for b2, b3 being set
   st b2 c= b3
for b4 being Element of the carrier of b1 holds
   (b4 is_<=_than b3 implies b4 is_<=_than b2) & (b3 is_<=_than b4 implies b2 is_<=_than b4);

:: YELLOW_0:th 10
theorem
for b1 being RelStr
for b2, b3 being set
for b4 being Element of the carrier of b1 holds
   (b4 is_<=_than b2 & b4 is_<=_than b3 implies b4 is_<=_than b2 \/ b3) &
    (b2 is_<=_than b4 & b3 is_<=_than b4 implies b2 \/ b3 is_<=_than b4);

:: YELLOW_0:th 11
theorem
for b1 being transitive RelStr
for b2 being set
for b3, b4 being Element of the carrier of b1
      st b2 is_<=_than b3 & b3 <= b4
   holds b2 is_<=_than b4;

:: YELLOW_0:th 12
theorem
for b1 being transitive RelStr
for b2 being set
for b3, b4 being Element of the carrier of b1
      st b3 is_<=_than b2 & b4 <= b3
   holds b4 is_<=_than b2;

:: YELLOW_0:funcreg 2
registration
  let a1 be non empty RelStr;
  cluster [#] a1 -> non empty;
end;

:: YELLOW_0:attrnot 4 => YELLOW_0:attr 1
definition
  let a1 be RelStr;
  attr a1 is lower-bounded means
    ex b1 being Element of the carrier of a1 st
       b1 is_<=_than the carrier of a1;
end;

:: YELLOW_0:dfs 4
definiens
  let a1 be RelStr;
To prove
     a1 is lower-bounded
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 is_<=_than the carrier of a1;

:: YELLOW_0:def 4
theorem
for b1 being RelStr holds
      b1 is lower-bounded
   iff
      ex b2 being Element of the carrier of b1 st
         b2 is_<=_than the carrier of b1;

:: YELLOW_0:attrnot 5 => YELLOW_0:attr 2
definition
  let a1 be RelStr;
  attr a1 is upper-bounded means
    ex b1 being Element of the carrier of a1 st
       the carrier of a1 is_<=_than b1;
end;

:: YELLOW_0:dfs 5
definiens
  let a1 be RelStr;
To prove
     a1 is upper-bounded
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       the carrier of a1 is_<=_than b1;

:: YELLOW_0:def 5
theorem
for b1 being RelStr holds
      b1 is upper-bounded
   iff
      ex b2 being Element of the carrier of b1 st
         the carrier of b1 is_<=_than b2;

:: YELLOW_0:attrnot 6 => YELLOW_0:attr 3
definition
  let a1 be RelStr;
  attr a1 is bounded means
    a1 is lower-bounded & a1 is upper-bounded;
end;

:: YELLOW_0:dfs 6
definiens
  let a1 be RelStr;
To prove
     a1 is bounded
it is sufficient to prove
  thus a1 is lower-bounded & a1 is upper-bounded;

:: YELLOW_0:def 6
theorem
for b1 being RelStr holds
      b1 is bounded
   iff
      b1 is lower-bounded & b1 is upper-bounded;

:: YELLOW_0: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#)
   holds (b1 is lower-bounded implies b2 is lower-bounded) & (b1 is upper-bounded implies b2 is upper-bounded);

:: YELLOW_0:condreg 3
registration
  cluster non empty complete -> bounded (RelStr);
end;

:: YELLOW_0:condreg 4
registration
  cluster bounded -> lower-bounded upper-bounded (RelStr);
end;

:: YELLOW_0:condreg 5
registration
  cluster lower-bounded upper-bounded -> bounded (RelStr);
end;

:: YELLOW_0:exreg 2
registration
  cluster non empty total reflexive transitive antisymmetric complete RelStr;
end;

:: YELLOW_0:prednot 1 => YELLOW_0:pred 1
definition
  let a1 be RelStr;
  let a2 be set;
  pred ex_sup_of A2,A1 means
    ex b1 being Element of the carrier of a1 st
       a2 is_<=_than b1 &
        (for b2 being Element of the carrier of a1
              st a2 is_<=_than b2
           holds b1 <= b2) &
        (for b2 being Element of the carrier of a1
              st a2 is_<=_than b2 &
                 (for b3 being Element of the carrier of a1
                       st a2 is_<=_than b3
                    holds b2 <= b3)
           holds b2 = b1);
end;

:: YELLOW_0:dfs 7
definiens
  let a1 be RelStr;
  let a2 be set;
To prove
     ex_sup_of a2,a1
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       a2 is_<=_than b1 &
        (for b2 being Element of the carrier of a1
              st a2 is_<=_than b2
           holds b1 <= b2) &
        (for b2 being Element of the carrier of a1
              st a2 is_<=_than b2 &
                 (for b3 being Element of the carrier of a1
                       st a2 is_<=_than b3
                    holds b2 <= b3)
           holds b2 = b1);

:: YELLOW_0:def 7
theorem
for b1 being RelStr
for b2 being set holds
      ex_sup_of b2,b1
   iff
      ex b3 being Element of the carrier of b1 st
         b2 is_<=_than b3 &
          (for b4 being Element of the carrier of b1
                st b2 is_<=_than b4
             holds b3 <= b4) &
          (for b4 being Element of the carrier of b1
                st b2 is_<=_than b4 &
                   (for b5 being Element of the carrier of b1
                         st b2 is_<=_than b5
                      holds b4 <= b5)
             holds b4 = b3);

:: YELLOW_0:prednot 2 => YELLOW_0:pred 2
definition
  let a1 be RelStr;
  let a2 be set;
  pred ex_inf_of A2,A1 means
    ex b1 being Element of the carrier of a1 st
       b1 is_<=_than a2 &
        (for b2 being Element of the carrier of a1
              st b2 is_<=_than a2
           holds b2 <= b1) &
        (for b2 being Element of the carrier of a1
              st b2 is_<=_than a2 &
                 (for b3 being Element of the carrier of a1
                       st b3 is_<=_than a2
                    holds b3 <= b2)
           holds b2 = b1);
end;

:: YELLOW_0:dfs 8
definiens
  let a1 be RelStr;
  let a2 be set;
To prove
     ex_inf_of a2,a1
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 is_<=_than a2 &
        (for b2 being Element of the carrier of a1
              st b2 is_<=_than a2
           holds b2 <= b1) &
        (for b2 being Element of the carrier of a1
              st b2 is_<=_than a2 &
                 (for b3 being Element of the carrier of a1
                       st b3 is_<=_than a2
                    holds b3 <= b2)
           holds b2 = b1);

:: YELLOW_0:def 8
theorem
for b1 being RelStr
for b2 being set holds
      ex_inf_of b2,b1
   iff
      ex b3 being Element of the carrier of b1 st
         b3 is_<=_than b2 &
          (for b4 being Element of the carrier of b1
                st b4 is_<=_than b2
             holds b4 <= b3) &
          (for b4 being Element of the carrier of b1
                st b4 is_<=_than b2 &
                   (for b5 being Element of the carrier of b1
                         st b5 is_<=_than b2
                      holds b5 <= b4)
             holds b4 = b3);

:: YELLOW_0: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#)
for b3 being set holds
   (ex_sup_of b3,b1 implies ex_sup_of b3,b2) & (ex_inf_of b3,b1 implies ex_inf_of b3,b2);

:: YELLOW_0:th 15
theorem
for b1 being antisymmetric RelStr
for b2 being set holds
      ex_sup_of b2,b1
   iff
      ex b3 being Element of the carrier of b1 st
         b2 is_<=_than b3 &
          (for b4 being Element of the carrier of b1
                st b2 is_<=_than b4
             holds b3 <= b4);

:: YELLOW_0:th 16
theorem
for b1 being antisymmetric RelStr
for b2 being set holds
      ex_inf_of b2,b1
   iff
      ex b3 being Element of the carrier of b1 st
         b3 is_<=_than b2 &
          (for b4 being Element of the carrier of b1
                st b4 is_<=_than b2
             holds b4 <= b3);

:: YELLOW_0:th 17
theorem
for b1 being non empty antisymmetric complete RelStr
for b2 being set holds
   ex_sup_of b2,b1 & ex_inf_of b2,b1;

:: YELLOW_0:th 18
theorem
for b1 being antisymmetric RelStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b4 = b2 "\/" b3 & ex_sup_of {b2,b3},b1
iff
   b2 <= b4 &
    b3 <= b4 &
    (for b5 being Element of the carrier of b1
          st b2 <= b5 & b3 <= b5
       holds b4 <= b5);

:: YELLOW_0:th 19
theorem
for b1 being antisymmetric RelStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b4 = b2 "/\" b3 & ex_inf_of {b2,b3},b1
iff
   b4 <= b2 &
    b4 <= b3 &
    (for b5 being Element of the carrier of b1
          st b5 <= b2 & b5 <= b3
       holds b5 <= b4);

:: YELLOW_0:th 20
theorem
for b1 being antisymmetric RelStr holds
      b1 is with_suprema
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex_sup_of {b2,b3},b1;

:: YELLOW_0:th 21
theorem
for b1 being antisymmetric RelStr holds
      b1 is with_infima
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex_inf_of {b2,b3},b1;

:: YELLOW_0:th 22
theorem
for b1 being antisymmetric with_suprema RelStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b4 = b2 "\/" b3
iff
   b2 <= b4 &
    b3 <= b4 &
    (for b5 being Element of the carrier of b1
          st b2 <= b5 & b3 <= b5
       holds b4 <= b5);

:: YELLOW_0:th 23
theorem
for b1 being antisymmetric with_infima RelStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b4 = b2 "/\" b3
iff
   b4 <= b2 &
    b4 <= b3 &
    (for b5 being Element of the carrier of b1
          st b5 <= b2 & b5 <= b3
       holds b5 <= b4);

:: YELLOW_0:th 24
theorem
for b1 being reflexive antisymmetric with_suprema RelStr
for b2, b3 being Element of the carrier of b1 holds
   b2 = b2 "\/" b3
iff
   b3 <= b2;

:: YELLOW_0:th 25
theorem
for b1 being reflexive antisymmetric with_infima RelStr
for b2, b3 being Element of the carrier of b1 holds
   b2 = b2 "/\" b3
iff
   b2 <= b3;

:: YELLOW_0:funcnot 1 => YELLOW_0:func 1
definition
  let a1 be RelStr;
  let a2 be set;
  func "\/"(A2,A1) -> Element of the carrier of a1 means
      case ex_sup_of a2,a1;
    thus a2 is_<=_than it &
     (for b1 being Element of the carrier of a1
           st a2 is_<=_than b1
        holds it <= b1);
  end;
;
end;

:: YELLOW_0:def 9
theorem
for b1 being RelStr
for b2 being set
for b3 being Element of the carrier of b1
      st ex_sup_of b2,b1
   holds    b3 = "\/"(b2,b1)
   iff
      b2 is_<=_than b3 &
       (for b4 being Element of the carrier of b1
             st b2 is_<=_than b4
          holds b3 <= b4);

:: YELLOW_0:funcnot 2 => YELLOW_0:func 2
definition
  let a1 be RelStr;
  let a2 be set;
  func "/\"(A2,A1) -> Element of the carrier of a1 means
      case ex_inf_of a2,a1;
    thus it is_<=_than a2 &
     (for b1 being Element of the carrier of a1
           st b1 is_<=_than a2
        holds b1 <= it);
  end;
;
end;

:: YELLOW_0:def 10
theorem
for b1 being RelStr
for b2 being set
for b3 being Element of the carrier of b1
      st ex_inf_of b2,b1
   holds    b3 = "/\"(b2,b1)
   iff
      b3 is_<=_than b2 &
       (for b4 being Element of the carrier of b1
             st b4 is_<=_than b2
          holds b4 <= b3);

:: YELLOW_0:th 26
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#)
for b3 being set
      st ex_sup_of b3,b1
   holds "\/"(b3,b1) = "\/"(b3,b2);

:: YELLOW_0:th 27
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#)
for b3 being set
      st ex_inf_of b3,b1
   holds "/\"(b3,b1) = "/\"(b3,b2);

:: YELLOW_0:th 28
theorem
for b1 being non empty reflexive transitive antisymmetric complete RelStr
for b2 being set holds
   "\/"(b2,b1) = "\/"(b2,latt b1) & "/\"(b2,b1) = "/\"(b2,latt b1);

:: YELLOW_0:th 29
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being set holds
   "\/"(b2,b1) = "\/"(b2,LattPOSet b1) & "/\"(b2,b1) = "/\"(b2,LattPOSet b1);

:: YELLOW_0:th 30
theorem
for b1 being antisymmetric RelStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b2 = "\/"(b3,b1) & ex_sup_of b3,b1
   iff
      b3 is_<=_than b2 &
       (for b4 being Element of the carrier of b1
             st b3 is_<=_than b4
          holds b2 <= b4);

:: YELLOW_0:th 31
theorem
for b1 being antisymmetric RelStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b2 = "/\"(b3,b1) & ex_inf_of b3,b1
   iff
      b2 is_<=_than b3 &
       (for b4 being Element of the carrier of b1
             st b4 is_<=_than b3
          holds b4 <= b2);

:: YELLOW_0:th 32
theorem
for b1 being non empty antisymmetric complete RelStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b2 = "\/"(b3,b1)
   iff
      b3 is_<=_than b2 &
       (for b4 being Element of the carrier of b1
             st b3 is_<=_than b4
          holds b2 <= b4);

:: YELLOW_0:th 33
theorem
for b1 being non empty antisymmetric complete RelStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b2 = "/\"(b3,b1)
   iff
      b2 is_<=_than b3 &
       (for b4 being Element of the carrier of b1
             st b4 is_<=_than b3
          holds b4 <= b2);

:: YELLOW_0:th 34
theorem
for b1 being RelStr
for b2, b3 being set
      st b2 c= b3 & ex_sup_of b2,b1 & ex_sup_of b3,b1
   holds "\/"(b2,b1) <= "\/"(b3,b1);

:: YELLOW_0:th 35
theorem
for b1 being RelStr
for b2, b3 being set
      st b2 c= b3 & ex_inf_of b2,b1 & ex_inf_of b3,b1
   holds "/\"(b3,b1) <= "/\"(b2,b1);

:: YELLOW_0:th 36
theorem
for b1 being transitive antisymmetric RelStr
for b2, b3 being set
      st ex_sup_of b2,b1 & ex_sup_of b3,b1 & ex_sup_of b2 \/ b3,b1
   holds "\/"(b2 \/ b3,b1) = ("\/"(b2,b1)) "\/" "\/"(b3,b1);

:: YELLOW_0:th 37
theorem
for b1 being transitive antisymmetric RelStr
for b2, b3 being set
      st ex_inf_of b2,b1 & ex_inf_of b3,b1 & ex_inf_of b2 \/ b3,b1
   holds "/\"(b2 \/ b3,b1) = ("/\"(b2,b1)) "/\" "/\"(b3,b1);

:: YELLOW_0:funcnot 3 => YELLOW_0:func 1
notation
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  synonym sup a2 for "\/"(a2,a1);
end;

:: YELLOW_0:funcnot 4 => YELLOW_0:func 2
notation
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  synonym inf a2 for "/\"(a2,a1);
end;

:: YELLOW_0:th 38
theorem
for b1 being non empty reflexive antisymmetric RelStr
for b2 being Element of the carrier of b1 holds
   ex_sup_of {b2},b1 & ex_inf_of {b2},b1;

:: YELLOW_0:th 39
theorem
for b1 being non empty reflexive antisymmetric RelStr
for b2 being Element of the carrier of b1 holds
   "\/"({b2},b1) = b2 & "/\"({b2},b1) = b2;

:: YELLOW_0:th 40
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2, b3 being Element of the carrier of b1 holds
"/\"({b2,b3},b1) = b2 "/\" b3;

:: YELLOW_0:th 41
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2, b3 being Element of the carrier of b1 holds
"\/"({b2,b3},b1) = b2 "\/" b3;

:: YELLOW_0:th 42
theorem
for b1 being non empty antisymmetric lower-bounded RelStr holds
   ex_sup_of {},b1 & ex_inf_of the carrier of b1,b1;

:: YELLOW_0:th 43
theorem
for b1 being non empty antisymmetric upper-bounded RelStr holds
   ex_inf_of {},b1 & ex_sup_of the carrier of b1,b1;

:: YELLOW_0:funcnot 5 => YELLOW_0:func 3
definition
  let a1 be RelStr;
  func Bottom A1 -> Element of the carrier of a1 equals
    "\/"({},a1);
end;

:: YELLOW_0:def 11
theorem
for b1 being RelStr holds
   Bottom b1 = "\/"({},b1);

:: YELLOW_0:funcnot 6 => YELLOW_0:func 4
definition
  let a1 be RelStr;
  func Top A1 -> Element of the carrier of a1 equals
    "/\"({},a1);
end;

:: YELLOW_0:def 12
theorem
for b1 being RelStr holds
   Top b1 = "/\"({},b1);

:: YELLOW_0:th 44
theorem
for b1 being non empty antisymmetric lower-bounded RelStr
for b2 being Element of the carrier of b1 holds
   Bottom b1 <= b2;

:: YELLOW_0:th 45
theorem
for b1 being non empty antisymmetric upper-bounded RelStr
for b2 being Element of the carrier of b1 holds
   b2 <= Top b1;

:: YELLOW_0:th 46
theorem
for b1 being non empty RelStr
for b2, b3 being set
      st (for b4 being Element of the carrier of b1 holds
               b2 is_<=_than b4
            iff
               b3 is_<=_than b4) &
         ex_sup_of b2,b1
   holds ex_sup_of b3,b1;

:: YELLOW_0:th 47
theorem
for b1 being non empty RelStr
for b2, b3 being set
      st ex_sup_of b2,b1 &
         (for b4 being Element of the carrier of b1 holds
               b2 is_<=_than b4
            iff
               b3 is_<=_than b4)
   holds "\/"(b2,b1) = "\/"(b3,b1);

:: YELLOW_0:th 48
theorem
for b1 being non empty RelStr
for b2, b3 being set
      st (for b4 being Element of the carrier of b1 holds
               b4 is_<=_than b2
            iff
               b4 is_<=_than b3) &
         ex_inf_of b2,b1
   holds ex_inf_of b3,b1;

:: YELLOW_0:th 49
theorem
for b1 being non empty RelStr
for b2, b3 being set
      st ex_inf_of b2,b1 &
         (for b4 being Element of the carrier of b1 holds
               b4 is_<=_than b2
            iff
               b4 is_<=_than b3)
   holds "/\"(b2,b1) = "/\"(b3,b1);

:: YELLOW_0:th 50
theorem
for b1 being non empty RelStr
for b2 being set holds
   (ex_sup_of b2,b1 implies ex_sup_of b2 /\ the carrier of b1,b1) & (ex_sup_of b2 /\ the carrier of b1,b1 implies ex_sup_of b2,b1) & (ex_inf_of b2,b1 implies ex_inf_of b2 /\ the carrier of b1,b1) & (ex_inf_of b2 /\ the carrier of b1,b1 implies ex_inf_of b2,b1);

:: YELLOW_0:th 51
theorem
for b1 being non empty RelStr
for b2 being set
      st (ex_sup_of b2,b1 or ex_sup_of b2 /\ the carrier of b1,b1)
   holds "\/"(b2,b1) = "\/"(b2 /\ the carrier of b1,b1);

:: YELLOW_0:th 52
theorem
for b1 being non empty RelStr
for b2 being set
      st (ex_inf_of b2,b1 or ex_inf_of b2 /\ the carrier of b1,b1)
   holds "/\"(b2,b1) = "/\"(b2 /\ the carrier of b1,b1);

:: YELLOW_0:th 53
theorem
for b1 being non empty RelStr
      st for b2 being Element of bool the carrier of b1 holds
           ex_sup_of b2,b1
   holds b1 is complete;

:: YELLOW_0:th 54
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr holds
      b1 is with_suprema
   iff
      for b2 being non empty finite Element of bool the carrier of b1 holds
         ex_sup_of b2,b1;

:: YELLOW_0:th 55
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr holds
      b1 is with_infima
   iff
      for b2 being non empty finite Element of bool the carrier of b1 holds
         ex_inf_of b2,b1;

:: YELLOW_0:modenot 1 => YELLOW_0:mode 1
definition
  let a1 be RelStr;
  mode SubRelStr of A1 -> RelStr means
    the carrier of it c= the carrier of a1 & the InternalRel of it c= the InternalRel of a1;
end;

:: YELLOW_0:dfs 13
definiens
  let a1, a2 be RelStr;
To prove
     a2 is SubRelStr of a1
it is sufficient to prove
  thus the carrier of a2 c= the carrier of a1 & the InternalRel of a2 c= the InternalRel of a1;

:: YELLOW_0:def 13
theorem
for b1, b2 being RelStr holds
   b2 is SubRelStr of b1
iff
   the carrier of b2 c= the carrier of b1 & the InternalRel of b2 c= the InternalRel of b1;

:: YELLOW_0:attrnot 7 => YELLOW_0:attr 4
definition
  let a1 be RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is full means
    the InternalRel of a2 = (the InternalRel of a1) |_2 the carrier of a2;
end;

:: YELLOW_0:dfs 14
definiens
  let a1 be RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is full
it is sufficient to prove
  thus the InternalRel of a2 = (the InternalRel of a1) |_2 the carrier of a2;

:: YELLOW_0:def 14
theorem
for b1 being RelStr
for b2 being SubRelStr of b1 holds
      b2 is full(b1)
   iff
      the InternalRel of b2 = (the InternalRel of b1) |_2 the carrier of b2;

:: YELLOW_0:exreg 3
registration
  let a1 be RelStr;
  cluster strict full SubRelStr of a1;
end;

:: YELLOW_0:exreg 4
registration
  let a1 be non empty RelStr;
  cluster non empty strict full SubRelStr of a1;
end;

:: YELLOW_0:th 57
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
   RelStr(#b2,(the InternalRel of b1) |_2 b2#) is full SubRelStr of b1;

:: YELLOW_0:th 58
theorem
for b1 being RelStr
for b2, b3 being full SubRelStr of b1
      st the carrier of b2 = the carrier of b3
   holds RelStr(#the carrier of b2,the InternalRel of b2#) = RelStr(#the carrier of b3,the InternalRel of b3#);

:: YELLOW_0:funcnot 7 => YELLOW_0:func 5
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  func subrelstr A2 -> strict full SubRelStr of a1 means
    the carrier of it = a2;
end;

:: YELLOW_0:def 15
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1
for b3 being strict full SubRelStr of b1 holds
      b3 = subrelstr b2
   iff
      the carrier of b3 = b2;

:: YELLOW_0:th 59
theorem
for b1 being non empty RelStr
for b2 being non empty SubRelStr of b1
for b3 being Element of the carrier of b2 holds
   b3 is Element of the carrier of b1;

:: YELLOW_0:th 60
theorem
for b1 being RelStr
for b2 being SubRelStr of b1
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b5 = b3 & b6 = b4 & b5 <= b6
   holds b3 <= b4;

:: YELLOW_0:th 61
theorem
for b1 being RelStr
for b2 being full SubRelStr of b1
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b5 = b3 & b6 = b4 & b3 <= b4 & b5 in the carrier of b2 & b6 in the carrier of b2
   holds b5 <= b6;

:: YELLOW_0:th 62
theorem
for b1 being non empty RelStr
for b2 being non empty full SubRelStr of b1
for b3 being set
for b4 being Element of the carrier of b1
for b5 being Element of the carrier of b2
      st b5 = b4
   holds (b4 is_<=_than b3 implies b5 is_<=_than b3) & (b3 is_<=_than b4 implies b3 is_<=_than b5);

:: YELLOW_0:th 63
theorem
for b1 being non empty RelStr
for b2 being non empty SubRelStr of b1
for b3 being Element of bool the carrier of b2
for b4 being Element of the carrier of b1
for b5 being Element of the carrier of b2
      st b5 = b4
   holds (b5 is_<=_than b3 implies b4 is_<=_than b3) & (b3 is_<=_than b5 implies b3 is_<=_than b4);

:: YELLOW_0:condreg 6
registration
  let a1 be reflexive RelStr;
  cluster full -> reflexive (SubRelStr of a1);
end;

:: YELLOW_0:condreg 7
registration
  let a1 be transitive RelStr;
  cluster full -> transitive (SubRelStr of a1);
end;

:: YELLOW_0:condreg 8
registration
  let a1 be antisymmetric RelStr;
  cluster full -> antisymmetric (SubRelStr of a1);
end;

:: YELLOW_0:attrnot 8 => YELLOW_0:attr 5
definition
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is meet-inheriting means
    for b1, b2 being Element of the carrier of a1
          st b1 in the carrier of a2 & b2 in the carrier of a2 & ex_inf_of {b1,b2},a1
       holds "/\"({b1,b2},a1) in the carrier of a2;
end;

:: YELLOW_0:dfs 16
definiens
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is meet-inheriting
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in the carrier of a2 & b2 in the carrier of a2 & ex_inf_of {b1,b2},a1
       holds "/\"({b1,b2},a1) in the carrier of a2;

:: YELLOW_0:def 16
theorem
for b1 being non empty RelStr
for b2 being SubRelStr of b1 holds
      b2 is meet-inheriting(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in the carrier of b2 & b4 in the carrier of b2 & ex_inf_of {b3,b4},b1
         holds "/\"({b3,b4},b1) in the carrier of b2;

:: YELLOW_0:attrnot 9 => YELLOW_0:attr 6
definition
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is join-inheriting means
    for b1, b2 being Element of the carrier of a1
          st b1 in the carrier of a2 & b2 in the carrier of a2 & ex_sup_of {b1,b2},a1
       holds "\/"({b1,b2},a1) in the carrier of a2;
end;

:: YELLOW_0:dfs 17
definiens
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is join-inheriting
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in the carrier of a2 & b2 in the carrier of a2 & ex_sup_of {b1,b2},a1
       holds "\/"({b1,b2},a1) in the carrier of a2;

:: YELLOW_0:def 17
theorem
for b1 being non empty RelStr
for b2 being SubRelStr of b1 holds
      b2 is join-inheriting(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in the carrier of b2 & b4 in the carrier of b2 & ex_sup_of {b3,b4},b1
         holds "\/"({b3,b4},b1) in the carrier of b2;

:: YELLOW_0:attrnot 10 => YELLOW_0:attr 7
definition
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is infs-inheriting means
    for b1 being Element of bool the carrier of a2
          st ex_inf_of b1,a1
       holds "/\"(b1,a1) in the carrier of a2;
end;

:: YELLOW_0:dfs 18
definiens
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is infs-inheriting
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a2
          st ex_inf_of b1,a1
       holds "/\"(b1,a1) in the carrier of a2;

:: YELLOW_0:def 18
theorem
for b1 being non empty RelStr
for b2 being SubRelStr of b1 holds
      b2 is infs-inheriting(b1)
   iff
      for b3 being Element of bool the carrier of b2
            st ex_inf_of b3,b1
         holds "/\"(b3,b1) in the carrier of b2;

:: YELLOW_0:attrnot 11 => YELLOW_0:attr 8
definition
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is sups-inheriting means
    for b1 being Element of bool the carrier of a2
          st ex_sup_of b1,a1
       holds "\/"(b1,a1) in the carrier of a2;
end;

:: YELLOW_0:dfs 19
definiens
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is sups-inheriting
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a2
          st ex_sup_of b1,a1
       holds "\/"(b1,a1) in the carrier of a2;

:: YELLOW_0:def 19
theorem
for b1 being non empty RelStr
for b2 being SubRelStr of b1 holds
      b2 is sups-inheriting(b1)
   iff
      for b3 being Element of bool the carrier of b2
            st ex_sup_of b3,b1
         holds "\/"(b3,b1) in the carrier of b2;

:: YELLOW_0:condreg 9
registration
  let a1 be non empty RelStr;
  cluster infs-inheriting -> meet-inheriting (SubRelStr of a1);
end;

:: YELLOW_0:condreg 10
registration
  let a1 be non empty RelStr;
  cluster sups-inheriting -> join-inheriting (SubRelStr of a1);
end;

:: YELLOW_0:exreg 5
registration
  let a1 be non empty RelStr;
  cluster non empty strict full infs-inheriting sups-inheriting SubRelStr of a1;
end;

:: YELLOW_0:th 64
theorem
for b1 being non empty transitive RelStr
for b2 being non empty full SubRelStr of b1
for b3 being Element of bool the carrier of b2
      st ex_inf_of b3,b1 & "/\"(b3,b1) in the carrier of b2
   holds ex_inf_of b3,b2 & "/\"(b3,b2) = "/\"(b3,b1);

:: YELLOW_0:th 65
theorem
for b1 being non empty transitive RelStr
for b2 being non empty full SubRelStr of b1
for b3 being Element of bool the carrier of b2
      st ex_sup_of b3,b1 & "\/"(b3,b1) in the carrier of b2
   holds ex_sup_of b3,b2 & "\/"(b3,b2) = "\/"(b3,b1);

:: YELLOW_0:th 66
theorem
for b1 being non empty transitive RelStr
for b2 being non empty full SubRelStr of b1
for b3, b4 being Element of the carrier of b2
      st ex_inf_of {b3,b4},b1 & "/\"({b3,b4},b1) in the carrier of b2
   holds ex_inf_of {b3,b4},b2 &
    "/\"({b3,b4},b2) = "/\"({b3,b4},b1);

:: YELLOW_0:th 67
theorem
for b1 being non empty transitive RelStr
for b2 being non empty full SubRelStr of b1
for b3, b4 being Element of the carrier of b2
      st ex_sup_of {b3,b4},b1 & "\/"({b3,b4},b1) in the carrier of b2
   holds ex_sup_of {b3,b4},b2 &
    "\/"({b3,b4},b2) = "\/"({b3,b4},b1);

:: YELLOW_0:condreg 11
registration
  let a1 be transitive antisymmetric with_infima RelStr;
  cluster non empty full meet-inheriting -> with_infima (SubRelStr of a1);
end;

:: YELLOW_0:condreg 12
registration
  let a1 be transitive antisymmetric with_suprema RelStr;
  cluster non empty full join-inheriting -> with_suprema (SubRelStr of a1);
end;

:: YELLOW_0:th 68
theorem
for b1 being non empty reflexive transitive antisymmetric complete RelStr
for b2 being non empty full SubRelStr of b1
for b3 being Element of bool the carrier of b2
      st "/\"(b3,b1) in the carrier of b2
   holds "/\"(b3,b2) = "/\"(b3,b1);

:: YELLOW_0:th 69
theorem
for b1 being non empty reflexive transitive antisymmetric complete RelStr
for b2 being non empty full SubRelStr of b1
for b3 being Element of bool the carrier of b2
      st "\/"(b3,b1) in the carrier of b2
   holds "\/"(b3,b2) = "\/"(b3,b1);

:: YELLOW_0:th 70
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2 being non empty full meet-inheriting SubRelStr of b1
for b3, b4 being Element of the carrier of b2
for b5, b6 being Element of the carrier of b1
      st b5 = b3 & b6 = b4
   holds b3 "/\" b4 = b5 "/\" b6;

:: YELLOW_0:th 71
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2 being non empty full join-inheriting SubRelStr of b1
for b3, b4 being Element of the carrier of b2
for b5, b6 being Element of the carrier of b1
      st b5 = b3 & b6 = b4
   holds b3 "\/" b4 = b5 "\/" b6;