Article YELLOW_3, MML version 4.99.1005

:: YELLOW_3:sch 1
scheme YELLOW_3:sch 1
{F1 -> non empty set,
  F2 -> set}:
{F2(b1, b2) where b1 is Element of F1(), b2 is Element of F1(): P1[b1, b2]} is Element of bool F1()
provided
   for b1, b2 being Element of F1() holds
   F2(b1, b2) in F1();


:: YELLOW_3:funcreg 1
registration
  let a1 be empty set;
  cluster proj1 a1 -> empty;
end;

:: YELLOW_3:funcreg 2
registration
  let a1 be empty set;
  cluster proj2 a1 -> empty;
end;

:: YELLOW_3:funcreg 3
registration
  let a1, a2 be non empty set;
  let a3 be non empty Element of bool [:a1,a2:];
  cluster proj1 a3 -> non empty;
end;

:: YELLOW_3:funcreg 4
registration
  let a1, a2 be non empty set;
  let a3 be non empty Element of bool [:a1,a2:];
  cluster proj2 a3 -> non empty;
end;

:: YELLOW_3:funcreg 5
registration
  let a1 be RelStr;
  let a2 be empty Element of bool the carrier of a1;
  cluster downarrow a2 -> empty;
end;

:: YELLOW_3:funcreg 6
registration
  let a1 be RelStr;
  let a2 be empty Element of bool the carrier of a1;
  cluster uparrow a2 -> empty;
end;

:: YELLOW_3:th 1
theorem
for b1, b2 being set
for b3 being Element of bool [:b1,b2:] holds
   b3 c= [:proj1 b3,proj2 b3:];

:: YELLOW_3:th 2
theorem
for b1 being transitive antisymmetric with_infima RelStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2 <= b4 & b3 <= b5
   holds b2 "/\" b3 <= b4 "/\" b5;

:: YELLOW_3:th 3
theorem
for b1 being transitive antisymmetric with_suprema RelStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2 <= b4 & b3 <= b5
   holds b2 "\/" b3 <= b4 "\/" b5;

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

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

:: YELLOW_3:th 6
theorem
for b1 being RelStr
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds downarrow b2 c= downarrow b3;

:: YELLOW_3:th 7
theorem
for b1 being RelStr
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds uparrow b2 c= uparrow b3;

:: YELLOW_3:th 8
theorem
for b1, b2 being reflexive transitive antisymmetric with_infima RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b4, b5 being Element of the carrier of b1 holds
   b3 preserves_inf_of {b4,b5}
iff
   b3 . (b4 "/\" b5) = (b3 . b4) "/\" (b3 . b5);

:: YELLOW_3:th 9
theorem
for b1, b2 being reflexive transitive antisymmetric with_suprema RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b4, b5 being Element of the carrier of b1 holds
   b3 preserves_sup_of {b4,b5}
iff
   b3 . (b4 "\/" b5) = (b3 . b4) "\/" (b3 . b5);

:: YELLOW_3:sch 2
scheme YELLOW_3:sch 2
{F1 -> non empty antisymmetric complete RelStr}:
"/\"(union {b1 where b1 is Element of bool the carrier of F1(): P1[b1]},F1()) <= "/\"({"/\"(b1,F1()) where b1 is Element of bool the carrier of F1(): P1[b1]},F1())


:: YELLOW_3:sch 3
scheme YELLOW_3:sch 3
{F1 -> reflexive transitive antisymmetric with_suprema with_infima complete RelStr}:
"/\"({"/\"(b1,F1()) where b1 is Element of bool the carrier of F1(): P1[b1]},F1()) = "/\"(union {b1 where b1 is Element of bool the carrier of F1(): P1[b1]},F1())


:: YELLOW_3:sch 4
scheme YELLOW_3:sch 4
{F1 -> non empty antisymmetric complete RelStr}:
"\/"({"\/"(b1,F1()) where b1 is Element of bool the carrier of F1(): P1[b1]},F1()) <= "\/"(union {b1 where b1 is Element of bool the carrier of F1(): P1[b1]},F1())


:: YELLOW_3:sch 5
scheme YELLOW_3:sch 5
{F1 -> reflexive transitive antisymmetric with_suprema with_infima complete RelStr}:
"\/"({"\/"(b1,F1()) where b1 is Element of bool the carrier of F1(): P1[b1]},F1()) = "\/"(union {b1 where b1 is Element of bool the carrier of F1(): P1[b1]},F1())


:: YELLOW_3:funcnot 1 => YELLOW_3:func 1
definition
  let a1, a2 be Relation-like set;
  func ["A1,A2"] -> Relation-like set means
    for b1, b2 being set holds
       [b1,b2] in it
    iff
       ex b3, b4, b5, b6 being set st
          b1 = [b3,b4] & b2 = [b5,b6] & [b3,b5] in a1 & [b4,b6] in a2;
end;

:: YELLOW_3:def 1
theorem
for b1, b2, b3 being Relation-like set holds
   b3 = ["b1,b2"]
iff
   for b4, b5 being set holds
      [b4,b5] in b3
   iff
      ex b6, b7, b8, b9 being set st
         b4 = [b6,b7] & b5 = [b8,b9] & [b6,b8] in b1 & [b7,b9] in b2;

:: YELLOW_3:th 10
theorem
for b1, b2 being Relation-like set
for b3 being set holds
      b3 in ["b1,b2"]
   iff
      [b3 `1 `1,b3 `2 `1] in b1 &
       [b3 `1 `2,b3 `2 `2] in b2 &
       (ex b4, b5 being set st
          b3 = [b4,b5]) &
       (ex b4, b5 being set st
          b3 `1 = [b4,b5]) &
       (ex b4, b5 being set st
          b3 `2 = [b4,b5]);

:: YELLOW_3:funcnot 2 => YELLOW_3:func 2
definition
  let a1, a2, a3, a4 be set;
  let a5 be Relation of a1,a2;
  let a6 be Relation of a3,a4;
  redefine func ["a5, a6"] -> Relation of [:a1,a3:],[:a2,a4:];
end;

:: YELLOW_3:funcnot 3 => YELLOW_3:func 3
definition
  let a1, a2 be RelStr;
  func [:A1,A2:] -> strict RelStr means
    the carrier of it = [:the carrier of a1,the carrier of a2:] &
     the InternalRel of it = ["the InternalRel of a1,the InternalRel of a2"];
end;

:: YELLOW_3:def 2
theorem
for b1, b2 being RelStr
for b3 being strict RelStr holds
      b3 = [:b1,b2:]
   iff
      the carrier of b3 = [:the carrier of b1,the carrier of b2:] &
       the InternalRel of b3 = ["the InternalRel of b1,the InternalRel of b2"];

:: YELLOW_3:funcnot 4 => YELLOW_3:func 4
definition
  let a1, a2 be RelStr;
  let a3 be Element of bool the carrier of [:a1,a2:];
  redefine func proj1 a3 -> Element of bool the carrier of a1;
end;

:: YELLOW_3:funcnot 5 => YELLOW_3:func 5
definition
  let a1, a2 be RelStr;
  let a3 be Element of bool the carrier of [:a1,a2:];
  redefine func proj2 a3 -> Element of bool the carrier of a2;
end;

:: YELLOW_3:funcnot 6 => YELLOW_3:func 6
definition
  let a1, a2 be RelStr;
  let a3 be Element of bool the carrier of a1;
  let a4 be Element of bool the carrier of a2;
  redefine func [:a3, a4:] -> Element of bool the carrier of [:a1,a2:];
end;

:: YELLOW_3:funcnot 7 => YELLOW_3:func 7
definition
  let a1, a2 be non empty RelStr;
  let a3 be Element of the carrier of a1;
  let a4 be Element of the carrier of a2;
  redefine func [a3, a4] -> Element of the carrier of [:a1,a2:];
end;

:: YELLOW_3:funcnot 8 => YELLOW_3:func 8
definition
  let a1, a2 be non empty RelStr;
  let a3 be Element of the carrier of [:a1,a2:];
  redefine func a3 `1 -> Element of the carrier of a1;
end;

:: YELLOW_3:funcnot 9 => YELLOW_3:func 9
definition
  let a1, a2 be non empty RelStr;
  let a3 be Element of the carrier of [:a1,a2:];
  redefine func a3 `2 -> Element of the carrier of a2;
end;

:: YELLOW_3:th 11
theorem
for b1, b2 being non empty RelStr
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2 holds
   b3 <= b4 & b5 <= b6
iff
   [b3,b5] <= [b4,b6];

:: YELLOW_3:th 12
theorem
for b1, b2 being non empty RelStr
for b3, b4 being Element of the carrier of [:b1,b2:] holds
   b3 <= b4
iff
   b3 `1 <= b4 `1 & b3 `2 <= b4 `2;

:: YELLOW_3:th 13
theorem
for b1, b2 being RelStr
for b3 being non empty RelStr
for b4, b5 being Function-like quasi_total Relation of the carrier of [:b1,b2:],the carrier of b3
      st for b6 being Element of the carrier of b1
        for b7 being Element of the carrier of b2 holds
           b4 .(b6,b7) = b5 .(b6,b7)
   holds b4 = b5;

:: YELLOW_3:funcreg 7
registration
  let a1, a2 be non empty RelStr;
  cluster [:a1,a2:] -> non empty strict;
end;

:: YELLOW_3:funcreg 8
registration
  let a1, a2 be reflexive RelStr;
  cluster [:a1,a2:] -> strict reflexive;
end;

:: YELLOW_3:funcreg 9
registration
  let a1, a2 be antisymmetric RelStr;
  cluster [:a1,a2:] -> strict antisymmetric;
end;

:: YELLOW_3:funcreg 10
registration
  let a1, a2 be transitive RelStr;
  cluster [:a1,a2:] -> strict transitive;
end;

:: YELLOW_3:funcreg 11
registration
  let a1, a2 be with_suprema RelStr;
  cluster [:a1,a2:] -> strict with_suprema;
end;

:: YELLOW_3:funcreg 12
registration
  let a1, a2 be with_infima RelStr;
  cluster [:a1,a2:] -> strict with_infima;
end;

:: YELLOW_3:th 14
theorem
for b1, b2 being RelStr
      st [:b1,b2:] is not empty
   holds b1 is not empty & b2 is not empty;

:: YELLOW_3:th 15
theorem
for b1, b2 being non empty RelStr
      st [:b1,b2:] is reflexive
   holds b1 is reflexive & b2 is reflexive;

:: YELLOW_3:th 16
theorem
for b1, b2 being non empty reflexive RelStr
      st [:b1,b2:] is antisymmetric
   holds b1 is antisymmetric & b2 is antisymmetric;

:: YELLOW_3:th 17
theorem
for b1, b2 being non empty reflexive RelStr
      st [:b1,b2:] is transitive
   holds b1 is transitive & b2 is transitive;

:: YELLOW_3:th 18
theorem
for b1, b2 being non empty reflexive RelStr
      st [:b1,b2:] is with_suprema
   holds b1 is with_suprema & b2 is with_suprema;

:: YELLOW_3:th 19
theorem
for b1, b2 being non empty reflexive RelStr
      st [:b1,b2:] is with_infima
   holds b1 is with_infima & b2 is with_infima;

:: YELLOW_3:funcnot 10 => YELLOW_3:func 10
definition
  let a1, a2 be RelStr;
  let a3 be directed Element of bool the carrier of a1;
  let a4 be directed Element of bool the carrier of a2;
  redefine func [:a3, a4:] -> directed Element of bool the carrier of [:a1,a2:];
end;

:: YELLOW_3:th 20
theorem
for b1, b2 being non empty RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
      st [:b3,b4:] is directed([:b1,b2:])
   holds b3 is directed(b1) & b4 is directed(b2);

:: YELLOW_3:th 21
theorem
for b1, b2 being non empty RelStr
for b3 being non empty Element of bool the carrier of [:b1,b2:] holds
   proj1 b3 is not empty & proj2 b3 is not empty;

:: YELLOW_3:th 22
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty directed Element of bool the carrier of [:b1,b2:] holds
   proj1 b3 is directed(b1) & proj2 b3 is directed(b2);

:: YELLOW_3:funcnot 11 => YELLOW_3:func 11
definition
  let a1, a2 be RelStr;
  let a3 be filtered Element of bool the carrier of a1;
  let a4 be filtered Element of bool the carrier of a2;
  redefine func [:a3, a4:] -> filtered Element of bool the carrier of [:a1,a2:];
end;

:: YELLOW_3:th 23
theorem
for b1, b2 being non empty RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
      st [:b3,b4:] is filtered([:b1,b2:])
   holds b3 is filtered(b1) & b4 is filtered(b2);

:: YELLOW_3:th 24
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty filtered Element of bool the carrier of [:b1,b2:] holds
   proj1 b3 is filtered(b1) & proj2 b3 is filtered(b2);

:: YELLOW_3:funcnot 12 => YELLOW_3:func 12
definition
  let a1, a2 be RelStr;
  let a3 be upper Element of bool the carrier of a1;
  let a4 be upper Element of bool the carrier of a2;
  redefine func [:a3, a4:] -> upper Element of bool the carrier of [:a1,a2:];
end;

:: YELLOW_3:th 25
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
      st [:b3,b4:] is upper([:b1,b2:])
   holds b3 is upper(b1) & b4 is upper(b2);

:: YELLOW_3:th 26
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty upper Element of bool the carrier of [:b1,b2:] holds
   proj1 b3 is upper(b1) & proj2 b3 is upper(b2);

:: YELLOW_3:funcnot 13 => YELLOW_3:func 13
definition
  let a1, a2 be RelStr;
  let a3 be lower Element of bool the carrier of a1;
  let a4 be lower Element of bool the carrier of a2;
  redefine func [:a3, a4:] -> lower Element of bool the carrier of [:a1,a2:];
end;

:: YELLOW_3:th 27
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
      st [:b3,b4:] is lower([:b1,b2:])
   holds b3 is lower(b1) & b4 is lower(b2);

:: YELLOW_3:th 28
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty lower Element of bool the carrier of [:b1,b2:] holds
   proj1 b3 is lower(b1) & proj2 b3 is lower(b2);

:: YELLOW_3:attrnot 1 => YELLOW_3:attr 1
definition
  let a1 be RelStr;
  attr a1 is void means
    the InternalRel of a1 is empty;
end;

:: YELLOW_3:dfs 3
definiens
  let a1 be RelStr;
To prove
     a1 is void
it is sufficient to prove
  thus the InternalRel of a1 is empty;

:: YELLOW_3:def 3
theorem
for b1 being RelStr holds
      b1 is void
   iff
      the InternalRel of b1 is empty;

:: YELLOW_3:condreg 1
registration
  cluster empty -> void (RelStr);
end;

:: YELLOW_3:exreg 1
registration
  cluster non empty strict reflexive transitive antisymmetric non void RelStr;
end;

:: YELLOW_3:condreg 2
registration
  cluster non void -> non empty (RelStr);
end;

:: YELLOW_3:condreg 3
registration
  cluster non empty reflexive -> non void (RelStr);
end;

:: YELLOW_3:funcreg 13
registration
  let a1 be non void RelStr;
  cluster the InternalRel of a1 -> non empty;
end;

:: YELLOW_3:th 29
theorem
for b1, b2 being non empty RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
      st [:b3,b4:] is_<=_than [b5,b6]
   holds b3 is_<=_than b5 & b4 is_<=_than b6;

:: YELLOW_3:th 30
theorem
for b1, b2 being non empty RelStr
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
      st b3 is_<=_than b5 & b4 is_<=_than b6
   holds [:b3,b4:] is_<=_than [b5,b6];

:: YELLOW_3:th 31
theorem
for b1, b2 being non empty RelStr
for b3 being Element of bool the carrier of [:b1,b2:]
for b4 being Element of the carrier of b1
for b5 being Element of the carrier of b2 holds
      b3 is_<=_than [b4,b5]
   iff
      proj1 b3 is_<=_than b4 & proj2 b3 is_<=_than b5;

:: YELLOW_3:th 32
theorem
for b1, b2 being non empty RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
      st [b5,b6] is_<=_than [:b3,b4:]
   holds b5 is_<=_than b3 & b6 is_<=_than b4;

:: YELLOW_3:th 33
theorem
for b1, b2 being non empty RelStr
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
      st b5 is_<=_than b3 & b6 is_<=_than b4
   holds [b5,b6] is_<=_than [:b3,b4:];

:: YELLOW_3:th 34
theorem
for b1, b2 being non empty RelStr
for b3 being Element of bool the carrier of [:b1,b2:]
for b4 being Element of the carrier of b1
for b5 being Element of the carrier of b2 holds
      [b4,b5] is_<=_than b3
   iff
      b4 is_<=_than proj1 b3 & b5 is_<=_than proj2 b3;

:: YELLOW_3:th 35
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
      st ex_sup_of b3,b1 &
         ex_sup_of b4,b2 &
         (for b7 being Element of the carrier of [:b1,b2:]
               st [:b3,b4:] is_<=_than b7
            holds [b5,b6] <= b7)
   holds (for b7 being Element of the carrier of b1
          st b3 is_<=_than b7
       holds b5 <= b7) &
    (for b7 being Element of the carrier of b2
          st b4 is_<=_than b7
       holds b6 <= b7);

:: YELLOW_3:th 36
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
      st ex_inf_of b3,b1 &
         ex_inf_of b4,b2 &
         (for b7 being Element of the carrier of [:b1,b2:]
               st b7 is_<=_than [:b3,b4:]
            holds b7 <= [b5,b6])
   holds (for b7 being Element of the carrier of b1
          st b7 is_<=_than b3
       holds b7 <= b5) &
    (for b7 being Element of the carrier of b2
          st b7 is_<=_than b4
       holds b7 <= b6);

:: YELLOW_3:th 37
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
   st (for b7 being Element of the carrier of b1
            st b3 is_<=_than b7
         holds b5 <= b7) &
      (for b7 being Element of the carrier of b2
            st b4 is_<=_than b7
         holds b6 <= b7)
for b7 being Element of the carrier of [:b1,b2:]
      st [:b3,b4:] is_<=_than b7
   holds [b5,b6] <= b7;

:: YELLOW_3:th 38
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
for b5 being Element of the carrier of b1
for b6 being Element of the carrier of b2
   st (for b7 being Element of the carrier of b1
            st b3 is_<=_than b7
         holds b7 <= b5) &
      (for b7 being Element of the carrier of b2
            st b4 is_<=_than b7
         holds b7 <= b6)
for b7 being Element of the carrier of [:b1,b2:]
      st [:b3,b4:] is_<=_than b7
   holds b7 <= [b5,b6];

:: YELLOW_3:th 39
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2 holds
      ex_sup_of b3,b1 & ex_sup_of b4,b2
   iff
      ex_sup_of [:b3,b4:],[:b1,b2:];

:: YELLOW_3:th 40
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2 holds
      ex_inf_of b3,b1 & ex_inf_of b4,b2
   iff
      ex_inf_of [:b3,b4:],[:b1,b2:];

:: YELLOW_3:th 41
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being Element of bool the carrier of [:b1,b2:] holds
      ex_sup_of proj1 b3,b1 & ex_sup_of proj2 b3,b2
   iff
      ex_sup_of b3,[:b1,b2:];

:: YELLOW_3:th 42
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being Element of bool the carrier of [:b1,b2:] holds
      ex_inf_of proj1 b3,b1 & ex_inf_of proj2 b3,b2
   iff
      ex_inf_of b3,[:b1,b2:];

:: YELLOW_3:th 43
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
      st ex_sup_of b3,b1 & ex_sup_of b4,b2
   holds "\/"([:b3,b4:],[:b1,b2:]) = ["\/"(b3,b1),"\/"(b4,b2)];

:: YELLOW_3:th 44
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b2
      st ex_inf_of b3,b1 & ex_inf_of b4,b2
   holds "/\"([:b3,b4:],[:b1,b2:]) = ["/\"(b3,b1),"/\"(b4,b2)];

:: YELLOW_3:funcreg 14
registration
  let a1, a2 be non empty antisymmetric complete RelStr;
  cluster [:a1,a2:] -> strict complete;
end;

:: YELLOW_3:th 45
theorem
for b1, b2 being non empty antisymmetric lower-bounded RelStr
      st [:b1,b2:] is complete
   holds b1 is complete & b2 is complete;

:: YELLOW_3:th 46
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of [:b1,b2:]
      st ([:b1,b2:] is complete or ex_sup_of b3,[:b1,b2:])
   holds "\/"(b3,[:b1,b2:]) = ["\/"(proj1 b3,b1),"\/"(proj2 b3,b2)];

:: YELLOW_3:th 47
theorem
for b1, b2 being non empty antisymmetric RelStr
for b3 being non empty Element of bool the carrier of [:b1,b2:]
      st ([:b1,b2:] is complete or ex_inf_of b3,[:b1,b2:])
   holds "/\"(b3,[:b1,b2:]) = ["/\"(proj1 b3,b1),"/\"(proj2 b3,b2)];

:: YELLOW_3:th 48
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty directed Element of bool the carrier of [:b1,b2:] holds
   [:proj1 b3,proj2 b3:] c= downarrow b3;

:: YELLOW_3:th 49
theorem
for b1, b2 being non empty reflexive RelStr
for b3 being non empty filtered Element of bool the carrier of [:b1,b2:] holds
   [:proj1 b3,proj2 b3:] c= uparrow b3;

:: YELLOW_3:sch 6
scheme YELLOW_3:sch 6
{F1 -> non empty RelStr,
  F2 -> non empty RelStr,
  F3 -> non empty RelStr,
  F4 -> set}:
ex b1 being Function-like quasi_total Relation of the carrier of [:F1(),F2():],the carrier of F3() st
   for b2 being Element of the carrier of F1()
   for b3 being Element of the carrier of F2() holds
      b1 .(b2,b3) = F4(b2, b3)
provided
   for b1 being Element of the carrier of F1()
   for b2 being Element of the carrier of F2() holds
      F4(b1, b2) is Element of the carrier of F3();