Article ORDERS_3, MML version 4.99.1005

:: ORDERS_3:attrnot 1 => ORDERS_3:attr 1
definition
  let a1 be RelStr;
  attr a1 is discrete means
    the InternalRel of a1 = id the carrier of a1;
end;

:: ORDERS_3:dfs 1
definiens
  let a1 be RelStr;
To prove
     a1 is discrete
it is sufficient to prove
  thus the InternalRel of a1 = id the carrier of a1;

:: ORDERS_3:def 1
theorem
for b1 being RelStr holds
      b1 is discrete
   iff
      the InternalRel of b1 = id the carrier of b1;

:: ORDERS_3:exreg 1
registration
  cluster non empty strict total reflexive transitive antisymmetric discrete RelStr;
end;

:: ORDERS_3:exreg 2
registration
  cluster empty strict total reflexive transitive antisymmetric discrete RelStr;
end;

:: ORDERS_3:funcreg 1
registration
  cluster RelStr(#{},id {}#) -> empty strict;
end;

:: ORDERS_3:funcreg 2
registration
  let a1 be empty RelStr;
  cluster the InternalRel of a1 -> empty;
end;

:: ORDERS_3:condreg 1
registration
  cluster empty -> discrete (RelStr);
end;

:: ORDERS_3:attrnot 2 => ORDERS_3:attr 2
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is disconnected means
    ex b1, b2 being Element of bool the carrier of a1 st
       b1 <> {} &
        b2 <> {} &
        a2 = b1 \/ b2 &
        b1 misses b2 &
        the InternalRel of a1 = ((the InternalRel of a1) |_2 b1) \/ ((the InternalRel of a1) |_2 b2);
end;

:: ORDERS_3:dfs 2
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is disconnected
it is sufficient to prove
  thus ex b1, b2 being Element of bool the carrier of a1 st
       b1 <> {} &
        b2 <> {} &
        a2 = b1 \/ b2 &
        b1 misses b2 &
        the InternalRel of a1 = ((the InternalRel of a1) |_2 b1) \/ ((the InternalRel of a1) |_2 b2);

:: ORDERS_3:def 2
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is disconnected(b1)
   iff
      ex b3, b4 being Element of bool the carrier of b1 st
         b3 <> {} &
          b4 <> {} &
          b2 = b3 \/ b4 &
          b3 misses b4 &
          the InternalRel of b1 = ((the InternalRel of b1) |_2 b3) \/ ((the InternalRel of b1) |_2 b4);

:: ORDERS_3:attrnot 3 => ORDERS_3:attr 2
notation
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  antonym connected for disconnected;
end;

:: ORDERS_3:attrnot 4 => ORDERS_3:attr 3
definition
  let a1 be RelStr;
  attr a1 is disconnected means
    [#] a1 is disconnected(a1);
end;

:: ORDERS_3:dfs 3
definiens
  let a1 be RelStr;
To prove
     a1 is disconnected
it is sufficient to prove
  thus [#] a1 is disconnected(a1);

:: ORDERS_3:def 3
theorem
for b1 being RelStr holds
      b1 is disconnected
   iff
      [#] b1 is disconnected(b1);

:: ORDERS_3:attrnot 5 => ORDERS_3:attr 3
notation
  let a1 be RelStr;
  antonym connected for disconnected;
end;

:: ORDERS_3:th 1
theorem
for b1 being non empty discrete RelStr
for b2, b3 being Element of the carrier of b1 holds
   b2 <= b3
iff
   b2 = b3;

:: ORDERS_3:th 2
theorem
for b1 being Relation-like set
for b2 being set
      st b1 is reflexive antisymmetric transitive total Relation of {b2},{b2}
   holds b1 = id {b2};

:: ORDERS_3:th 3
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
      st b1 is reflexive & [#] b1 = {b2}
   holds b1 is discrete;

:: ORDERS_3:th 4
theorem
for b1 being non empty RelStr
for b2 being set
      st [#] b1 = {b2}
   holds b1 is connected;

:: ORDERS_3:th 5
theorem
for b1 being non empty reflexive transitive antisymmetric discrete RelStr
      st ex b2, b3 being Element of the carrier of b1 st
           b2 <> b3
   holds b1 is disconnected;

:: ORDERS_3:exreg 3
registration
  cluster non empty strict total reflexive transitive antisymmetric connected RelStr;
end;

:: ORDERS_3:exreg 4
registration
  cluster non empty strict total reflexive transitive antisymmetric discrete disconnected RelStr;
end;

:: ORDERS_3:attrnot 6 => ORDERS_3:attr 4
definition
  let a1 be set;
  attr a1 is POSet_set-like means
    for b1 being set
          st b1 in a1
       holds b1 is non empty reflexive transitive antisymmetric RelStr;
end;

:: ORDERS_3:dfs 4
definiens
  let a1 be set;
To prove
     a1 is POSet_set-like
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is non empty reflexive transitive antisymmetric RelStr;

:: ORDERS_3:def 4
theorem
for b1 being set holds
      b1 is POSet_set-like
   iff
      for b2 being set
            st b2 in b1
         holds b2 is non empty reflexive transitive antisymmetric RelStr;

:: ORDERS_3:exreg 5
registration
  cluster non empty POSet_set-like set;
end;

:: ORDERS_3:modenot 1
definition
  mode POSet_set is POSet_set-like set;
end;

:: ORDERS_3:modenot 2 => ORDERS_3:mode 1
definition
  let a1 be non empty POSet_set-like set;
  redefine mode Element of a1 -> non empty reflexive transitive antisymmetric RelStr;
end;

:: ORDERS_3:attrnot 7 => ORDERS_3:attr 5
definition
  let a1, a2 be RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is monotone means
    for b1, b2 being Element of the carrier of a1
       st b1 <= b2
    for b3, b4 being Element of the carrier of a2
          st b3 = a3 . b1 & b4 = a3 . b2
       holds b3 <= b4;
end;

:: ORDERS_3:dfs 5
definiens
  let a1, a2 be RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is monotone
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
       st b1 <= b2
    for b3, b4 being Element of the carrier of a2
          st b3 = a3 . b1 & b4 = a3 . b2
       holds b3 <= b4;

:: ORDERS_3:def 5
theorem
for b1, b2 being RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
      b3 is monotone(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1
         st b4 <= b5
      for b6, b7 being Element of the carrier of b2
            st b6 = b3 . b4 & b7 = b3 . b5
         holds b6 <= b7;

:: ORDERS_3:funcnot 1 => ORDERS_3:func 1
definition
  let a1, a2 be RelStr;
  func MonFuncs(A1,A2) -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Function-like quasi_total Relation of the carrier of a1,the carrier of a2 st
             b1 = b2 & b2 in Funcs(the carrier of a1,the carrier of a2) & b2 is monotone(a1, a2);
end;

:: ORDERS_3:def 6
theorem
for b1, b2 being RelStr
for b3 being set holds
      b3 = MonFuncs(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 st
               b4 = b5 & b5 in Funcs(the carrier of b1,the carrier of b2) & b5 is monotone(b1, b2);

:: ORDERS_3:th 6
theorem
for b1, b2, b3 being non empty RelStr
for b4, b5 being Relation-like Function-like set
      st b4 in MonFuncs(b1,b2) & b5 in MonFuncs(b2,b3)
   holds b4 * b5 in MonFuncs(b1,b3);

:: ORDERS_3:th 7
theorem
for b1 being non empty RelStr holds
   id the carrier of b1 in MonFuncs(b1,b1);

:: ORDERS_3:funcreg 3
registration
  let a1 be non empty RelStr;
  cluster MonFuncs(a1,a1) -> non empty;
end;

:: ORDERS_3:funcnot 2 => ORDERS_3:func 2
definition
  let a1 be set;
  func Carr A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being 1-sorted st
             b2 in a1 & b1 = the carrier of b2;
end;

:: ORDERS_3:def 7
theorem
for b1, b2 being set holds
   b2 = Carr b1
iff
   for b3 being set holds
         b3 in b2
      iff
         ex b4 being 1-sorted st
            b4 in b1 & b3 = the carrier of b4;

:: ORDERS_3:funcreg 4
registration
  let a1 be non empty POSet_set-like set;
  cluster Carr a1 -> non empty;
end;

:: ORDERS_3:th 8
theorem
for b1 being 1-sorted holds
   Carr {b1} = {the carrier of b1};

:: ORDERS_3:th 9
theorem
for b1, b2 being 1-sorted holds
Carr {b1,b2} = {the carrier of b1,the carrier of b2};

:: ORDERS_3:th 10
theorem
for b1 being non empty POSet_set-like set
for b2, b3 being Element of b1 holds
MonFuncs(b2,b3) c= Funcs Carr b1;

:: ORDERS_3:th 11
theorem
for b1, b2 being RelStr holds
MonFuncs(b1,b2) c= Funcs(the carrier of b1,the carrier of b2);

:: ORDERS_3:funcreg 5
registration
  let a1, a2 be non empty reflexive transitive antisymmetric RelStr;
  cluster MonFuncs(a1,a2) -> functional;
end;

:: ORDERS_3:funcnot 3 => ORDERS_3:func 3
definition
  let a1 be non empty POSet_set-like set;
  func POSCat A1 -> strict non void Category-like with_triple-like_morphisms CatStr means
    the Vertices of it = a1 &
     (for b1, b2 being Element of a1
     for b3 being Element of Funcs Carr a1
           st b3 in MonFuncs(b1,b2)
        holds [[b1,b2],b3] is Element of the Edges of it) &
     (for b1 being Element of the Edges of it holds
        ex b2, b3 being Element of a1 st
           ex b4 being Element of Funcs Carr a1 st
              b1 = [[b2,b3],b4] & b4 in MonFuncs(b2,b3)) &
     (for b1, b2 being Element of the Edges of it
     for b3, b4, b5 being Element of a1
     for b6, b7 being Element of Funcs Carr a1
           st b1 = [[b3,b4],b6] & b2 = [[b4,b5],b7]
        holds b2 * b1 = [[b3,b5],b6 * b7]);
end;

:: ORDERS_3:def 8
theorem
for b1 being non empty POSet_set-like set
for b2 being strict non void Category-like with_triple-like_morphisms CatStr holds
      b2 = POSCat b1
   iff
      the Vertices of b2 = b1 &
       (for b3, b4 being Element of b1
       for b5 being Element of Funcs Carr b1
             st b5 in MonFuncs(b3,b4)
          holds [[b3,b4],b5] is Element of the Edges of b2) &
       (for b3 being Element of the Edges of b2 holds
          ex b4, b5 being Element of b1 st
             ex b6 being Element of Funcs Carr b1 st
                b3 = [[b4,b5],b6] & b6 in MonFuncs(b4,b5)) &
       (for b3, b4 being Element of the Edges of b2
       for b5, b6, b7 being Element of b1
       for b8, b9 being Element of Funcs Carr b1
             st b3 = [[b5,b6],b8] & b4 = [[b6,b7],b9]
          holds b4 * b3 = [[b5,b7],b8 * b9]);

:: ORDERS_3:sch 1
scheme ORDERS_3:sch 1
{F1 -> non empty set,
  F2 -> functional set}:
ex b1 being strict AltCatStr st
   the carrier of b1 = F1() &
    (for b2, b3 being Element of F1() holds
    (the Arrows of b1) .(b2,b3) = F2(b2, b3) &
     (for b4, b5, b6 being Element of F1() holds
     (the Comp of b1) .(b4,b5,b6) = FuncComp(F2(b4, b5),F2(b5, b6))))
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being Relation-like Function-like set
         st b4 in F2(b1, b2) & b5 in F2(b2, b3)
      holds b4 * b5 in F2(b1, b3);


:: ORDERS_3:sch 2
scheme ORDERS_3:sch 2
{F1 -> non empty set,
  F2 -> functional set}:
for b1, b2 being strict AltCatStr
      st the carrier of b1 = F1() &
         (for b3, b4 being Element of F1() holds
         (the Arrows of b1) .(b3,b4) = F2(b3, b4) &
          (for b5, b6, b7 being Element of F1() holds
          (the Comp of b1) .(b5,b6,b7) = FuncComp(F2(b5, b6),F2(b6, b7)))) &
         the carrier of b2 = F1() &
         (for b3, b4 being Element of F1() holds
         (the Arrows of b2) .(b3,b4) = F2(b3, b4) &
          (for b5, b6, b7 being Element of F1() holds
          (the Comp of b2) .(b5,b6,b7) = FuncComp(F2(b5, b6),F2(b6, b7))))
   holds b1 = b2


:: ORDERS_3:funcnot 4 => ORDERS_3:func 4
definition
  let a1 be non empty POSet_set-like set;
  func POSAltCat A1 -> strict AltCatStr means
    the carrier of it = a1 &
     (for b1, b2 being Element of a1 holds
     (the Arrows of it) .(b1,b2) = MonFuncs(b1,b2) &
      (for b3, b4, b5 being Element of a1 holds
      (the Comp of it) .(b3,b4,b5) = FuncComp(MonFuncs(b3,b4),MonFuncs(b4,b5))));
end;

:: ORDERS_3:def 9
theorem
for b1 being non empty POSet_set-like set
for b2 being strict AltCatStr holds
      b2 = POSAltCat b1
   iff
      the carrier of b2 = b1 &
       (for b3, b4 being Element of b1 holds
       (the Arrows of b2) .(b3,b4) = MonFuncs(b3,b4) &
        (for b5, b6, b7 being Element of b1 holds
        (the Comp of b2) .(b5,b6,b7) = FuncComp(MonFuncs(b5,b6),MonFuncs(b6,b7))));

:: ORDERS_3:funcreg 6
registration
  let a1 be non empty POSet_set-like set;
  cluster POSAltCat a1 -> non empty transitive strict;
end;

:: ORDERS_3:funcreg 7
registration
  let a1 be non empty POSet_set-like set;
  cluster POSAltCat a1 -> strict associative with_units;
end;

:: ORDERS_3:th 12
theorem
for b1 being non empty POSet_set-like set
for b2, b3 being Element of the carrier of POSAltCat b1
for b4, b5 being Element of b1
      st b2 = b4 & b3 = b5
   holds <^b2,b3^> c= Funcs(the carrier of b4,the carrier of b5);