Article CAT_4, MML version 4.99.1005

:: CAT_4:prednot 1 => CAT_1:pred 1
definition
  let a1 be non void Category-like CatStr;
  let a2, a3 be Element of the Vertices of a1;
  pred A2,A3 are_isomorphic means
    Hom(a2,a3) <> {} &
     Hom(a3,a2) <> {} &
     (ex b1 being Morphism of a2,a3 st
        ex b2 being Morphism of a3,a2 st
           b1 * b2 = id a3 & b2 * b1 = id a2);
end;

:: CAT_4:dfs 1
definiens
  let a1 be non void Category-like CatStr;
  let a2, a3 be Element of the Vertices of a1;
To prove
     a2,a3 are_isomorphic
it is sufficient to prove
  thus Hom(a2,a3) <> {} &
     Hom(a3,a2) <> {} &
     (ex b1 being Morphism of a2,a3 st
        ex b2 being Morphism of a3,a2 st
           b1 * b2 = id a3 & b2 * b1 = id a2);

:: CAT_4:def 2
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1 holds
   b2,b3 are_isomorphic
iff
   Hom(b2,b3) <> {} &
    Hom(b3,b2) <> {} &
    (ex b4 being Morphism of b2,b3 st
       ex b5 being Morphism of b3,b2 st
          b4 * b5 = id b3 & b5 * b4 = id b2);

:: CAT_4:attrnot 1 => CAT_4:attr 1
definition
  let a1 be non void Category-like CatStr;
  attr a1 is with_finite_product means
    for b1 being finite set
    for b2 being Function-like quasi_total Relation of b1,the Vertices of a1 holds
       ex b3 being Element of the Vertices of a1 st
          ex b4 being Projections_family of b3,b1 st
             cods b4 = b2 & b3 is_a_product_wrt b4;
end;

:: CAT_4:dfs 2
definiens
  let a1 be non void Category-like CatStr;
To prove
     a1 is with_finite_product
it is sufficient to prove
  thus for b1 being finite set
    for b2 being Function-like quasi_total Relation of b1,the Vertices of a1 holds
       ex b3 being Element of the Vertices of a1 st
          ex b4 being Projections_family of b3,b1 st
             cods b4 = b2 & b3 is_a_product_wrt b4;

:: CAT_4:def 3
theorem
for b1 being non void Category-like CatStr holds
      b1 is with_finite_product
   iff
      for b2 being finite set
      for b3 being Function-like quasi_total Relation of b2,the Vertices of b1 holds
         ex b4 being Element of the Vertices of b1 st
            ex b5 being Projections_family of b4,b2 st
               cods b5 = b3 & b4 is_a_product_wrt b5;

:: CAT_4:prednot 2 => CAT_4:attr 1
notation
  let a1 be non void Category-like CatStr;
  synonym a1 has_finite_product for with_finite_product;
end;

:: CAT_4:th 1
theorem
for b1 being non void Category-like CatStr holds
      b1 is with_finite_product
   iff
      (ex b2 being Element of the Vertices of b1 st
          b2 is terminal(b1)) &
       (for b2, b3 being Element of the Vertices of b1 holds
       ex b4 being Element of the Vertices of b1 st
          ex b5, b6 being Element of the Edges of b1 st
             dom b5 = b4 & dom b6 = b4 & cod b5 = b2 & cod b6 = b3 & b4 is_a_product_wrt b5,b6);

:: CAT_4:structnot 1 => CAT_4:struct 1
definition
  struct(CatStr) ProdCatStr(#
    Vertices -> set,
    Edges -> set,
    Source -> Function-like quasi_total Relation of the Edges of it,the Vertices of it,
    Target -> Function-like quasi_total Relation of the Edges of it,the Vertices of it,
    Comp -> Function-like Relation of [:the Edges of it,the Edges of it:],the Edges of it,
    Id -> Function-like quasi_total Relation of the Vertices of it,the Edges of it,
    TerminalObj -> Element of the Vertices of it,
    CatProd -> Function-like quasi_total Relation of [:the Vertices of it,the Vertices of it:],the Vertices of it,
    Proj1 -> Function-like quasi_total Relation of [:the Vertices of it,the Vertices of it:],the Edges of it,
    Proj2 -> Function-like quasi_total Relation of [:the Vertices of it,the Vertices of it:],the Edges of it
  #);
end;

:: CAT_4:attrnot 2 => CAT_4:attr 2
definition
  let a1 be ProdCatStr;
  attr a1 is strict;
end;

:: CAT_4:exreg 1
registration
  cluster strict ProdCatStr;
end;

:: CAT_4:aggrnot 1 => CAT_4:aggr 1
definition
  let a1, a2 be set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Function-like Relation of [:a2,a2:],a2;
  let a6 be Function-like quasi_total Relation of a1,a2;
  let a7 be Element of a1;
  let a8 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a9, a10 be Function-like quasi_total Relation of [:a1,a1:],a2;
  aggr ProdCatStr(#a1,a2,a3,a4,a5,a6,a7,a8,a9,a10#) -> strict ProdCatStr;
end;

:: CAT_4:selnot 1 => CAT_4:sel 1
definition
  let a1 be ProdCatStr;
  sel the TerminalObj of a1 -> Element of the Vertices of a1;
end;

:: CAT_4:selnot 2 => CAT_4:sel 2
definition
  let a1 be ProdCatStr;
  sel the CatProd of a1 -> Function-like quasi_total Relation of [:the Vertices of a1,the Vertices of a1:],the Vertices of a1;
end;

:: CAT_4:selnot 3 => CAT_4:sel 3
definition
  let a1 be ProdCatStr;
  sel the Proj1 of a1 -> Function-like quasi_total Relation of [:the Vertices of a1,the Vertices of a1:],the Edges of a1;
end;

:: CAT_4:selnot 4 => CAT_4:sel 4
definition
  let a1 be ProdCatStr;
  sel the Proj2 of a1 -> Function-like quasi_total Relation of [:the Vertices of a1,the Vertices of a1:],the Edges of a1;
end;

:: CAT_4:exreg 2
registration
  cluster non void ProdCatStr;
end;

:: CAT_4:funcnot 1 => CAT_4:func 1
definition
  let a1 be non void ProdCatStr;
  func [1] A1 -> Element of the Vertices of a1 equals
    the TerminalObj of a1;
end;

:: CAT_4:def 4
theorem
for b1 being non void ProdCatStr holds
   [1] b1 = the TerminalObj of b1;

:: CAT_4:funcnot 2 => CAT_4:func 2
definition
  let a1 be non void ProdCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func A2 [x] A3 -> Element of the Vertices of a1 equals
    (the CatProd of a1) .(a2,a3);
end;

:: CAT_4:def 5
theorem
for b1 being non void ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
b2 [x] b3 = (the CatProd of b1) .(b2,b3);

:: CAT_4:funcnot 3 => CAT_4:func 3
definition
  let a1 be non void ProdCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func pr1(A2,A3) -> Element of the Edges of a1 equals
    (the Proj1 of a1) .(a2,a3);
end;

:: CAT_4:def 6
theorem
for b1 being non void ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
pr1(b2,b3) = (the Proj1 of b1) .(b2,b3);

:: CAT_4:funcnot 4 => CAT_4:func 4
definition
  let a1 be non void ProdCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func pr2(A2,A3) -> Element of the Edges of a1 equals
    (the Proj2 of a1) .(a2,a3);
end;

:: CAT_4:def 7
theorem
for b1 being non void ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
pr2(b2,b3) = (the Proj2 of b1) .(b2,b3);

:: CAT_4:funcnot 5 => CAT_4:func 5
definition
  let a1, a2 be set;
  func c1Cat(A1,A2) -> strict ProdCatStr equals
    ProdCatStr(#{a1},{a2},{a2} --> a1,{a2} --> a1,(a2,a2).--> a2,{a1} --> a2,Extract a1,(a1,a1):-> a1,(a1,a1):-> a2,(a1,a1):-> a2#);
end;

:: CAT_4:def 8
theorem
for b1, b2 being set holds
c1Cat(b1,b2) = ProdCatStr(#{b1},{b2},{b2} --> b1,{b2} --> b1,(b2,b2).--> b2,{b1} --> b2,Extract b1,(b1,b1):-> b1,(b1,b1):-> b2,(b1,b1):-> b2#);

:: CAT_4:funcreg 1
registration
  let a1, a2 be set;
  cluster c1Cat(a1,a2) -> non void strict;
end;

:: CAT_4:th 2
theorem
for b1, b2 being set holds
CatStr(#the Vertices of c1Cat(b1,b2),the Edges of c1Cat(b1,b2),the Source of c1Cat(b1,b2),the Target of c1Cat(b1,b2),the Comp of c1Cat(b1,b2),the Id of c1Cat(b1,b2)#) = 1Cat(b1,b2);

:: CAT_4:exreg 3
registration
  cluster non void Category-like strict ProdCatStr;
end;

:: CAT_4:funcreg 2
registration
  let a1, a2 be set;
  cluster c1Cat(a1,a2) -> Category-like strict;
end;

:: CAT_4:th 4
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat(b1,b2) holds
b3 = b4;

:: CAT_4:th 6
theorem
for b1, b2 being set
for b3, b4 being Element of the Edges of c1Cat(b1,b2) holds
b3 = b4;

:: CAT_4:th 7
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat(b1,b2)
for b5 being Element of the Edges of c1Cat(b1,b2) holds
   b5 in Hom(b3,b4);

:: CAT_4:th 8
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat(b1,b2)
for b5 being Element of the Edges of c1Cat(b1,b2) holds
   b5 is Morphism of b3,b4;

:: CAT_4:th 9
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat(b1,b2) holds
Hom(b3,b4) <> {};

:: CAT_4:th 10
theorem
for b1, b2 being set
for b3 being Element of the Vertices of c1Cat(b1,b2) holds
   b3 is terminal(c1Cat(b1,b2));

:: CAT_4:th 11
theorem
for b1, b2 being set
for b3 being Element of the Vertices of c1Cat(b1,b2)
for b4, b5 being Element of the Edges of c1Cat(b1,b2) holds
b3 is_a_product_wrt b4,b5;

:: CAT_4:attrnot 3 => CAT_4:attr 3
definition
  let a1 be non void Category-like ProdCatStr;
  attr a1 is Cartesian means
    the TerminalObj of a1 is terminal(a1) &
     (for b1, b2 being Element of the Vertices of a1 holds
     cod ((the Proj1 of a1) .(b1,b2)) = b1 &
      cod ((the Proj2 of a1) .(b1,b2)) = b2 &
      (the CatProd of a1) .(b1,b2) is_a_product_wrt (the Proj1 of a1) .(b1,b2),(the Proj2 of a1) .(b1,b2));
end;

:: CAT_4:dfs 8
definiens
  let a1 be non void Category-like ProdCatStr;
To prove
     a1 is Cartesian
it is sufficient to prove
  thus the TerminalObj of a1 is terminal(a1) &
     (for b1, b2 being Element of the Vertices of a1 holds
     cod ((the Proj1 of a1) .(b1,b2)) = b1 &
      cod ((the Proj2 of a1) .(b1,b2)) = b2 &
      (the CatProd of a1) .(b1,b2) is_a_product_wrt (the Proj1 of a1) .(b1,b2),(the Proj2 of a1) .(b1,b2));

:: CAT_4:def 9
theorem
for b1 being non void Category-like ProdCatStr holds
      b1 is Cartesian
   iff
      the TerminalObj of b1 is terminal(b1) &
       (for b2, b3 being Element of the Vertices of b1 holds
       cod ((the Proj1 of b1) .(b2,b3)) = b2 &
        cod ((the Proj2 of b1) .(b2,b3)) = b3 &
        (the CatProd of b1) .(b2,b3) is_a_product_wrt (the Proj1 of b1) .(b2,b3),(the Proj2 of b1) .(b2,b3));

:: CAT_4:th 12
theorem
for b1, b2 being set holds
c1Cat(b1,b2) is Cartesian;

:: CAT_4:exreg 4
registration
  cluster non void Category-like strict Cartesian ProdCatStr;
end;

:: CAT_4:modenot 1
definition
  mode Cartesian_category is non void Category-like Cartesian ProdCatStr;
end;

:: CAT_4:th 13
theorem
for b1 being non void Category-like Cartesian ProdCatStr holds
   [1] b1 is terminal(b1);

:: CAT_4:th 14
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1
for b3, b4 being Morphism of b2,[1] b1 holds
b3 = b4;

:: CAT_4:th 15
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   Hom(b2,[1] b1) <> {};

:: CAT_4:funcnot 6 => CAT_4:func 6
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2 be Element of the Vertices of a1;
  func term A2 -> Morphism of a2,[1] a1 means
    TRUE;
end;

:: CAT_4:def 10
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1
for b3 being Morphism of b2,[1] b1 holds
   (b3 = term b2 implies TRUE) & b3 = term b2;

:: CAT_4:th 16
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   term b2 = term(b2,[1] b1);

:: CAT_4:th 17
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   dom term b2 = b2 & cod term b2 = [1] b1;

:: CAT_4:th 18
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   Hom(b2,[1] b1) = {term b2};

:: CAT_4:th 19
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
dom pr1(b2,b3) = b2 [x] b3 & cod pr1(b2,b3) = b2;

:: CAT_4:th 20
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
dom pr2(b2,b3) = b2 [x] b3 & cod pr2(b2,b3) = b3;

:: CAT_4:funcnot 7 => CAT_4:func 7
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3 be Element of the Vertices of a1;
  redefine func pr1(a2,a3) -> Morphism of a2 [x] a3,a2;
end;

:: CAT_4:funcnot 8 => CAT_4:func 8
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3 be Element of the Vertices of a1;
  redefine func pr2(a2,a3) -> Morphism of a2 [x] a3,a3;
end;

:: CAT_4:th 21
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
Hom(b2 [x] b3,b2) <> {} & Hom(b2 [x] b3,b3) <> {};

:: CAT_4:th 22
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
b2 [x] b3 is_a_product_wrt pr1(b2,b3),pr2(b2,b3);

:: CAT_4:th 23
theorem
for b1 being non void Category-like Cartesian ProdCatStr holds
   b1 is with_finite_product;

:: CAT_4:th 24
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b3,b2) <> {}
   holds pr1(b2,b3) is retraction(b1) & pr2(b2,b3) is retraction(b1);

:: CAT_4:funcnot 9 => CAT_4:func 9
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3, a4 be Element of the Vertices of a1;
  let a5 be Morphism of a4,a2;
  let a6 be Morphism of a4,a3;
  assume Hom(a4,a2) <> {} & Hom(a4,a3) <> {};
  func <:A5,A6:> -> Morphism of a4,a2 [x] a3 means
    (pr1(a2,a3)) * it = a5 & (pr2(a2,a3)) * it = a6;
end;

:: CAT_4:def 11
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b4,b2
for b6 being Morphism of b4,b3
   st Hom(b4,b2) <> {} & Hom(b4,b3) <> {}
for b7 being Morphism of b4,b2 [x] b3 holds
      b7 = <:b5,b6:>
   iff
      (pr1(b2,b3)) * b7 = b5 & (pr2(b2,b3)) * b7 = b6;

:: CAT_4:th 25
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b2,b4) <> {}
   holds Hom(b2,b3 [x] b4) <> {};

:: CAT_4:th 26
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
<:pr1(b2,b3),pr2(b2,b3):> = id (b2 [x] b3);

:: CAT_4:th 27
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
for b6 being Morphism of b2,b3
for b7 being Morphism of b2,b4
for b8 being Morphism of b5,b2
      st Hom(b2,b3) <> {} & Hom(b2,b4) <> {} & Hom(b5,b2) <> {}
   holds <:b6 * b8,b7 * b8:> = <:b6,b7:> * b8;

:: CAT_4:th 28
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5, b6 being Morphism of b2,b3
for b7, b8 being Morphism of b2,b4
      st Hom(b2,b3) <> {} & Hom(b2,b4) <> {} & <:b5,b7:> = <:b6,b8:>
   holds b5 = b6 & b7 = b8;

:: CAT_4:th 29
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b2,b4
      st Hom(b2,b3) <> {} & Hom(b2,b4) <> {} & (b5 is monic(b1) or b6 is monic(b1))
   holds <:b5,b6:> is monic(b1);

:: CAT_4:th 30
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   Hom(b2,b2 [x] [1] b1) <> {} & Hom(b2,([1] b1) [x] b2) <> {};

:: CAT_4:funcnot 10 => CAT_4:func 10
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2 be Element of the Vertices of a1;
  func lambda A2 -> Morphism of ([1] a1) [x] a2,a2 equals
    pr2([1] a1,a2);
end;

:: CAT_4:def 12
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   lambda b2 = pr2([1] b1,b2);

:: CAT_4:funcnot 11 => CAT_4:func 11
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2 be Element of the Vertices of a1;
  func lambda' A2 -> Morphism of a2,([1] a1) [x] a2 equals
    <:term a2,id a2:>;
end;

:: CAT_4:def 13
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   lambda' b2 = <:term b2,id b2:>;

:: CAT_4:funcnot 12 => CAT_4:func 12
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2 be Element of the Vertices of a1;
  func rho A2 -> Morphism of a2 [x] [1] a1,a2 equals
    pr1(a2,[1] a1);
end;

:: CAT_4:def 14
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   rho b2 = pr1(b2,[1] b1);

:: CAT_4:funcnot 13 => CAT_4:func 13
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2 be Element of the Vertices of a1;
  func rho' A2 -> Morphism of a2,a2 [x] [1] a1 equals
    <:id a2,term a2:>;
end;

:: CAT_4:def 15
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   rho' b2 = <:id b2,term b2:>;

:: CAT_4:th 31
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   (lambda b2) * lambda' b2 = id b2 &
    (lambda' b2) * lambda b2 = id (([1] b1) [x] b2) &
    (rho b2) * rho' b2 = id b2 &
    (rho' b2) * rho b2 = id (b2 [x] [1] b1);

:: CAT_4:th 32
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   b2,b2 [x] [1] b1 are_isomorphic & b2,([1] b1) [x] b2 are_isomorphic;

:: CAT_4:funcnot 14 => CAT_4:func 14
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func Switch(A2,A3) -> Morphism of a2 [x] a3,a3 [x] a2 equals
    <:pr2(a2,a3),pr1(a2,a3):>;
end;

:: CAT_4:def 16
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
Switch(b2,b3) = <:pr2(b2,b3),pr1(b2,b3):>;

:: CAT_4:th 33
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
Hom(b2 [x] b3,b3 [x] b2) <> {};

:: CAT_4:th 34
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
(Switch(b2,b3)) * Switch(b3,b2) = id (b3 [x] b2);

:: CAT_4:th 35
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
b2 [x] b3,b3 [x] b2 are_isomorphic;

:: CAT_4:funcnot 15 => CAT_4:func 15
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2 be Element of the Vertices of a1;
  func Delta A2 -> Morphism of a2,a2 [x] a2 equals
    <:id a2,id a2:>;
end;

:: CAT_4:def 17
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   Delta b2 = <:id b2,id b2:>;

:: CAT_4:th 36
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2 being Element of the Vertices of b1 holds
   Hom(b2,b2 [x] b2) <> {};

:: CAT_4:th 37
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {}
   holds <:b4,b4:> = (Delta b3) * b4;

:: CAT_4:funcnot 16 => CAT_4:func 16
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3, a4 be Element of the Vertices of a1;
  func Alpha(A2,A3,A4) -> Morphism of (a2 [x] a3) [x] a4,a2 [x] (a3 [x] a4) equals
    <:(pr1(a2,a3)) * pr1(a2 [x] a3,a4),<:(pr2(a2,a3)) * pr1(a2 [x] a3,a4),pr2(a2 [x] a3,a4):>:>;
end;

:: CAT_4:def 18
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1 holds
Alpha(b2,b3,b4) = <:(pr1(b2,b3)) * pr1(b2 [x] b3,b4),<:(pr2(b2,b3)) * pr1(b2 [x] b3,b4),pr2(b2 [x] b3,b4):>:>;

:: CAT_4:funcnot 17 => CAT_4:func 17
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3, a4 be Element of the Vertices of a1;
  func Alpha'(A2,A3,A4) -> Morphism of a2 [x] (a3 [x] a4),(a2 [x] a3) [x] a4 equals
    <:<:pr1(a2,a3 [x] a4),(pr1(a3,a4)) * pr2(a2,a3 [x] a4):>,(pr2(a3,a4)) * pr2(a2,a3 [x] a4):>;
end;

:: CAT_4:def 19
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1 holds
Alpha'(b2,b3,b4) = <:<:pr1(b2,b3 [x] b4),(pr1(b3,b4)) * pr2(b2,b3 [x] b4):>,(pr2(b3,b4)) * pr2(b2,b3 [x] b4):>;

:: CAT_4:th 38
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1 holds
Hom((b2 [x] b3) [x] b4,b2 [x] (b3 [x] b4)) <> {} &
 Hom(b2 [x] (b3 [x] b4),(b2 [x] b3) [x] b4) <> {};

:: CAT_4:th 39
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1 holds
(Alpha(b2,b3,b4)) * Alpha'(b2,b3,b4) = id (b2 [x] (b3 [x] b4)) &
 (Alpha'(b2,b3,b4)) * Alpha(b2,b3,b4) = id ((b2 [x] b3) [x] b4);

:: CAT_4:th 40
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1 holds
(b2 [x] b3) [x] b4,b2 [x] (b3 [x] b4) are_isomorphic;

:: CAT_4:funcnot 18 => CAT_4:func 18
definition
  let a1 be non void Category-like Cartesian ProdCatStr;
  let a2, a3, a4, a5 be Element of the Vertices of a1;
  let a6 be Morphism of a2,a3;
  let a7 be Morphism of a4,a5;
  func A6 [x] A7 -> Morphism of a2 [x] a4,a3 [x] a5 equals
    <:a6 * pr1(a2,a4),a7 * pr2(a2,a4):>;
end;

:: CAT_4:def 20
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
for b6 being Morphism of b2,b3
for b7 being Morphism of b4,b5 holds
   b6 [x] b7 = <:b6 * pr1(b2,b4),b7 * pr2(b2,b4):>;

:: CAT_4:th 41
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {}
   holds Hom(b2 [x] b4,b3 [x] b5) <> {};

:: CAT_4:th 42
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3 being Element of the Vertices of b1 holds
(id b2) [x] id b3 = id (b2 [x] b3);

:: CAT_4:th 43
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4, b5, b6 being Element of the Vertices of b1
for b7 being Morphism of b2,b3
for b8 being Morphism of b4,b5
for b9 being Morphism of b6,b2
for b10 being Morphism of b6,b4
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {} & Hom(b6,b2) <> {} & Hom(b6,b4) <> {}
   holds (b7 [x] b8) * <:b9,b10:> = <:b7 * b9,b8 * b10:>;

:: CAT_4:th 44
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b2,b4
      st Hom(b2,b3) <> {} & Hom(b2,b4) <> {}
   holds <:b5,b6:> = (b5 [x] b6) * Delta b2;

:: CAT_4:th 45
theorem
for b1 being non void Category-like Cartesian ProdCatStr
for b2, b3, b4, b5, b6, b7 being Element of the Vertices of b1
for b8 being Morphism of b2,b3
for b9 being Morphism of b4,b5
for b10 being Morphism of b6,b2
for b11 being Morphism of b7,b4
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {} & Hom(b6,b2) <> {} & Hom(b7,b4) <> {}
   holds (b8 [x] b9) * (b10 [x] b11) = (b8 * b10) [x] (b9 * b11);

:: CAT_4:attrnot 4 => CAT_4:attr 4
definition
  let a1 be non void Category-like CatStr;
  attr a1 is with_finite_coproduct means
    for b1 being finite set
    for b2 being Function-like quasi_total Relation of b1,the Vertices of a1 holds
       ex b3 being Element of the Vertices of a1 st
          ex b4 being Injections_family of b3,b1 st
             doms b4 = b2 & b3 is_a_coproduct_wrt b4;
end;

:: CAT_4:dfs 20
definiens
  let a1 be non void Category-like CatStr;
To prove
     a1 is with_finite_coproduct
it is sufficient to prove
  thus for b1 being finite set
    for b2 being Function-like quasi_total Relation of b1,the Vertices of a1 holds
       ex b3 being Element of the Vertices of a1 st
          ex b4 being Injections_family of b3,b1 st
             doms b4 = b2 & b3 is_a_coproduct_wrt b4;

:: CAT_4:def 21
theorem
for b1 being non void Category-like CatStr holds
      b1 is with_finite_coproduct
   iff
      for b2 being finite set
      for b3 being Function-like quasi_total Relation of b2,the Vertices of b1 holds
         ex b4 being Element of the Vertices of b1 st
            ex b5 being Injections_family of b4,b2 st
               doms b5 = b3 & b4 is_a_coproduct_wrt b5;

:: CAT_4:prednot 3 => CAT_4:attr 4
notation
  let a1 be non void Category-like CatStr;
  synonym a1 has_finite_coproduct for with_finite_coproduct;
end;

:: CAT_4:th 46
theorem
for b1 being non void Category-like CatStr holds
      b1 is with_finite_coproduct
   iff
      (ex b2 being Element of the Vertices of b1 st
          b2 is initial(b1)) &
       (for b2, b3 being Element of the Vertices of b1 holds
       ex b4 being Element of the Vertices of b1 st
          ex b5, b6 being Element of the Edges of b1 st
             dom b5 = b2 & dom b6 = b3 & cod b5 = b4 & cod b6 = b4 & b4 is_a_coproduct_wrt b5,b6);

:: CAT_4:structnot 2 => CAT_4:struct 2
definition
  struct(CatStr) CoprodCatStr(#
    Vertices -> set,
    Edges -> set,
    Source -> Function-like quasi_total Relation of the Edges of it,the Vertices of it,
    Target -> Function-like quasi_total Relation of the Edges of it,the Vertices of it,
    Comp -> Function-like Relation of [:the Edges of it,the Edges of it:],the Edges of it,
    Id -> Function-like quasi_total Relation of the Vertices of it,the Edges of it,
    Initial -> Element of the Vertices of it,
    Coproduct -> Function-like quasi_total Relation of [:the Vertices of it,the Vertices of it:],the Vertices of it,
    Incl1 -> Function-like quasi_total Relation of [:the Vertices of it,the Vertices of it:],the Edges of it,
    Incl2 -> Function-like quasi_total Relation of [:the Vertices of it,the Vertices of it:],the Edges of it
  #);
end;

:: CAT_4:attrnot 5 => CAT_4:attr 5
definition
  let a1 be CoprodCatStr;
  attr a1 is strict;
end;

:: CAT_4:exreg 5
registration
  cluster strict CoprodCatStr;
end;

:: CAT_4:aggrnot 2 => CAT_4:aggr 2
definition
  let a1, a2 be set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Function-like Relation of [:a2,a2:],a2;
  let a6 be Function-like quasi_total Relation of a1,a2;
  let a7 be Element of a1;
  let a8 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a9, a10 be Function-like quasi_total Relation of [:a1,a1:],a2;
  aggr CoprodCatStr(#a1,a2,a3,a4,a5,a6,a7,a8,a9,a10#) -> strict CoprodCatStr;
end;

:: CAT_4:selnot 5 => CAT_4:sel 5
definition
  let a1 be CoprodCatStr;
  sel the Initial of a1 -> Element of the Vertices of a1;
end;

:: CAT_4:selnot 6 => CAT_4:sel 6
definition
  let a1 be CoprodCatStr;
  sel the Coproduct of a1 -> Function-like quasi_total Relation of [:the Vertices of a1,the Vertices of a1:],the Vertices of a1;
end;

:: CAT_4:selnot 7 => CAT_4:sel 7
definition
  let a1 be CoprodCatStr;
  sel the Incl1 of a1 -> Function-like quasi_total Relation of [:the Vertices of a1,the Vertices of a1:],the Edges of a1;
end;

:: CAT_4:selnot 8 => CAT_4:sel 8
definition
  let a1 be CoprodCatStr;
  sel the Incl2 of a1 -> Function-like quasi_total Relation of [:the Vertices of a1,the Vertices of a1:],the Edges of a1;
end;

:: CAT_4:exreg 6
registration
  cluster non void CoprodCatStr;
end;

:: CAT_4:funcnot 19 => CAT_4:func 19
definition
  let a1 be non void CoprodCatStr;
  func [0] A1 -> Element of the Vertices of a1 equals
    the Initial of a1;
end;

:: CAT_4:def 22
theorem
for b1 being non void CoprodCatStr holds
   [0] b1 = the Initial of b1;

:: CAT_4:funcnot 20 => CAT_4:func 20
definition
  let a1 be non void CoprodCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func A2 + A3 -> Element of the Vertices of a1 equals
    (the Coproduct of a1) .(a2,a3);
end;

:: CAT_4:def 23
theorem
for b1 being non void CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
b2 + b3 = (the Coproduct of b1) .(b2,b3);

:: CAT_4:funcnot 21 => CAT_4:func 21
definition
  let a1 be non void CoprodCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func in1(A2,A3) -> Element of the Edges of a1 equals
    (the Incl1 of a1) .(a2,a3);
end;

:: CAT_4:def 24
theorem
for b1 being non void CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
in1(b2,b3) = (the Incl1 of b1) .(b2,b3);

:: CAT_4:funcnot 22 => CAT_4:func 22
definition
  let a1 be non void CoprodCatStr;
  let a2, a3 be Element of the Vertices of a1;
  func in2(A2,A3) -> Element of the Edges of a1 equals
    (the Incl2 of a1) .(a2,a3);
end;

:: CAT_4:def 25
theorem
for b1 being non void CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
in2(b2,b3) = (the Incl2 of b1) .(b2,b3);

:: CAT_4:funcnot 23 => CAT_4:func 23
definition
  let a1, a2 be set;
  func c1Cat*(A1,A2) -> strict CoprodCatStr equals
    CoprodCatStr(#{a1},{a2},{a2} --> a1,{a2} --> a1,(a2,a2).--> a2,{a1} --> a2,Extract a1,(a1,a1):-> a1,(a1,a1):-> a2,(a1,a1):-> a2#);
end;

:: CAT_4:def 26
theorem
for b1, b2 being set holds
c1Cat*(b1,b2) = CoprodCatStr(#{b1},{b2},{b2} --> b1,{b2} --> b1,(b2,b2).--> b2,{b1} --> b2,Extract b1,(b1,b1):-> b1,(b1,b1):-> b2,(b1,b1):-> b2#);

:: CAT_4:th 47
theorem
for b1, b2 being set holds
CatStr(#the Vertices of c1Cat*(b1,b2),the Edges of c1Cat*(b1,b2),the Source of c1Cat*(b1,b2),the Target of c1Cat*(b1,b2),the Comp of c1Cat*(b1,b2),the Id of c1Cat*(b1,b2)#) = 1Cat(b1,b2);

:: CAT_4:funcreg 3
registration
  let a1, a2 be set;
  cluster c1Cat*(a1,a2) -> non void strict;
end;

:: CAT_4:exreg 7
registration
  cluster non void Category-like strict CoprodCatStr;
end;

:: CAT_4:funcreg 4
registration
  let a1, a2 be set;
  cluster c1Cat*(a1,a2) -> non void Category-like strict;
end;

:: CAT_4:th 49
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat*(b1,b2) holds
b3 = b4;

:: CAT_4:th 51
theorem
for b1, b2 being set
for b3, b4 being Element of the Edges of c1Cat*(b1,b2) holds
b3 = b4;

:: CAT_4:th 52
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat*(b1,b2)
for b5 being Element of the Edges of c1Cat*(b1,b2) holds
   b5 in Hom(b3,b4);

:: CAT_4:th 53
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat*(b1,b2)
for b5 being Element of the Edges of c1Cat*(b1,b2) holds
   b5 is Morphism of b3,b4;

:: CAT_4:th 54
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of c1Cat*(b1,b2) holds
Hom(b3,b4) <> {};

:: CAT_4:th 55
theorem
for b1, b2 being set
for b3 being Element of the Vertices of c1Cat*(b1,b2) holds
   b3 is initial(c1Cat*(b1,b2));

:: CAT_4:th 56
theorem
for b1, b2 being set
for b3 being Element of the Vertices of c1Cat*(b1,b2)
for b4, b5 being Element of the Edges of c1Cat*(b1,b2) holds
b3 is_a_coproduct_wrt b4,b5;

:: CAT_4:attrnot 6 => CAT_4:attr 6
definition
  let a1 be non void Category-like CoprodCatStr;
  attr a1 is Cocartesian means
    the Initial of a1 is initial(a1) &
     (for b1, b2 being Element of the Vertices of a1 holds
     dom ((the Incl1 of a1) .(b1,b2)) = b1 &
      dom ((the Incl2 of a1) .(b1,b2)) = b2 &
      (the Coproduct of a1) .(b1,b2) is_a_coproduct_wrt (the Incl1 of a1) .(b1,b2),(the Incl2 of a1) .(b1,b2));
end;

:: CAT_4:dfs 26
definiens
  let a1 be non void Category-like CoprodCatStr;
To prove
     a1 is Cocartesian
it is sufficient to prove
  thus the Initial of a1 is initial(a1) &
     (for b1, b2 being Element of the Vertices of a1 holds
     dom ((the Incl1 of a1) .(b1,b2)) = b1 &
      dom ((the Incl2 of a1) .(b1,b2)) = b2 &
      (the Coproduct of a1) .(b1,b2) is_a_coproduct_wrt (the Incl1 of a1) .(b1,b2),(the Incl2 of a1) .(b1,b2));

:: CAT_4:def 27
theorem
for b1 being non void Category-like CoprodCatStr holds
      b1 is Cocartesian
   iff
      the Initial of b1 is initial(b1) &
       (for b2, b3 being Element of the Vertices of b1 holds
       dom ((the Incl1 of b1) .(b2,b3)) = b2 &
        dom ((the Incl2 of b1) .(b2,b3)) = b3 &
        (the Coproduct of b1) .(b2,b3) is_a_coproduct_wrt (the Incl1 of b1) .(b2,b3),(the Incl2 of b1) .(b2,b3));

:: CAT_4:th 57
theorem
for b1, b2 being set holds
c1Cat*(b1,b2) is Cocartesian;

:: CAT_4:exreg 8
registration
  cluster non void Category-like strict Cocartesian CoprodCatStr;
end;

:: CAT_4:modenot 2
definition
  mode Cocartesian_category is non void Category-like Cocartesian CoprodCatStr;
end;

:: CAT_4:th 58
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr holds
   [0] b1 is initial(b1);

:: CAT_4:th 59
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1
for b3, b4 being Morphism of [0] b1,b2 holds
b3 = b4;

:: CAT_4:funcnot 24 => CAT_4:func 24
definition
  let a1 be non void Category-like Cocartesian CoprodCatStr;
  let a2 be Element of the Vertices of a1;
  func init A2 -> Morphism of [0] a1,a2 means
    TRUE;
end;

:: CAT_4:def 28
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1
for b3 being Morphism of [0] b1,b2 holds
   (b3 = init b2 implies TRUE) & b3 = init b2;

:: CAT_4:th 60
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1 holds
   Hom([0] b1,b2) <> {};

:: CAT_4:th 61
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1 holds
   init b2 = init([0] b1,b2);

:: CAT_4:th 62
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1 holds
   dom init b2 = [0] b1 & cod init b2 = b2;

:: CAT_4:th 63
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1 holds
   Hom([0] b1,b2) = {init b2};

:: CAT_4:th 64
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
dom in1(b2,b3) = b2 & cod in1(b2,b3) = b2 + b3;

:: CAT_4:th 65
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
dom in2(b2,b3) = b3 & cod in2(b2,b3) = b2 + b3;

:: CAT_4:th 66
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
Hom(b2,b2 + b3) <> {} & Hom(b3,b2 + b3) <> {};

:: CAT_4:th 67
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
b2 + b3 is_a_coproduct_wrt in1(b2,b3),in2(b2,b3);

:: CAT_4:th 68
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr holds
   b1 is with_finite_coproduct;

:: CAT_4:th 69
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b3,b2) <> {}
   holds in1(b2,b3) is coretraction(b1) & in2(b2,b3) is coretraction(b1);

:: CAT_4:funcnot 25 => CAT_4:func 25
definition
  let a1 be non void Category-like Cocartesian CoprodCatStr;
  let a2, a3 be Element of the Vertices of a1;
  redefine func in1(a2,a3) -> Morphism of a2,a2 + a3;
end;

:: CAT_4:funcnot 26 => CAT_4:func 26
definition
  let a1 be non void Category-like Cocartesian CoprodCatStr;
  let a2, a3 be Element of the Vertices of a1;
  redefine func in2(a2,a3) -> Morphism of a3,a2 + a3;
end;

:: CAT_4:funcnot 27 => CAT_4:func 27
definition
  let a1 be non void Category-like Cocartesian CoprodCatStr;
  let a2, a3, a4 be Element of the Vertices of a1;
  let a5 be Morphism of a2,a4;
  let a6 be Morphism of a3,a4;
  assume Hom(a2,a4) <> {} & Hom(a3,a4) <> {};
  func [$A5,A6$] -> Morphism of a2 + a3,a4 means
    it * in1(a2,a3) = a5 & it * in2(a2,a3) = a6;
end;

:: CAT_4:def 29
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b4
for b6 being Morphism of b3,b4
   st Hom(b2,b4) <> {} & Hom(b3,b4) <> {}
for b7 being Morphism of b2 + b3,b4 holds
      b7 = [$b5,b6$]
   iff
      b7 * in1(b2,b3) = b5 & b7 * in2(b2,b3) = b6;

:: CAT_4:th 70
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b4,b3) <> {}
   holds Hom(b2 + b4,b3) <> {};

:: CAT_4:th 71
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
[$in1(b2,b3),in2(b2,b3)$] = id (b2 + b3);

:: CAT_4:th 72
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
for b6 being Morphism of b2,b3
for b7 being Morphism of b4,b3
for b8 being Morphism of b3,b5
      st Hom(b2,b3) <> {} & Hom(b4,b3) <> {} & Hom(b3,b5) <> {}
   holds [$b8 * b6,b8 * b7$] = b8 * [$b6,b7$];

:: CAT_4:th 73
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5, b6 being Morphism of b2,b3
for b7, b8 being Morphism of b4,b3
      st Hom(b2,b3) <> {} & Hom(b4,b3) <> {} & [$b5,b7$] = [$b6,b8$]
   holds b5 = b6 & b7 = b8;

:: CAT_4:th 74
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b4,b3
      st Hom(b2,b3) <> {} & Hom(b4,b3) <> {} & (b5 is epi(b1) or b6 is epi(b1))
   holds [$b5,b6$] is epi(b1);

:: CAT_4:th 75
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1 holds
   b2,b2 + [0] b1 are_isomorphic & b2,([0] b1) + b2 are_isomorphic;

:: CAT_4:th 76
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
b2 + b3,b3 + b2 are_isomorphic;

:: CAT_4:th 77
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4 being Element of the Vertices of b1 holds
(b2 + b3) + b4,b2 + (b3 + b4) are_isomorphic;

:: CAT_4:funcnot 28 => CAT_4:func 28
definition
  let a1 be non void Category-like Cocartesian CoprodCatStr;
  let a2 be Element of the Vertices of a1;
  func nabla A2 -> Morphism of a2 + a2,a2 equals
    [$id a2,id a2$];
end;

:: CAT_4:def 30
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2 being Element of the Vertices of b1 holds
   nabla b2 = [$id b2,id b2$];

:: CAT_4:funcnot 29 => CAT_4:func 29
definition
  let a1 be non void Category-like Cocartesian CoprodCatStr;
  let a2, a3, a4, a5 be Element of the Vertices of a1;
  let a6 be Morphism of a2,a4;
  let a7 be Morphism of a3,a5;
  func A6 + A7 -> Morphism of a2 + a3,a4 + a5 equals
    [$(in1(a4,a5)) * a6,(in2(a4,a5)) * a7$];
end;

:: CAT_4:def 31
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
for b6 being Morphism of b2,b4
for b7 being Morphism of b3,b5 holds
   b6 + b7 = [$(in1(b4,b5)) * b6,(in2(b4,b5)) * b7$];

:: CAT_4:th 78
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {}
   holds Hom(b2 + b4,b3 + b5) <> {};

:: CAT_4:th 79
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3 being Element of the Vertices of b1 holds
(id b2) + id b3 = id (b2 + b3);

:: CAT_4:th 80
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4, b5, b6 being Element of the Vertices of b1
for b7 being Morphism of b2,b3
for b8 being Morphism of b4,b5
for b9 being Morphism of b3,b6
for b10 being Morphism of b5,b6
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {} & Hom(b3,b6) <> {} & Hom(b5,b6) <> {}
   holds [$b9,b10$] * (b7 + b8) = [$b9 * b7,b10 * b8$];

:: CAT_4:th 81
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b4,b3
      st Hom(b2,b3) <> {} & Hom(b4,b3) <> {}
   holds (nabla b3) * (b5 + b6) = [$b5,b6$];

:: CAT_4:th 82
theorem
for b1 being non void Category-like Cocartesian CoprodCatStr
for b2, b3, b4, b5, b6, b7 being Element of the Vertices of b1
for b8 being Morphism of b2,b3
for b9 being Morphism of b4,b5
for b10 being Morphism of b3,b6
for b11 being Morphism of b5,b7
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {} & Hom(b3,b6) <> {} & Hom(b5,b7) <> {}
   holds (b10 + b11) * (b8 + b9) = (b10 * b8) + (b11 * b9);