Article YELLOW_1, MML version 4.99.1005

:: YELLOW_1:funcreg 1
registration
  let a1 be non empty Lattice-like LattStr;
  cluster LattPOSet a1 -> strict reflexive transitive antisymmetric with_suprema with_infima;
end;

:: YELLOW_1:funcreg 2
registration
  let a1 be non empty Lattice-like upper-bounded LattStr;
  cluster LattPOSet a1 -> strict reflexive transitive antisymmetric upper-bounded;
end;

:: YELLOW_1:funcreg 3
registration
  let a1 be non empty Lattice-like lower-bounded LattStr;
  cluster LattPOSet a1 -> strict reflexive transitive antisymmetric lower-bounded;
end;

:: YELLOW_1:funcreg 4
registration
  let a1 be non empty Lattice-like complete LattStr;
  cluster LattPOSet a1 -> strict reflexive transitive antisymmetric complete;
end;

:: YELLOW_1:funcnot 1 => YELLOW_1:func 1
definition
  let a1 be set;
  redefine func RelIncl a1 -> reflexive antisymmetric transitive total Relation of a1,a1;
end;

:: YELLOW_1:funcnot 2 => YELLOW_1:func 2
definition
  let a1 be set;
  func InclPoset A1 -> strict RelStr equals
    RelStr(#a1,RelIncl a1#);
end;

:: YELLOW_1:def 1
theorem
for b1 being set holds
   InclPoset b1 = RelStr(#b1,RelIncl b1#);

:: YELLOW_1:funcreg 5
registration
  let a1 be set;
  cluster InclPoset a1 -> strict reflexive transitive antisymmetric;
end;

:: YELLOW_1:funcreg 6
registration
  let a1 be non empty set;
  cluster InclPoset a1 -> non empty strict;
end;

:: YELLOW_1:th 1
theorem
for b1 being set holds
   the carrier of InclPoset b1 = b1 & the InternalRel of InclPoset b1 = RelIncl b1;

:: YELLOW_1:funcnot 3 => YELLOW_1:func 3
definition
  let a1 be set;
  func BoolePoset A1 -> strict RelStr equals
    LattPOSet BooleLatt a1;
end;

:: YELLOW_1:def 2
theorem
for b1 being set holds
   BoolePoset b1 = LattPOSet BooleLatt b1;

:: YELLOW_1:funcreg 7
registration
  let a1 be set;
  cluster BoolePoset a1 -> non empty strict reflexive transitive antisymmetric;
end;

:: YELLOW_1:funcreg 8
registration
  let a1 be set;
  cluster BoolePoset a1 -> strict complete;
end;

:: YELLOW_1:th 2
theorem
for b1 being set
for b2, b3 being Element of the carrier of BoolePoset b1 holds
   b2 <= b3
iff
   b2 c= b3;

:: YELLOW_1:th 3
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of InclPoset b1 holds
   b2 <= b3
iff
   b2 c= b3;

:: YELLOW_1:th 4
theorem
for b1 being set holds
   BoolePoset b1 = InclPoset bool b1;

:: YELLOW_1:th 5
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
   InclPoset b2 is full SubRelStr of BoolePoset b1;

:: YELLOW_1:th 6
theorem
for b1 being non empty set
   st InclPoset b1 is with_suprema
for b2, b3 being Element of the carrier of InclPoset b1 holds
b2 \/ b3 c= b2 "\/" b3;

:: YELLOW_1:th 7
theorem
for b1 being non empty set
   st InclPoset b1 is with_infima
for b2, b3 being Element of the carrier of InclPoset b1 holds
b2 "/\" b3 c= b2 /\ b3;

:: YELLOW_1:th 8
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of InclPoset b1
      st b2 \/ b3 in b1
   holds b2 "\/" b3 = b2 \/ b3;

:: YELLOW_1:th 9
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of InclPoset b1
      st b2 /\ b3 in b1
   holds b2 "/\" b3 = b2 /\ b3;

:: YELLOW_1:th 10
theorem
for b1 being RelStr
      st for b2, b3 being Element of the carrier of b1 holds
           b2 <= b3
        iff
           b2 c= b3
   holds the InternalRel of b1 = RelIncl the carrier of b1;

:: YELLOW_1:th 11
theorem
for b1 being non empty set
      st for b2, b3 being set
              st b2 in b1 & b3 in b1
           holds b2 \/ b3 in b1
   holds InclPoset b1 is with_suprema;

:: YELLOW_1:th 12
theorem
for b1 being non empty set
      st for b2, b3 being set
              st b2 in b1 & b3 in b1
           holds b2 /\ b3 in b1
   holds InclPoset b1 is with_infima;

:: YELLOW_1:th 13
theorem
for b1 being non empty set
      st {} in b1
   holds Bottom InclPoset b1 = {};

:: YELLOW_1:th 14
theorem
for b1 being non empty set
      st union b1 in b1
   holds Top InclPoset b1 = union b1;

:: YELLOW_1:th 15
theorem
for b1 being non empty set
      st InclPoset b1 is upper-bounded
   holds union b1 in b1;

:: YELLOW_1:th 16
theorem
for b1 being non empty set
      st InclPoset b1 is lower-bounded
   holds meet b1 in b1;

:: YELLOW_1:th 17
theorem
for b1 being set
for b2, b3 being Element of the carrier of BoolePoset b1 holds
b2 "\/" b3 = b2 \/ b3 & b2 "/\" b3 = b2 /\ b3;

:: YELLOW_1:th 18
theorem
for b1 being set holds
   Bottom BoolePoset b1 = {};

:: YELLOW_1:th 19
theorem
for b1 being set holds
   Top BoolePoset b1 = b1;

:: YELLOW_1:th 20
theorem
for b1 being set
for b2 being non empty Element of bool the carrier of BoolePoset b1 holds
   "/\"(b2,BoolePoset b1) = meet b2;

:: YELLOW_1:th 21
theorem
for b1 being set
for b2 being Element of bool the carrier of BoolePoset b1 holds
   "\/"(b2,BoolePoset b1) = union b2;

:: YELLOW_1:th 22
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of InclPoset the topology of b1 holds
   "\/"(b2,InclPoset the topology of b1) = union b2;

:: YELLOW_1:th 23
theorem
for b1 being non empty TopSpace-like TopStruct holds
   Bottom InclPoset the topology of b1 = {};

:: YELLOW_1:th 24
theorem
for b1 being non empty TopSpace-like TopStruct holds
   Top InclPoset the topology of b1 = the carrier of b1;

:: YELLOW_1:funcreg 9
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster InclPoset the topology of a1 -> non trivial strict complete;
end;

:: YELLOW_1:th 25
theorem
for b1 being TopSpace-like TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is open(b1)
   iff
      b2 is Element of bool the carrier of InclPoset the topology of b1;

:: YELLOW_1:attrnot 1 => YELLOW_1:attr 1
definition
  let a1 be Relation-like set;
  attr a1 is RelStr-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is RelStr;
end;

:: YELLOW_1:dfs 3
definiens
  let a1 be Relation-like set;
To prove
     a1 is RelStr-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is RelStr;

:: YELLOW_1:def 3
theorem
for b1 being Relation-like set holds
      b1 is RelStr-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is RelStr;

:: YELLOW_1:condreg 1
registration
  cluster Relation-like Function-like RelStr-yielding -> 1-sorted-yielding (set);
end;

:: YELLOW_1:exreg 1
registration
  let a1 be set;
  cluster Relation-like Function-like RelStr-yielding ManySortedSet of a1;
end;

:: YELLOW_1:funcnot 4 => YELLOW_1:func 4
definition
  let a1 be non empty set;
  let a2 be RelStr-yielding ManySortedSet of a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> RelStr;
end;

:: YELLOW_1:funcnot 5 => YELLOW_1:func 5
definition
  let a1 be set;
  let a2 be RelStr-yielding ManySortedSet of a1;
  func product A2 -> strict RelStr means
    the carrier of it = product Carrier a2 &
     (for b1, b2 being Element of the carrier of it
           st b1 in product Carrier a2
        holds    b1 <= b2
        iff
           ex b3, b4 being Relation-like Function-like set st
              b3 = b1 &
               b4 = b2 &
               (for b5 being set
                     st b5 in a1
                  holds ex b6 being RelStr st
                     ex b7, b8 being Element of the carrier of b6 st
                        b6 = a2 . b5 & b7 = b3 . b5 & b8 = b4 . b5 & b7 <= b8));
end;

:: YELLOW_1:def 4
theorem
for b1 being set
for b2 being RelStr-yielding ManySortedSet of b1
for b3 being strict RelStr holds
      b3 = product b2
   iff
      the carrier of b3 = product Carrier b2 &
       (for b4, b5 being Element of the carrier of b3
             st b4 in product Carrier b2
          holds    b4 <= b5
          iff
             ex b6, b7 being Relation-like Function-like set st
                b6 = b4 &
                 b7 = b5 &
                 (for b8 being set
                       st b8 in b1
                    holds ex b9 being RelStr st
                       ex b10, b11 being Element of the carrier of b9 st
                          b9 = b2 . b8 & b10 = b6 . b8 & b11 = b7 . b8 & b10 <= b11));

:: YELLOW_1:funcreg 10
registration
  let a1 be set;
  let a2 be RelStr;
  cluster a1 --> a2 -> RelStr-yielding;
end;

:: YELLOW_1:funcnot 6 => YELLOW_1:func 6
definition
  let a1 be set;
  let a2 be RelStr;
  func A2 |^ A1 -> strict RelStr equals
    product (a1 --> a2);
end;

:: YELLOW_1:def 5
theorem
for b1 being set
for b2 being RelStr holds
   b2 |^ b1 = product (b1 --> b2);

:: YELLOW_1:th 26
theorem
for b1 being RelStr-yielding ManySortedSet of {} holds
   product b1 = RelStr(#{{}},id {{}}#);

:: YELLOW_1:th 27
theorem
for b1 being RelStr holds
   b1 |^ {} = RelStr(#{{}},id {{}}#);

:: YELLOW_1:th 28
theorem
for b1 being set
for b2 being RelStr holds
   Funcs(b1,the carrier of b2) = the carrier of b2 |^ b1;

:: YELLOW_1:funcreg 11
registration
  let a1 be set;
  let a2 be non empty RelStr;
  cluster a2 |^ a1 -> non empty strict;
end;

:: YELLOW_1:funcreg 12
registration
  let a1 be set;
  let a2 be non empty reflexive RelStr;
  cluster a2 |^ a1 -> strict reflexive;
end;

:: YELLOW_1:funcreg 13
registration
  let a1 be non empty RelStr;
  cluster a1 |^ {} -> trivial strict;
end;

:: YELLOW_1:funcreg 14
registration
  let a1 be non empty reflexive RelStr;
  cluster a1 |^ {} -> strict antisymmetric with_suprema with_infima;
end;

:: YELLOW_1:funcreg 15
registration
  let a1 be set;
  let a2 be non empty transitive RelStr;
  cluster a2 |^ a1 -> strict transitive;
end;

:: YELLOW_1:funcreg 16
registration
  let a1 be set;
  let a2 be non empty antisymmetric RelStr;
  cluster a2 |^ a1 -> strict antisymmetric;
end;

:: YELLOW_1:funcreg 17
registration
  let a1 be non empty set;
  let a2 be non empty antisymmetric with_infima RelStr;
  cluster a2 |^ a1 -> strict with_infima;
end;

:: YELLOW_1:funcreg 18
registration
  let a1 be non empty set;
  let a2 be non empty antisymmetric with_suprema RelStr;
  cluster a2 |^ a1 -> strict with_suprema;
end;

:: YELLOW_1:funcnot 7 => YELLOW_1:func 7
definition
  let a1, a2 be RelStr;
  func MonMaps(A1,A2) -> strict full SubRelStr of a2 |^ the carrier of a1 means
    for b1 being Function-like quasi_total Relation of the carrier of a1,the carrier of a2 holds
          b1 in the carrier of it
       iff
          b1 in Funcs(the carrier of a1,the carrier of a2) & b1 is monotone(a1, a2);
end;

:: YELLOW_1:def 6
theorem
for b1, b2 being RelStr
for b3 being strict full SubRelStr of b2 |^ the carrier of b1 holds
      b3 = MonMaps(b1,b2)
   iff
      for b4 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
            b4 in the carrier of b3
         iff
            b4 in Funcs(the carrier of b1,the carrier of b2) & b4 is monotone(b1, b2);