Article CAT_5, MML version 4.99.1005

:: CAT_5:funcnot 1 => CAT_5:func 1
definition
  let a1, a2, a3 be non empty set;
  let a4 be Element of [:[:a1,a2:],a3:];
  redefine func a4 `11 -> Element of a1;
end;

:: CAT_5:funcnot 2 => CAT_5:func 2
definition
  let a1, a2, a3 be non empty set;
  let a4 be Element of [:[:a1,a2:],a3:];
  redefine func a4 `12 -> Element of a2;
end;

:: CAT_5:funcnot 3 => CAT_5:func 3
definition
  let a1, a2 be non empty set;
  let a3 be Element of [:a1,a2:];
  redefine func a3 `2 -> Element of a2;
end;

:: CAT_5:th 1
theorem
for b1, b2 being CatStr
      st CatStr(#the Vertices of b1,the Edges of b1,the Source of b1,the Target of b1,the Comp of b1,the Id of b1#) = CatStr(#the Vertices of b2,the Edges of b2,the Source of b2,the Target of b2,the Comp of b2,the Id of b2#) &
         b1 is Category-like
   holds b2 is Category-like;

:: CAT_5:attrnot 1 => CAT_5:attr 1
definition
  let a1 be non void CatStr;
  attr a1 is with_triple-like_morphisms means
    for b1 being Element of the Edges of a1 holds
       ex b2 being set st
          b1 = [[dom b1,cod b1],b2];
end;

:: CAT_5:dfs 1
definiens
  let a1 be non void CatStr;
To prove
     a1 is with_triple-like_morphisms
it is sufficient to prove
  thus for b1 being Element of the Edges of a1 holds
       ex b2 being set st
          b1 = [[dom b1,cod b1],b2];

:: CAT_5:def 1
theorem
for b1 being non void CatStr holds
      b1 is with_triple-like_morphisms
   iff
      for b2 being Element of the Edges of b1 holds
         ex b3 being set st
            b2 = [[dom b2,cod b2],b3];

:: CAT_5:exreg 1
registration
  cluster strict non void Category-like with_triple-like_morphisms CatStr;
end;

:: CAT_5:th 2
theorem
for b1 being non void with_triple-like_morphisms CatStr
for b2 being Element of the Edges of b1 holds
   dom b2 = b2 `11 &
    cod b2 = b2 `12 &
    b2 = [[dom b2,cod b2],b2 `2];

:: CAT_5:funcnot 4 => CAT_5:func 4
definition
  let a1 be non void with_triple-like_morphisms CatStr;
  let a2 be Element of the Edges of a1;
  redefine func a2 `11 -> Element of the Vertices of a1;
end;

:: CAT_5:funcnot 5 => CAT_5:func 5
definition
  let a1 be non void with_triple-like_morphisms CatStr;
  let a2 be Element of the Edges of a1;
  redefine func a2 `12 -> Element of the Vertices of a1;
end;

:: CAT_5:sch 1
scheme CAT_5:sch 1
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set}:
ex b1 being strict non void Category-like with_triple-like_morphisms CatStr st
   the Vertices of b1 = F1() &
    (for b2, b3 being Element of F1()
    for b4 being Element of F2()
          st P1[b2, b3, b4]
       holds [[b2,b3],b4] is Element of the Edges of b1) &
    (for b2 being Element of the Edges of b1 holds
       ex b3, b4 being Element of F1() st
          ex b5 being Element of F2() st
             b2 = [[b3,b4],b5] & P1[b3, b4, b5]) &
    (for b2, b3 being Element of the Edges of b1
    for b4, b5, b6 being Element of F1()
    for b7, b8 being Element of F2()
          st b2 = [[b4,b5],b7] & b3 = [[b5,b6],b8]
       holds b3 * b2 = [[b4,b6],F3(b8, b7)])
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being Element of F2()
         st P1[b1, b2, b4] & P1[b2, b3, b5]
      holds F3(b5, b4) in F2() & P1[b1, b3, F3(b5, b4)]
and
   for b1 being Element of F1() holds
      ex b2 being Element of F2() st
         P1[b1, b1, b2] &
          (for b3 being Element of F1()
          for b4 being Element of F2() holds
             (P1[b1, b3, b4] implies F3(b4, b2) = b4) & (P1[b3, b1, b4] implies F3(b2, b4) = b4))
and
   for b1, b2, b3, b4 being Element of F1()
   for b5, b6, b7 being Element of F2()
         st P1[b1, b2, b5] & P1[b2, b3, b6] & P1[b3, b4, b7]
      holds F3(b7, F3(b6, b5)) = F3(F3(b7, b6), b5);


:: CAT_5:sch 2
scheme CAT_5:sch 2
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set}:
for b1, b2 being strict non void Category-like with_triple-like_morphisms CatStr
      st the Vertices of b1 = F1() &
         (for b3, b4 being Element of F1()
         for b5 being Element of F2()
               st P1[b3, b4, b5]
            holds [[b3,b4],b5] is Element of the Edges of b1) &
         (for b3 being Element of the Edges of b1 holds
            ex b4, b5 being Element of F1() st
               ex b6 being Element of F2() st
                  b3 = [[b4,b5],b6] & P1[b4, b5, b6]) &
         (for b3, b4 being Element of the Edges of b1
         for b5, b6, b7 being Element of F1()
         for b8, b9 being Element of F2()
               st b3 = [[b5,b6],b8] & b4 = [[b6,b7],b9]
            holds b4 * b3 = [[b5,b7],F3(b9, b8)]) &
         the Vertices of b2 = F1() &
         (for b3, b4 being Element of F1()
         for b5 being Element of F2()
               st P1[b3, b4, b5]
            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 F1() st
               ex b6 being Element of F2() st
                  b3 = [[b4,b5],b6] & P1[b4, b5, b6]) &
         (for b3, b4 being Element of the Edges of b2
         for b5, b6, b7 being Element of F1()
         for b8, b9 being Element of F2()
               st b3 = [[b5,b6],b8] & b4 = [[b6,b7],b9]
            holds b4 * b3 = [[b5,b7],F3(b9, b8)])
   holds b1 = b2
provided
   for b1 being Element of F1() holds
      ex b2 being Element of F2() st
         P1[b1, b1, b2] &
          (for b3 being Element of F1()
          for b4 being Element of F2() holds
             (P1[b1, b3, b4] implies F3(b4, b2) = b4) & (P1[b3, b1, b4] implies F3(b2, b4) = b4));


:: CAT_5:sch 3
scheme CAT_5:sch 3
{F1 -> non void Category-like CatStr,
  F2 -> non void Category-like CatStr,
  F3 -> Element of the Vertices of F2(),
  F4 -> set}:
ex b1 being Functor of F1(),F2() st
   for b2 being Element of the Edges of F1() holds
      b1 . b2 = F4(b2)
provided
   for b1 being Element of the Edges of F1() holds
      F4(b1) is Element of the Edges of F2() &
       (for b2 being Element of the Edges of F2()
             st b2 = F4(b1)
          holds dom b2 = F3(dom b1) & cod b2 = F3(cod b1))
and
   for b1 being Element of the Vertices of F1() holds
      F4(id b1) = id F3(b1)
and
   for b1, b2 being Element of the Edges of F1()
   for b3, b4 being Element of the Edges of F2()
         st b3 = F4(b1) & b4 = F4(b2) & dom b2 = cod b1
      holds F4(b2 * b1) = b4 * b3;


:: CAT_5:th 3
theorem
for b1 being non void Category-like CatStr
for b2 being Subcategory of b1
      st b1 is Subcategory of b2
   holds CatStr(#the Vertices of b1,the Edges of b1,the Source of b1,the Target of b1,the Comp of b1,the Id of b1#) = CatStr(#the Vertices of b2,the Edges of b2,the Source of b2,the Target of b2,the Comp of b2,the Id of b2#);

:: CAT_5:th 4
theorem
for b1 being non void Category-like CatStr
for b2 being Subcategory of b1
for b3 being Subcategory of b2 holds
   b3 is Subcategory of b1;

:: CAT_5:funcnot 6 => CAT_5:func 6
definition
  let a1, a2 be non void Category-like CatStr;
  assume (ex b1 being non void Category-like CatStr st
        a1 is Subcategory of b1 & a2 is Subcategory of b1) &
     (ex b1 being Element of the Vertices of a1 st
        b1 is Element of the Vertices of a2);
  func A1 /\ A2 -> strict non void Category-like CatStr means
    the Vertices of it = (the Vertices of a1) /\ the Vertices of a2 & the Edges of it = (the Edges of a1) /\ the Edges of a2 & the Source of it = (the Source of a1) | the Edges of a2 & the Target of it = (the Target of a1) | the Edges of a2 & the Comp of it = (the Comp of a1) || the Edges of a2 & the Id of it = (the Id of a1) | the Vertices of a2;
end;

:: CAT_5:def 2
theorem
for b1, b2 being non void Category-like CatStr
   st (ex b3 being non void Category-like CatStr st
         b1 is Subcategory of b3 & b2 is Subcategory of b3) &
      (ex b3 being Element of the Vertices of b1 st
         b3 is Element of the Vertices of b2)
for b3 being strict non void Category-like CatStr holds
      b3 = b1 /\ b2
   iff
      the Vertices of b3 = (the Vertices of b1) /\ the Vertices of b2 &
       the Edges of b3 = (the Edges of b1) /\ the Edges of b2 &
       the Source of b3 = (the Source of b1) | the Edges of b2 &
       the Target of b3 = (the Target of b1) | the Edges of b2 &
       the Comp of b3 = (the Comp of b1) || the Edges of b2 &
       the Id of b3 = (the Id of b1) | the Vertices of b2;

:: CAT_5:th 5
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Subcategory of b1
      st the Vertices of b2 meets the Vertices of b3
   holds b2 /\ b3 = b3 /\ b2;

:: CAT_5:th 6
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Subcategory of b1
      st the Vertices of b2 meets the Vertices of b3
   holds b2 /\ b3 is Subcategory of b2 & b2 /\ b3 is Subcategory of b3;

:: CAT_5:funcnot 7 => CAT_5:func 7
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  func Image A3 -> strict Subcategory of a2 means
    the Vertices of it = rng Obj a3 &
     rng a3 c= the Edges of it &
     (for b1 being Subcategory of a2
           st the Vertices of b1 = rng Obj a3 & rng a3 c= the Edges of b1
        holds it is Subcategory of b1);
end;

:: CAT_5:def 3
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being strict Subcategory of b2 holds
      b4 = Image b3
   iff
      the Vertices of b4 = rng Obj b3 &
       rng b3 c= the Edges of b4 &
       (for b5 being Subcategory of b2
             st the Vertices of b5 = rng Obj b3 & rng b3 c= the Edges of b5
          holds b4 is Subcategory of b5);

:: CAT_5:th 7
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Subcategory of b2
for b4 being Functor of b1,b2
      st rng b4 c= the Edges of b3
   holds b4 is Functor of b1,b3;

:: CAT_5:th 8
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
   b3 is Functor of b1,Image b3;

:: CAT_5:th 9
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Subcategory of b2
for b4 being Functor of b1,b3
for b5 being Functor of b1,b2
      st b4 = b5
   holds Image b4 = Image b5;

:: CAT_5:attrnot 2 => CAT_5:attr 2
definition
  let a1 be set;
  attr a1 is categorial means
    for b1 being set
          st b1 in a1
       holds b1 is non void Category-like CatStr;
end;

:: CAT_5:dfs 4
definiens
  let a1 be set;
To prove
     a1 is categorial
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is non void Category-like CatStr;

:: CAT_5:def 4
theorem
for b1 being set holds
      b1 is categorial
   iff
      for b2 being set
            st b2 in b1
         holds b2 is non void Category-like CatStr;

:: CAT_5:attrnot 3 => CAT_5:attr 2
definition
  let a1 be set;
  attr a1 is categorial means
    for b1 being Element of a1 holds
       b1 is non void Category-like CatStr;
end;

:: CAT_5:dfs 5
definiens
  let a1 be non empty set;
To prove
     a1 is categorial
it is sufficient to prove
  thus for b1 being Element of a1 holds
       b1 is non void Category-like CatStr;

:: CAT_5:def 5
theorem
for b1 being non empty set holds
      b1 is categorial
   iff
      for b2 being Element of b1 holds
         b2 is non void Category-like CatStr;

:: CAT_5:exreg 2
registration
  cluster non empty categorial set;
end;

:: CAT_5:modenot 1 => CAT_5:mode 1
definition
  let a1 be non empty categorial set;
  redefine mode Element of a1 -> non void Category-like CatStr;
end;

:: CAT_5:attrnot 4 => CAT_5:attr 3
definition
  let a1 be non void Category-like CatStr;
  attr a1 is Categorial means
    the Vertices of a1 is categorial &
     (for b1 being Element of the Vertices of a1
     for b2 being non void Category-like CatStr
           st b1 = b2
        holds id b1 = [[b2,b2],id b2]) &
     (for b1 being Element of the Edges of a1
     for b2, b3 being non void Category-like CatStr
           st b2 = dom b1 & b3 = cod b1
        holds ex b4 being Functor of b2,b3 st
           b1 = [[b2,b3],b4]) &
     (for b1, b2 being Element of the Edges of a1
     for b3, b4, b5 being non void Category-like CatStr
     for b6 being Functor of b3,b4
     for b7 being Functor of b4,b5
           st b1 = [[b3,b4],b6] & b2 = [[b4,b5],b7]
        holds b2 * b1 = [[b3,b5],b7 * b6]);
end;

:: CAT_5:dfs 6
definiens
  let a1 be non void Category-like CatStr;
To prove
     a1 is Categorial
it is sufficient to prove
  thus the Vertices of a1 is categorial &
     (for b1 being Element of the Vertices of a1
     for b2 being non void Category-like CatStr
           st b1 = b2
        holds id b1 = [[b2,b2],id b2]) &
     (for b1 being Element of the Edges of a1
     for b2, b3 being non void Category-like CatStr
           st b2 = dom b1 & b3 = cod b1
        holds ex b4 being Functor of b2,b3 st
           b1 = [[b2,b3],b4]) &
     (for b1, b2 being Element of the Edges of a1
     for b3, b4, b5 being non void Category-like CatStr
     for b6 being Functor of b3,b4
     for b7 being Functor of b4,b5
           st b1 = [[b3,b4],b6] & b2 = [[b4,b5],b7]
        holds b2 * b1 = [[b3,b5],b7 * b6]);

:: CAT_5:def 6
theorem
for b1 being non void Category-like CatStr holds
      b1 is Categorial
   iff
      the Vertices of b1 is categorial &
       (for b2 being Element of the Vertices of b1
       for b3 being non void Category-like CatStr
             st b2 = b3
          holds id b2 = [[b3,b3],id b3]) &
       (for b2 being Element of the Edges of b1
       for b3, b4 being non void Category-like CatStr
             st b3 = dom b2 & b4 = cod b2
          holds ex b5 being Functor of b3,b4 st
             b2 = [[b3,b4],b5]) &
       (for b2, b3 being Element of the Edges of b1
       for b4, b5, b6 being non void Category-like CatStr
       for b7 being Functor of b4,b5
       for b8 being Functor of b5,b6
             st b2 = [[b4,b5],b7] & b3 = [[b5,b6],b8]
          holds b3 * b2 = [[b4,b6],b8 * b7]);

:: CAT_5:condreg 1
registration
  cluster non void Category-like Categorial -> with_triple-like_morphisms (CatStr);
end;

:: CAT_5:th 10
theorem
for b1, b2 being non void Category-like CatStr
      st CatStr(#the Vertices of b1,the Edges of b1,the Source of b1,the Target of b1,the Comp of b1,the Id of b1#) = CatStr(#the Vertices of b2,the Edges of b2,the Source of b2,the Target of b2,the Comp of b2,the Id of b2#) &
         b1 is Categorial
   holds b2 is Categorial;

:: CAT_5:th 11
theorem
for b1 being non void Category-like CatStr holds
   1Cat(b1,[[b1,b1],id b1]) is Categorial;

:: CAT_5:exreg 3
registration
  cluster strict non void Category-like Categorial CatStr;
end;

:: CAT_5:th 12
theorem
for b1 being non void Category-like Categorial CatStr
for b2 being Element of the Vertices of b1 holds
   b2 is non void Category-like CatStr;

:: CAT_5:th 13
theorem
for b1 being non void Category-like Categorial CatStr
for b2 being Element of the Edges of b1 holds
   dom b2 = b2 `11 & cod b2 = b2 `12;

:: CAT_5:funcnot 8 => CAT_5:func 8
definition
  let a1 be non void Category-like Categorial CatStr;
  let a2 be Element of the Edges of a1;
  redefine func a2 `11 -> non void Category-like CatStr;
end;

:: CAT_5:funcnot 9 => CAT_5:func 9
definition
  let a1 be non void Category-like Categorial CatStr;
  let a2 be Element of the Edges of a1;
  redefine func a2 `12 -> non void Category-like CatStr;
end;

:: CAT_5:th 14
theorem
for b1, b2 being non void Category-like Categorial CatStr
      st the Vertices of b1 = the Vertices of b2 & the Edges of b1 = the Edges of b2
   holds CatStr(#the Vertices of b1,the Edges of b1,the Source of b1,the Target of b1,the Comp of b1,the Id of b1#) = CatStr(#the Vertices of b2,the Edges of b2,the Source of b2,the Target of b2,the Comp of b2,the Id of b2#);

:: CAT_5:condreg 2
registration
  let a1 be non void Category-like Categorial CatStr;
  cluster -> Categorial (Subcategory of a1);
end;

:: CAT_5:th 15
theorem
for b1, b2 being non void Category-like Categorial CatStr
      st the Edges of b1 c= the Edges of b2
   holds b1 is Subcategory of b2;

:: CAT_5:funcnot 10 => CAT_5:func 10
definition
  let a1 be set;
  assume a1 is non void Category-like CatStr;
  func cat A1 -> non void Category-like CatStr equals
    a1;
end;

:: CAT_5:def 7
theorem
for b1 being set
      st b1 is non void Category-like CatStr
   holds cat b1 = b1;

:: CAT_5:th 16
theorem
for b1 being non void Category-like Categorial CatStr
for b2 being Element of the Vertices of b1 holds
   cat b2 = b2;

:: CAT_5:funcnot 11 => CAT_5:func 11
definition
  let a1 be non void Category-like Categorial CatStr;
  let a2 be Element of the Edges of a1;
  redefine func a2 `2 -> Functor of cat dom a2,cat cod a2;
end;

:: CAT_5:th 17
theorem
for b1 being non empty categorial set
for b2 being non empty set
      st (for b3, b4, b5 being Element of b1
         for b6 being Functor of b3,b4
         for b7 being Functor of b4,b5
               st b6 in b2 & b7 in b2
            holds b7 * b6 in b2) &
         (for b3 being Element of b1 holds
            id b3 in b2)
   holds ex b3 being strict non void Category-like Categorial CatStr st
      the Vertices of b3 = b1 &
       (for b4, b5 being Element of b1
       for b6 being Functor of b4,b5 holds
             [[b4,b5],b6] is Element of the Edges of b3
          iff
             b6 in b2);

:: CAT_5:th 18
theorem
for b1 being non empty categorial set
for b2 being non empty set
for b3, b4 being strict non void Category-like Categorial CatStr
      st the Vertices of b3 = b1 &
         (for b5, b6 being Element of b1
         for b7 being Functor of b5,b6 holds
               [[b5,b6],b7] is Element of the Edges of b3
            iff
               b7 in b2) &
         the Vertices of b4 = b1 &
         (for b5, b6 being Element of b1
         for b7 being Functor of b5,b6 holds
               [[b5,b6],b7] is Element of the Edges of b4
            iff
               b7 in b2)
   holds b3 = b4;

:: CAT_5:attrnot 5 => CAT_5:attr 4
definition
  let a1 be non void Category-like Categorial CatStr;
  attr a1 is full means
    for b1, b2 being non void Category-like CatStr
       st b1 is Element of the Vertices of a1 & b2 is Element of the Vertices of a1
    for b3 being Functor of b1,b2 holds
       [[b1,b2],b3] is Element of the Edges of a1;
end;

:: CAT_5:dfs 8
definiens
  let a1 be non void Category-like Categorial CatStr;
To prove
     a1 is full
it is sufficient to prove
  thus for b1, b2 being non void Category-like CatStr
       st b1 is Element of the Vertices of a1 & b2 is Element of the Vertices of a1
    for b3 being Functor of b1,b2 holds
       [[b1,b2],b3] is Element of the Edges of a1;

:: CAT_5:def 8
theorem
for b1 being non void Category-like Categorial CatStr holds
      b1 is full
   iff
      for b2, b3 being non void Category-like CatStr
         st b2 is Element of the Vertices of b1 & b3 is Element of the Vertices of b1
      for b4 being Functor of b2,b3 holds
         [[b2,b3],b4] is Element of the Edges of b1;

:: CAT_5:exreg 4
registration
  cluster strict non void Category-like with_triple-like_morphisms Categorial full CatStr;
end;

:: CAT_5:th 19
theorem
for b1, b2 being non void Category-like Categorial full CatStr
      st the Vertices of b1 = the Vertices of b2
   holds CatStr(#the Vertices of b1,the Edges of b1,the Source of b1,the Target of b1,the Comp of b1,the Id of b1#) = CatStr(#the Vertices of b2,the Edges of b2,the Source of b2,the Target of b2,the Comp of b2,the Id of b2#);

:: CAT_5:th 20
theorem
for b1 being non empty categorial set holds
   ex b2 being strict non void Category-like Categorial full CatStr st
      the Vertices of b2 = b1;

:: CAT_5:th 21
theorem
for b1 being non void Category-like Categorial CatStr
for b2 being non void Category-like Categorial full CatStr
      st the Vertices of b1 c= the Vertices of b2
   holds b1 is Subcategory of b2;

:: CAT_5:th 22
theorem
for b1 being non void Category-like CatStr
for b2, b3 being non void Category-like Categorial CatStr
for b4 being Functor of b1,b2
for b5 being Functor of b1,b3
      st b4 = b5
   holds Image b4 = Image b5;

:: CAT_5:funcnot 12 => CAT_5:func 12
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  func Hom A2 -> Element of bool the Edges of a1 equals
    (the Target of a1) " {a2};
end;

:: CAT_5:def 9
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   Hom b2 = (the Target of b1) " {b2};

:: CAT_5:funcnot 13 => CAT_5:func 13
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  func A2 Hom -> Element of bool the Edges of a1 equals
    (the Source of a1) " {a2};
end;

:: CAT_5:def 10
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   b2 Hom = (the Source of b1) " {b2};

:: CAT_5:funcreg 1
registration
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  cluster Hom a2 -> non empty;
end;

:: CAT_5:funcreg 2
registration
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  cluster a2 Hom -> non empty;
end;

:: CAT_5:th 23
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Element of the Edges of b1 holds
      b3 in Hom b2
   iff
      cod b3 = b2;

:: CAT_5:th 24
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Element of the Edges of b1 holds
      b3 in b2 Hom
   iff
      dom b3 = b2;

:: CAT_5:th 25
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1 holds
Hom(b2,b3) = b2 Hom /\ Hom b3;

:: CAT_5:th 26
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1 holds
   b2 in (dom b2) Hom & b2 in Hom cod b2;

:: CAT_5:th 27
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1
for b3 being Element of Hom dom b2 holds
   b2 * b3 in Hom cod b2;

:: CAT_5:th 28
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1
for b3 being Element of (cod b2) Hom holds
   b3 * b2 in (dom b2) Hom;

:: CAT_5:funcnot 14 => CAT_5:func 14
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  func A1 -SliceCat A2 -> strict non void Category-like with_triple-like_morphisms CatStr means
    the Vertices of it = Hom a2 &
     (for b1, b2 being Element of Hom a2
     for b3 being Element of the Edges of a1
           st dom b2 = cod b3 & b1 = b2 * b3
        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 Hom a2 st
           ex b4 being Element of the Edges of a1 st
              b1 = [[b2,b3],b4] & dom b3 = cod b4 & b2 = b3 * b4) &
     (for b1, b2 being Element of the Edges of it
     for b3, b4, b5 being Element of Hom a2
     for b6, b7 being Element of the Edges of a1
           st b1 = [[b3,b4],b6] & b2 = [[b4,b5],b7]
        holds b2 * b1 = [[b3,b5],b7 * b6]);
end;

:: CAT_5:def 11
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being strict non void Category-like with_triple-like_morphisms CatStr holds
      b3 = b1 -SliceCat b2
   iff
      the Vertices of b3 = Hom b2 &
       (for b4, b5 being Element of Hom b2
       for b6 being Element of the Edges of b1
             st dom b5 = cod b6 & b4 = b5 * b6
          holds [[b4,b5],b6] is Element of the Edges of b3) &
       (for b4 being Element of the Edges of b3 holds
          ex b5, b6 being Element of Hom b2 st
             ex b7 being Element of the Edges of b1 st
                b4 = [[b5,b6],b7] & dom b6 = cod b7 & b5 = b6 * b7) &
       (for b4, b5 being Element of the Edges of b3
       for b6, b7, b8 being Element of Hom b2
       for b9, b10 being Element of the Edges of b1
             st b4 = [[b6,b7],b9] & b5 = [[b7,b8],b10]
          holds b5 * b4 = [[b6,b8],b10 * b9]);

:: CAT_5:funcnot 15 => CAT_5:func 15
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  func A2 -SliceCat A1 -> strict non void Category-like with_triple-like_morphisms CatStr means
    the Vertices of it = a2 Hom &
     (for b1, b2 being Element of a2 Hom
     for b3 being Element of the Edges of a1
           st dom b3 = cod b1 & b3 * 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 a2 Hom st
           ex b4 being Element of the Edges of a1 st
              b1 = [[b2,b3],b4] & dom b4 = cod b2 & b4 * b2 = b3) &
     (for b1, b2 being Element of the Edges of it
     for b3, b4, b5 being Element of a2 Hom
     for b6, b7 being Element of the Edges of a1
           st b1 = [[b3,b4],b6] & b2 = [[b4,b5],b7]
        holds b2 * b1 = [[b3,b5],b7 * b6]);
end;

:: CAT_5:def 12
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being strict non void Category-like with_triple-like_morphisms CatStr holds
      b3 = b2 -SliceCat b1
   iff
      the Vertices of b3 = b2 Hom &
       (for b4, b5 being Element of b2 Hom
       for b6 being Element of the Edges of b1
             st dom b6 = cod b4 & b6 * b4 = b5
          holds [[b4,b5],b6] is Element of the Edges of b3) &
       (for b4 being Element of the Edges of b3 holds
          ex b5, b6 being Element of b2 Hom st
             ex b7 being Element of the Edges of b1 st
                b4 = [[b5,b6],b7] & dom b7 = cod b5 & b7 * b5 = b6) &
       (for b4, b5 being Element of the Edges of b3
       for b6, b7, b8 being Element of b2 Hom
       for b9, b10 being Element of the Edges of b1
             st b4 = [[b6,b7],b9] & b5 = [[b7,b8],b10]
          holds b5 * b4 = [[b6,b8],b10 * b9]);

:: CAT_5:funcnot 16 => CAT_5:func 16
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  let a3 be Element of the Edges of a1 -SliceCat a2;
  redefine func a3 `2 -> Element of the Edges of a1;
end;

:: CAT_5:funcnot 17 => CAT_5:func 17
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  let a3 be Element of the Edges of a1 -SliceCat a2;
  redefine func a3 `11 -> Element of Hom a2;
end;

:: CAT_5:funcnot 18 => CAT_5:func 18
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  let a3 be Element of the Edges of a1 -SliceCat a2;
  redefine func a3 `12 -> Element of Hom a2;
end;

:: CAT_5:th 29
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Element of the Edges of b1 -SliceCat b2 holds
   b3 = [[b3 `11,b3 `12],b3 `2] &
    dom (b3 `12) = cod (b3 `2) &
    b3 `11 = b3 `12 * (b3 `2) &
    dom b3 = b3 `11 &
    cod b3 = b3 `12;

:: CAT_5:th 30
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Element of Hom b2
for b4 being Element of the Vertices of b1 -SliceCat b2
      st b4 = b3
   holds id b4 = [[b4,b4],id dom b3];

:: CAT_5:funcnot 19 => CAT_5:func 19
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  let a3 be Element of the Edges of a2 -SliceCat a1;
  redefine func a3 `2 -> Element of the Edges of a1;
end;

:: CAT_5:funcnot 20 => CAT_5:func 20
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  let a3 be Element of the Edges of a2 -SliceCat a1;
  redefine func a3 `11 -> Element of a2 Hom;
end;

:: CAT_5:funcnot 21 => CAT_5:func 21
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  let a3 be Element of the Edges of a2 -SliceCat a1;
  redefine func a3 `12 -> Element of a2 Hom;
end;

:: CAT_5:th 31
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Element of the Edges of b2 -SliceCat b1 holds
   b3 = [[b3 `11,b3 `12],b3 `2] &
    dom (b3 `2) = cod (b3 `11) &
    b3 `2 * (b3 `11) = b3 `12 &
    dom b3 = b3 `11 &
    cod b3 = b3 `12;

:: CAT_5:th 32
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Element of b2 Hom
for b4 being Element of the Vertices of b2 -SliceCat b1
      st b4 = b3
   holds id b4 = [[b4,b4],id cod b3];

:: CAT_5:funcnot 22 => CAT_5:func 22
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
  func SliceFunctor A2 -> Functor of a1 -SliceCat dom a2,a1 -SliceCat cod a2 means
    for b1 being Element of the Edges of a1 -SliceCat dom a2 holds
       it . b1 = [[a2 * (b1 `11),a2 * (b1 `12)],b1 `2];
end;

:: CAT_5:def 13
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1
for b3 being Functor of b1 -SliceCat dom b2,b1 -SliceCat cod b2 holds
      b3 = SliceFunctor b2
   iff
      for b4 being Element of the Edges of b1 -SliceCat dom b2 holds
         b3 . b4 = [[b2 * (b4 `11),b2 * (b4 `12)],b4 `2];

:: CAT_5:funcnot 23 => CAT_5:func 23
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
  func SliceContraFunctor A2 -> Functor of (cod a2) -SliceCat a1,(dom a2) -SliceCat a1 means
    for b1 being Element of the Edges of (cod a2) -SliceCat a1 holds
       it . b1 = [[b1 `11 * a2,b1 `12 * a2],b1 `2];
end;

:: CAT_5:def 14
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1
for b3 being Functor of (cod b2) -SliceCat b1,(dom b2) -SliceCat b1 holds
      b3 = SliceContraFunctor b2
   iff
      for b4 being Element of the Edges of (cod b2) -SliceCat b1 holds
         b3 . b4 = [[b4 `11 * b2,b4 `12 * b2],b4 `2];

:: CAT_5:th 33
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Edges of b1
      st dom b3 = cod b2
   holds SliceFunctor (b3 * b2) = (SliceFunctor b3) * SliceFunctor b2;

:: CAT_5:th 34
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Edges of b1
      st dom b3 = cod b2
   holds SliceContraFunctor (b3 * b2) = (SliceContraFunctor b2) * SliceContraFunctor b3;