Article CAT_1, MML version 4.99.1005

:: CAT_1:th 4
theorem
for b1, b2, b3 being set
for b4 being non empty set
for b5 being Function-like quasi_total Relation of b1,b4
      st b2 c= b1 & b5 .: b2 c= b3
   holds b5 | b2 is Function-like quasi_total Relation of b2,b3;

:: CAT_1:funcnot 1 => CAT_1:func 1
definition
  let a1, a2, a3 be set;
  redefine func (a1,a2).--> a3 -> Function-like Relation of [:{a1},{a2}:],{a3};
end;

:: CAT_1:th 7
theorem
for b1, b2, b3 being set holds
proj1 ((b1,b2).--> b3) = [:{b1},{b2}:];

:: CAT_1:th 8
theorem
for b1, b2, b3 being set holds
((b1,b2).--> b3) .(b1,b2) = b3;

:: CAT_1:th 9
theorem
for b1, b2, b3 being set
for b4 being Element of {b1}
for b5 being Element of {b2} holds
   ((b1,b2).--> b3) .(b4,b5) = b3;

:: CAT_1:structnot 1 => CAT_1:struct 1
definition
  struct(MultiGraphStruct) CatStr(#
    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
  #);
end;

:: CAT_1:attrnot 1 => CAT_1:attr 1
definition
  let a1 be CatStr;
  attr a1 is strict;
end;

:: CAT_1:exreg 1
registration
  cluster strict CatStr;
end;

:: CAT_1:aggrnot 1 => CAT_1: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;
  aggr CatStr(#a1,a2,a3,a4,a5,a6#) -> strict CatStr;
end;

:: CAT_1:selnot 1 => CAT_1:sel 1
definition
  let a1 be CatStr;
  sel the Comp of a1 -> Function-like Relation of [:the Edges of a1,the Edges of a1:],the Edges of a1;
end;

:: CAT_1:selnot 2 => CAT_1:sel 2
definition
  let a1 be CatStr;
  sel the Id of a1 -> Function-like quasi_total Relation of the Vertices of a1,the Edges of a1;
end;

:: CAT_1:modenot 1
definition
  let a1 be CatStr;
  mode Object of a1 is Element of the Vertices of a1;
end;

:: CAT_1:modenot 2
definition
  let a1 be CatStr;
  mode Morphism of a1 is Element of the Edges of a1;
end;

:: CAT_1:attrnot 2 => CAT_1:attr 2
definition
  let a1 be CatStr;
  attr a1 is void means
    (the Vertices of a1 <> {}) implies the Edges of a1 = {};
end;

:: CAT_1:dfs 1
definiens
  let a1 be CatStr;
To prove
     a1 is void
it is sufficient to prove
  thus (the Vertices of a1 <> {}) implies the Edges of a1 = {};

:: CAT_1:def 1
theorem
for b1 being CatStr holds
      b1 is void
   iff
      (the Vertices of b1 = {} or the Edges of b1 = {});

:: CAT_1:funcnot 2 => CAT_1:func 2
definition
  let a1, a2 be set;
  redefine func a1 .--> a2 -> Function-like quasi_total Relation of {a1},{a2};
end;

:: CAT_1:exreg 2
registration
  cluster non void CatStr;
end;

:: CAT_1:funcreg 1
registration
  let a1 be non void CatStr;
  cluster the Vertices of a1 -> non empty;
end;

:: CAT_1:funcreg 2
registration
  let a1 be non void CatStr;
  cluster the Edges of a1 -> non empty;
end;

:: CAT_1:funcnot 3 => CAT_1:func 3
definition
  let a1 be non void CatStr;
  let a2 be Element of the Edges of a1;
  func dom A2 -> Element of the Vertices of a1 equals
    (the Source of a1) . a2;
end;

:: CAT_1:def 2
theorem
for b1 being non void CatStr
for b2 being Element of the Edges of b1 holds
   dom b2 = (the Source of b1) . b2;

:: CAT_1:funcnot 4 => CAT_1:func 4
definition
  let a1 be non void CatStr;
  let a2 be Element of the Edges of a1;
  func cod A2 -> Element of the Vertices of a1 equals
    (the Target of a1) . a2;
end;

:: CAT_1:def 3
theorem
for b1 being non void CatStr
for b2 being Element of the Edges of b1 holds
   cod b2 = (the Target of b1) . b2;

:: CAT_1:funcnot 5 => CAT_1:func 5
definition
  let a1 be CatStr;
  let a2, a3 be Element of the Edges of a1;
  assume [a3,a2] in proj1 the Comp of a1;
  func A3 * A2 -> Element of the Edges of a1 equals
    (the Comp of a1) .(a3,a2);
end;

:: CAT_1:def 4
theorem
for b1 being CatStr
for b2, b3 being Element of the Edges of b1
      st [b3,b2] in proj1 the Comp of b1
   holds b3 * b2 = (the Comp of b1) .(b3,b2);

:: CAT_1:funcnot 6 => CAT_1:func 6
definition
  let a1 be non void CatStr;
  let a2 be Element of the Vertices of a1;
  func id A2 -> Element of the Edges of a1 equals
    (the Id of a1) . a2;
end;

:: CAT_1:def 5
theorem
for b1 being non void CatStr
for b2 being Element of the Vertices of b1 holds
   id b2 = (the Id of b1) . b2;

:: CAT_1:funcnot 7 => CAT_1:func 7
definition
  let a1 be non void CatStr;
  let a2, a3 be Element of the Vertices of a1;
  func Hom(A2,A3) -> Element of bool the Edges of a1 equals
    {b1 where b1 is Element of the Edges of a1: dom b1 = a2 & cod b1 = a3};
end;

:: CAT_1:def 6
theorem
for b1 being non void CatStr
for b2, b3 being Element of the Vertices of b1 holds
Hom(b2,b3) = {b4 where b4 is Element of the Edges of b1: dom b4 = b2 & cod b4 = b3};

:: CAT_1:th 18
theorem
for b1 being non void CatStr
for b2 being Element of the Edges of b1
for b3, b4 being Element of the Vertices of b1 holds
   b2 in Hom(b3,b4)
iff
   dom b2 = b3 & cod b2 = b4;

:: CAT_1:th 19
theorem
for b1 being non void CatStr
for b2 being Element of the Edges of b1 holds
   Hom(dom b2,cod b2) <> {};

:: CAT_1:modenot 3 => CAT_1:mode 1
definition
  let a1 be non void CatStr;
  let a2, a3 be Element of the Vertices of a1;
  assume Hom(a2,a3) <> {};
  mode Morphism of A2,A3 -> Element of the Edges of a1 means
    it in Hom(a2,a3);
end;

:: CAT_1:dfs 7
definiens
  let a1 be non void CatStr;
  let a2, a3 be Element of the Vertices of a1;
  let a4 be Element of the Edges of a1;
To prove
     a4 is Morphism of a2,a3
it is sufficient to prove
thus Hom(a2,a3) <> {};
  thus a4 in Hom(a2,a3);

:: CAT_1:def 7
theorem
for b1 being non void CatStr
for b2, b3 being Element of the Vertices of b1
   st Hom(b2,b3) <> {}
for b4 being Element of the Edges of b1 holds
      b4 is Morphism of b2,b3
   iff
      b4 in Hom(b2,b3);

:: CAT_1:th 21
theorem
for b1 being non void CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being set
      st b4 in Hom(b2,b3)
   holds b4 is Morphism of b2,b3;

:: CAT_1:th 22
theorem
for b1 being non void CatStr
for b2 being Element of the Edges of b1 holds
   b2 is Morphism of dom b2,cod b2;

:: CAT_1:th 23
theorem
for b1 being non void CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {}
   holds dom b4 = b2 & cod b4 = b3;

:: CAT_1:th 24
theorem
for b1 being non void CatStr
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
      st Hom(b2,b3) <> {} & Hom(b4,b5) <> {} & b6 = b7
   holds b2 = b4 & b3 = b5;

:: CAT_1:th 25
theorem
for b1 being non void CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
   st Hom(b2,b3) = {b4}
for b5 being Morphism of b2,b3 holds
   b4 = b5;

:: CAT_1:th 26
theorem
for b1 being non void CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {} &
         (for b5 being Morphism of b2,b3 holds
            b4 = b5)
   holds Hom(b2,b3) = {b4};

:: CAT_1:th 27
theorem
for b1 being non void CatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
for b6 being Morphism of b2,b3
      st Hom(b2,b3),Hom(b4,b5) are_equipotent & Hom(b2,b3) = {b6}
   holds ex b7 being Morphism of b4,b5 st
      Hom(b4,b5) = {b7};

:: CAT_1:attrnot 3 => CAT_1:attr 3
definition
  let a1 be CatStr;
  attr a1 is Category-like means
    (for b1, b2 being Element of the Edges of a1 holds
        [b2,b1] in proj1 the Comp of a1
     iff
        (the Source of a1) . b2 = (the Target of a1) . b1) &
     (for b1, b2 being Element of the Edges of a1
           st (the Source of a1) . b2 = (the Target of a1) . b1
        holds (the Source of a1) . ((the Comp of a1) .(b2,b1)) = (the Source of a1) . b1 &
         (the Target of a1) . ((the Comp of a1) .(b2,b1)) = (the Target of a1) . b2) &
     (for b1, b2, b3 being Element of the Edges of a1
           st (the Source of a1) . b3 = (the Target of a1) . b2 & (the Source of a1) . b2 = (the Target of a1) . b1
        holds (the Comp of a1) .(b3,(the Comp of a1) .(b2,b1)) = (the Comp of a1) .((the Comp of a1) .(b3,b2),b1)) &
     (for b1 being Element of the Vertices of a1 holds
        (the Source of a1) . ((the Id of a1) . b1) = b1 &
         (the Target of a1) . ((the Id of a1) . b1) = b1 &
         (for b2 being Element of the Edges of a1
               st (the Target of a1) . b2 = b1
            holds (the Comp of a1) .((the Id of a1) . b1,b2) = b2) &
         (for b2 being Element of the Edges of a1
               st (the Source of a1) . b2 = b1
            holds (the Comp of a1) .(b2,(the Id of a1) . b1) = b2));
end;

:: CAT_1:dfs 8
definiens
  let a1 be CatStr;
To prove
     a1 is Category-like
it is sufficient to prove
  thus (for b1, b2 being Element of the Edges of a1 holds
        [b2,b1] in proj1 the Comp of a1
     iff
        (the Source of a1) . b2 = (the Target of a1) . b1) &
     (for b1, b2 being Element of the Edges of a1
           st (the Source of a1) . b2 = (the Target of a1) . b1
        holds (the Source of a1) . ((the Comp of a1) .(b2,b1)) = (the Source of a1) . b1 &
         (the Target of a1) . ((the Comp of a1) .(b2,b1)) = (the Target of a1) . b2) &
     (for b1, b2, b3 being Element of the Edges of a1
           st (the Source of a1) . b3 = (the Target of a1) . b2 & (the Source of a1) . b2 = (the Target of a1) . b1
        holds (the Comp of a1) .(b3,(the Comp of a1) .(b2,b1)) = (the Comp of a1) .((the Comp of a1) .(b3,b2),b1)) &
     (for b1 being Element of the Vertices of a1 holds
        (the Source of a1) . ((the Id of a1) . b1) = b1 &
         (the Target of a1) . ((the Id of a1) . b1) = b1 &
         (for b2 being Element of the Edges of a1
               st (the Target of a1) . b2 = b1
            holds (the Comp of a1) .((the Id of a1) . b1,b2) = b2) &
         (for b2 being Element of the Edges of a1
               st (the Source of a1) . b2 = b1
            holds (the Comp of a1) .(b2,(the Id of a1) . b1) = b2));

:: CAT_1:def 8
theorem
for b1 being CatStr holds
      b1 is Category-like
   iff
      (for b2, b3 being Element of the Edges of b1 holds
          [b3,b2] in proj1 the Comp of b1
       iff
          (the Source of b1) . b3 = (the Target of b1) . b2) &
       (for b2, b3 being Element of the Edges of b1
             st (the Source of b1) . b3 = (the Target of b1) . b2
          holds (the Source of b1) . ((the Comp of b1) .(b3,b2)) = (the Source of b1) . b2 &
           (the Target of b1) . ((the Comp of b1) .(b3,b2)) = (the Target of b1) . b3) &
       (for b2, b3, b4 being Element of the Edges of b1
             st (the Source of b1) . b4 = (the Target of b1) . b3 & (the Source of b1) . b3 = (the Target of b1) . b2
          holds (the Comp of b1) .(b4,(the Comp of b1) .(b3,b2)) = (the Comp of b1) .((the Comp of b1) .(b4,b3),b2)) &
       (for b2 being Element of the Vertices of b1 holds
          (the Source of b1) . ((the Id of b1) . b2) = b2 &
           (the Target of b1) . ((the Id of b1) . b2) = b2 &
           (for b3 being Element of the Edges of b1
                 st (the Target of b1) . b3 = b2
              holds (the Comp of b1) .((the Id of b1) . b2,b3) = b3) &
           (for b3 being Element of the Edges of b1
                 st (the Source of b1) . b3 = b2
              holds (the Comp of b1) .(b3,(the Id of b1) . b2) = b3));

:: CAT_1:exreg 3
registration
  cluster non void Category-like CatStr;
end;

:: CAT_1:modenot 4
definition
  mode Category is non void Category-like CatStr;
end;

:: CAT_1:exreg 4
registration
  cluster strict non void Category-like CatStr;
end;

:: CAT_1:th 29
theorem
for b1 being non void CatStr
      st (for b2, b3 being Element of the Edges of b1 holds
            [b3,b2] in proj1 the Comp of b1
         iff
            dom b3 = cod b2) &
         (for b2, b3 being Element of the Edges of b1
               st dom b3 = cod b2
            holds dom (b3 * b2) = dom b2 & cod (b3 * b2) = cod b3) &
         (for b2, b3, b4 being Element of the Edges of b1
               st dom b4 = cod b3 & dom b3 = cod b2
            holds b4 * (b3 * b2) = (b4 * b3) * b2) &
         (for b2 being Element of the Vertices of b1 holds
            dom id b2 = b2 &
             cod id b2 = b2 &
             (for b3 being Element of the Edges of b1
                   st cod b3 = b2
                holds (id b2) * b3 = b3) &
             (for b3 being Element of the Edges of b1
                   st dom b3 = b2
                holds b3 * id b2 = b3))
   holds b1 is Category-like;

:: CAT_1:funcnot 8 => CAT_1:func 8
definition
  let a1, a2 be set;
  func 1Cat(A1,A2) -> strict non void Category-like CatStr equals
    CatStr(#{a1},{a2},a2 .--> a1,a2 .--> a1,(a2,a2).--> a2,a1 .--> a2#);
end;

:: CAT_1:def 9
theorem
for b1, b2 being set holds
1Cat(b1,b2) = CatStr(#{b1},{b2},b2 .--> b1,b2 .--> b1,(b2,b2).--> b2,b1 .--> b2#);

:: CAT_1:th 36
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of 1Cat(b1,b2)
for b5 being Element of the Edges of 1Cat(b1,b2) holds
   b5 in Hom(b3,b4);

:: CAT_1:th 37
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of 1Cat(b1,b2)
for b5 being Element of the Edges of 1Cat(b1,b2) holds
   b5 is Morphism of b3,b4;

:: CAT_1:th 38
theorem
for b1, b2 being set
for b3, b4 being Element of the Vertices of 1Cat(b1,b2) holds
Hom(b3,b4) <> {};

:: CAT_1:th 39
theorem
for b1, b2 being set
for b3, b4, b5, b6 being Element of the Vertices of 1Cat(b1,b2)
for b7 being Morphism of b3,b4
for b8 being Morphism of b5,b6 holds
   b7 = b8;

:: CAT_1:th 40
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Edges of b1 holds
   dom b2 = cod b3
iff
   [b2,b3] in proj1 the Comp of b1;

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

:: CAT_1:th 42
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 dom (b3 * b2) = dom b2 & cod (b3 * b2) = cod b3;

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

:: CAT_1:th 44
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   dom id b2 = b2 & cod id b2 = b2;

:: CAT_1:th 45
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
      st id b2 = id b3
   holds b2 = b3;

:: CAT_1:th 46
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
      st cod b3 = b2
   holds (id b2) * b3 = b3;

:: CAT_1:th 47
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
      st dom b3 = b2
   holds b3 * id b2 = b3;

:: CAT_1:attrnot 4 => CAT_1:attr 4
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
  attr a2 is monic means
    for b1, b2 being Element of the Edges of a1
          st dom b1 = dom b2 & cod b1 = dom a2 & cod b2 = dom a2 & a2 * b1 = a2 * b2
       holds b1 = b2;
end;

:: CAT_1:dfs 10
definiens
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
To prove
     a2 is monic
it is sufficient to prove
  thus for b1, b2 being Element of the Edges of a1
          st dom b1 = dom b2 & cod b1 = dom a2 & cod b2 = dom a2 & a2 * b1 = a2 * b2
       holds b1 = b2;

:: CAT_1:def 10
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1 holds
      b2 is monic(b1)
   iff
      for b3, b4 being Element of the Edges of b1
            st dom b3 = dom b4 & cod b3 = dom b2 & cod b4 = dom b2 & b2 * b3 = b2 * b4
         holds b3 = b4;

:: CAT_1:attrnot 5 => CAT_1:attr 5
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
  attr a2 is epi means
    for b1, b2 being Element of the Edges of a1
          st dom b1 = cod a2 & dom b2 = cod a2 & cod b1 = cod b2 & b1 * a2 = b2 * a2
       holds b1 = b2;
end;

:: CAT_1:dfs 11
definiens
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
To prove
     a2 is epi
it is sufficient to prove
  thus for b1, b2 being Element of the Edges of a1
          st dom b1 = cod a2 & dom b2 = cod a2 & cod b1 = cod b2 & b1 * a2 = b2 * a2
       holds b1 = b2;

:: CAT_1:def 11
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1 holds
      b2 is epi(b1)
   iff
      for b3, b4 being Element of the Edges of b1
            st dom b3 = cod b2 & dom b4 = cod b2 & cod b3 = cod b4 & b3 * b2 = b4 * b2
         holds b3 = b4;

:: CAT_1:attrnot 6 => CAT_1:attr 6
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
  attr a2 is invertible means
    ex b1 being Element of the Edges of a1 st
       dom b1 = cod a2 & cod b1 = dom a2 & a2 * b1 = id cod a2 & b1 * a2 = id dom a2;
end;

:: CAT_1:dfs 12
definiens
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Edges of a1;
To prove
     a2 is invertible
it is sufficient to prove
  thus ex b1 being Element of the Edges of a1 st
       dom b1 = cod a2 & cod b1 = dom a2 & a2 * b1 = id cod a2 & b1 * a2 = id dom a2;

:: CAT_1:def 12
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Edges of b1 holds
      b2 is invertible(b1)
   iff
      ex b3 being Element of the Edges of b1 st
         dom b3 = cod b2 & cod b3 = dom b2 & b2 * b3 = id cod b2 & b3 * b2 = id dom b2;

:: CAT_1:th 51
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {}
   holds b6 * b5 in Hom(b2,b4);

:: CAT_1:th 52
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {}
   holds Hom(b2,b4) <> {};

:: CAT_1:funcnot 9 => CAT_1:func 9
definition
  let a1 be non void Category-like CatStr;
  let a2, a3, a4 be Element of the Vertices of a1;
  let a5 be Morphism of a2,a3;
  let a6 be Morphism of a3,a4;
  assume Hom(a2,a3) <> {} & Hom(a3,a4) <> {};
  func A6 * A5 -> Morphism of a2,a4 equals
    a6 * a5;
end;

:: CAT_1:def 13
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {}
   holds b6 * b5 = b6 * b5;

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

:: CAT_1:th 55
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   id b2 in Hom(b2,b2);

:: CAT_1:th 56
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   Hom(b2,b2) <> {};

:: CAT_1:funcnot 10 => CAT_1:func 10
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  redefine func id a2 -> Morphism of a2,a2;
end;

:: CAT_1:th 57
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {}
   holds (id b3) * b4 = b4;

:: CAT_1:th 58
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {}
   holds b4 * id b2 = b4;

:: CAT_1:th 59
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   (id b2) * id b2 = id b2;

:: CAT_1:th 60
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {}
   holds    b4 is monic(b1)
   iff
      for b5 being Element of the Vertices of b1
      for b6, b7 being Morphism of b5,b2
            st Hom(b5,b2) <> {} & b4 * b6 = b4 * b7
         holds b6 = b7;

:: CAT_1:th 61
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {} & b5 is monic(b1) & b6 is monic(b1)
   holds b6 * b5 is monic(b1);

:: CAT_1:th 62
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {} & b6 * b5 is monic(b1)
   holds b5 is monic(b1);

:: CAT_1:th 63
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
for b5 being Morphism of b3,b2
      st Hom(b2,b3) <> {} & Hom(b3,b2) <> {} & b4 * b5 = id b3
   holds b5 is monic(b1);

:: CAT_1:th 64
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   id b2 is monic(b1);

:: CAT_1:th 65
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {}
   holds    b4 is epi(b1)
   iff
      for b5 being Element of the Vertices of b1
      for b6, b7 being Morphism of b3,b5
            st Hom(b3,b5) <> {} & b6 * b4 = b7 * b4
         holds b6 = b7;

:: CAT_1:th 66
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {} & b5 is epi(b1) & b6 is epi(b1)
   holds b6 * b5 is epi(b1);

:: CAT_1:th 67
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {} & b6 * b5 is epi(b1)
   holds b6 is epi(b1);

:: CAT_1:th 68
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
for b5 being Morphism of b3,b2
      st Hom(b2,b3) <> {} & Hom(b3,b2) <> {} & b4 * b5 = id b3
   holds b4 is epi(b1);

:: CAT_1:th 69
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   id b2 is epi(b1);

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

:: CAT_1:th 71
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
   st Hom(b2,b3) <> {} & Hom(b3,b2) <> {}
for b5, b6 being Morphism of b3,b2
      st b4 * b5 = id b3 & b6 * b4 = id b2
   holds b5 = b6;

:: CAT_1:funcnot 11 => CAT_1:func 11
definition
  let a1 be non void Category-like CatStr;
  let a2, a3 be Element of the Vertices of a1;
  let a4 be Morphism of a2,a3;
  assume Hom(a2,a3) <> {} & a4 is invertible(a1);
  func A4 " -> Morphism of a3,a2 means
    a4 * it = id a3 & it * a4 = id a2;
end;

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

:: CAT_1:th 73
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {} & b4 is invertible(b1)
   holds b4 is monic(b1) & b4 is epi(b1);

:: CAT_1:th 74
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   id b2 is invertible(b1);

:: CAT_1:th 75
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {} & b5 is invertible(b1) & b6 is invertible(b1)
   holds b6 * b5 is invertible(b1);

:: CAT_1:th 76
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {} & b4 is invertible(b1)
   holds b4 " is invertible(b1);

:: CAT_1:th 77
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
for b5 being Morphism of b2,b3
for b6 being Morphism of b3,b4
      st Hom(b2,b3) <> {} & Hom(b3,b4) <> {} & b5 is invertible(b1) & b6 is invertible(b1)
   holds (b6 * b5) " = b5 " * (b6 ");

:: CAT_1:attrnot 7 => CAT_1:attr 7
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  attr a2 is terminal means
    for b1 being Element of the Vertices of a1 holds
       Hom(b1,a2) <> {} &
        (ex b2 being Morphism of b1,a2 st
           for b3 being Morphism of b1,a2 holds
              b2 = b3);
end;

:: CAT_1:dfs 15
definiens
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
To prove
     a2 is terminal
it is sufficient to prove
  thus for b1 being Element of the Vertices of a1 holds
       Hom(b1,a2) <> {} &
        (ex b2 being Morphism of b1,a2 st
           for b3 being Morphism of b1,a2 holds
              b2 = b3);

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

:: CAT_1:attrnot 8 => CAT_1:attr 8
definition
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
  attr a2 is initial means
    for b1 being Element of the Vertices of a1 holds
       Hom(a2,b1) <> {} &
        (ex b2 being Morphism of a2,b1 st
           for b3 being Morphism of a2,b1 holds
              b2 = b3);
end;

:: CAT_1:dfs 16
definiens
  let a1 be non void Category-like CatStr;
  let a2 be Element of the Vertices of a1;
To prove
     a2 is initial
it is sufficient to prove
  thus for b1 being Element of the Vertices of a1 holds
       Hom(a2,b1) <> {} &
        (ex b2 being Morphism of a2,b1 st
           for b3 being Morphism of a2,b1 holds
              b2 = b3);

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

:: CAT_1: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) <> {} &
     (ex b1 being Morphism of a2,a3 st
        b1 is invertible(a1));
end;

:: CAT_1:dfs 17
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) <> {} &
     (ex b1 being Morphism of a2,a3 st
        b1 is invertible(a1));

:: CAT_1:def 17
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) <> {} &
    (ex b4 being Morphism of b2,b3 st
       b4 is invertible(b1));

:: CAT_1:th 81
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_1:th 82
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
      b2 is initial(b1)
   iff
      for b3 being Element of the Vertices of b1 holds
         ex b4 being Morphism of b2,b3 st
            Hom(b2,b3) = {b4};

:: CAT_1:th 83
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
   st b2 is initial(b1)
for b3 being Morphism of b2,b2 holds
   id b2 = b3;

:: CAT_1:th 84
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
      st b2 is initial(b1) & b3 is initial(b1)
   holds b2,b3 are_isomorphic;

:: CAT_1:th 85
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
      st b2 is initial(b1) & b2,b3 are_isomorphic
   holds b3 is initial(b1);

:: CAT_1:th 86
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
      b2 is terminal(b1)
   iff
      for b3 being Element of the Vertices of b1 holds
         ex b4 being Morphism of b3,b2 st
            Hom(b3,b2) = {b4};

:: CAT_1:th 87
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
   st b2 is terminal(b1)
for b3 being Morphism of b2,b2 holds
   id b2 = b3;

:: CAT_1:th 88
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
      st b2 is terminal(b1) & b3 is terminal(b1)
   holds b2,b3 are_isomorphic;

:: CAT_1:th 89
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
      st b2 is terminal(b1) & b3,b2 are_isomorphic
   holds b3 is terminal(b1);

:: CAT_1:th 90
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
for b4 being Morphism of b2,b3
      st Hom(b2,b3) <> {} & b2 is terminal(b1)
   holds b4 is monic(b1);

:: CAT_1:th 91
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   b2,b2 are_isomorphic;

:: CAT_1:th 92
theorem
for b1 being non void Category-like CatStr
for b2, b3 being Element of the Vertices of b1
      st b2,b3 are_isomorphic
   holds b3,b2 are_isomorphic;

:: CAT_1:th 93
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4 being Element of the Vertices of b1
      st b2,b3 are_isomorphic & b3,b4 are_isomorphic
   holds b2,b4 are_isomorphic;

:: CAT_1:modenot 5 => CAT_1:mode 2
definition
  let a1, a2 be non void Category-like CatStr;
  mode Functor of A1,A2 -> Function-like quasi_total Relation of the Edges of a1,the Edges of a2 means
    (for b1 being Element of the Vertices of a1 holds
        ex b2 being Element of the Vertices of a2 st
           it . ((the Id of a1) . b1) = (the Id of a2) . b2) &
     (for b1 being Element of the Edges of a1 holds
        it . ((the Id of a1) . ((the Source of a1) . b1)) = (the Id of a2) . ((the Source of a2) . (it . b1)) &
         it . ((the Id of a1) . ((the Target of a1) . b1)) = (the Id of a2) . ((the Target of a2) . (it . b1))) &
     (for b1, b2 being Element of the Edges of a1
           st [b2,b1] in proj1 the Comp of a1
        holds it . ((the Comp of a1) .(b2,b1)) = (the Comp of a2) .(it . b2,it . b1));
end;

:: CAT_1:dfs 18
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3 be Function-like quasi_total Relation of the Edges of a1,the Edges of a2;
To prove
     a3 is Functor of a1,a2
it is sufficient to prove
  thus (for b1 being Element of the Vertices of a1 holds
        ex b2 being Element of the Vertices of a2 st
           a3 . ((the Id of a1) . b1) = (the Id of a2) . b2) &
     (for b1 being Element of the Edges of a1 holds
        a3 . ((the Id of a1) . ((the Source of a1) . b1)) = (the Id of a2) . ((the Source of a2) . (a3 . b1)) &
         a3 . ((the Id of a1) . ((the Target of a1) . b1)) = (the Id of a2) . ((the Target of a2) . (a3 . b1))) &
     (for b1, b2 being Element of the Edges of a1
           st [b2,b1] in proj1 the Comp of a1
        holds a3 . ((the Comp of a1) .(b2,b1)) = (the Comp of a2) .(a3 . b2,a3 . b1));

:: CAT_1:def 18
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Function-like quasi_total Relation of the Edges of b1,the Edges of b2 holds
      b3 is Functor of b1,b2
   iff
      (for b4 being Element of the Vertices of b1 holds
          ex b5 being Element of the Vertices of b2 st
             b3 . ((the Id of b1) . b4) = (the Id of b2) . b5) &
       (for b4 being Element of the Edges of b1 holds
          b3 . ((the Id of b1) . ((the Source of b1) . b4)) = (the Id of b2) . ((the Source of b2) . (b3 . b4)) &
           b3 . ((the Id of b1) . ((the Target of b1) . b4)) = (the Id of b2) . ((the Target of b2) . (b3 . b4))) &
       (for b4, b5 being Element of the Edges of b1
             st [b5,b4] in proj1 the Comp of b1
          holds b3 . ((the Comp of b1) .(b5,b4)) = (the Comp of b2) .(b3 . b5,b3 . b4));

:: CAT_1:th 96
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Function-like quasi_total Relation of the Edges of b1,the Edges of b2
      st (for b4 being Element of the Vertices of b1 holds
            ex b5 being Element of the Vertices of b2 st
               b3 . id b4 = id b5) &
         (for b4 being Element of the Edges of b1 holds
            b3 . id dom b4 = id dom (b3 . b4) &
             b3 . id cod b4 = id cod (b3 . b4)) &
         (for b4, b5 being Element of the Edges of b1
               st dom b5 = cod b4
            holds b3 . (b5 * b4) = (b3 . b5) * (b3 . b4))
   holds b3 is Functor of b1,b2;

:: CAT_1:th 97
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Vertices of b1 holds
   ex b5 being Element of the Vertices of b2 st
      b3 . id b4 = id b5;

:: CAT_1:th 98
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Edges of b1 holds
   b3 . id dom b4 = id dom (b3 . b4) &
    b3 . id cod b4 = id cod (b3 . b4);

:: CAT_1:th 99
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Edges of b1
      st dom b5 = cod b4
   holds dom (b3 . b5) = cod (b3 . b4) &
    b3 . (b5 * b4) = (b3 . b5) * (b3 . b4);

:: CAT_1:th 100
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Function-like quasi_total Relation of the Edges of b1,the Edges of b2
for b4 being Function-like quasi_total Relation of the Vertices of b1,the Vertices of b2
      st (for b5 being Element of the Vertices of b1 holds
            b3 . id b5 = id (b4 . b5)) &
         (for b5 being Element of the Edges of b1 holds
            b4 . dom b5 = dom (b3 . b5) & b4 . cod b5 = cod (b3 . b5)) &
         (for b5, b6 being Element of the Edges of b1
               st dom b6 = cod b5
            holds b3 . (b6 * b5) = (b3 . b6) * (b3 . b5))
   holds b3 is Functor of b1,b2;

:: CAT_1:funcnot 12 => CAT_1:func 12
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Function-like quasi_total Relation of the Edges of a1,the Edges of a2;
  assume for b1 being Element of the Vertices of a1 holds
       ex b2 being Element of the Vertices of a2 st
          a3 . ((the Id of a1) . b1) = (the Id of a2) . b2;
  func Obj A3 -> Function-like quasi_total Relation of the Vertices of a1,the Vertices of a2 means
    for b1 being Element of the Vertices of a1
    for b2 being Element of the Vertices of a2
          st a3 . ((the Id of a1) . b1) = (the Id of a2) . b2
       holds it . b1 = b2;
end;

:: CAT_1:def 19
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Function-like quasi_total Relation of the Edges of b1,the Edges of b2
   st for b4 being Element of the Vertices of b1 holds
        ex b5 being Element of the Vertices of b2 st
           b3 . ((the Id of b1) . b4) = (the Id of b2) . b5
for b4 being Function-like quasi_total Relation of the Vertices of b1,the Vertices of b2 holds
      b4 = Obj b3
   iff
      for b5 being Element of the Vertices of b1
      for b6 being Element of the Vertices of b2
            st b3 . ((the Id of b1) . b5) = (the Id of b2) . b6
         holds b4 . b5 = b6;

:: CAT_1:th 102
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Function-like quasi_total Relation of the Edges of b1,the Edges of b2
   st for b4 being Element of the Vertices of b1 holds
        ex b5 being Element of the Vertices of b2 st
           b3 . id b4 = id b5
for b4 being Element of the Vertices of b1
for b5 being Element of the Vertices of b2
      st b3 . id b4 = id b5
   holds (Obj b3) . b4 = b5;

:: CAT_1:th 103
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Vertices of b1
for b5 being Element of the Vertices of b2
      st b3 . id b4 = id b5
   holds (Obj b3) . b4 = b5;

:: CAT_1:th 104
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Vertices of b1 holds
   b3 . id b4 = id ((Obj b3) . b4);

:: CAT_1:th 105
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Edges of b1 holds
   (Obj b3) . dom b4 = dom (b3 . b4) &
    (Obj b3) . cod b4 = cod (b3 . b4);

:: CAT_1:funcnot 13 => CAT_1:func 13
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  let a4 be Element of the Vertices of a1;
  func A3 . A4 -> Element of the Vertices of a2 equals
    (Obj a3) . a4;
end;

:: CAT_1:def 20
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Vertices of b1 holds
   b3 . b4 = (Obj b3) . b4;

:: CAT_1:th 107
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Vertices of b1
for b5 being Element of the Vertices of b2
      st b3 . id b4 = id b5
   holds b3 . b4 = b5;

:: CAT_1:th 108
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Vertices of b1 holds
   b3 . id b4 = id (b3 . b4);

:: CAT_1:th 109
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Element of the Edges of b1 holds
   b3 . dom b4 = dom (b3 . b4) & b3 . cod b4 = cod (b3 . b4);

:: CAT_1:th 110
theorem
for b1, b2, b3 being non void Category-like CatStr
for b4 being Functor of b1,b2
for b5 being Functor of b2,b3 holds
   b5 * b4 is Functor of b1,b3;

:: CAT_1:funcnot 14 => CAT_1:func 14
definition
  let a1, a2, a3 be non void Category-like CatStr;
  let a4 be Functor of a1,a2;
  let a5 be Functor of a2,a3;
  redefine func a5 * a4 -> Functor of a1,a3;
end;

:: CAT_1:th 111
theorem
for b1 being non void Category-like CatStr holds
   id the Edges of b1 is Functor of b1,b1;

:: CAT_1:th 112
theorem
for b1, b2, b3 being non void Category-like CatStr
for b4 being Functor of b1,b2
for b5 being Functor of b2,b3
for b6 being Element of the Vertices of b1 holds
   (Obj (b5 * b4)) . b6 = (Obj b5) . ((Obj b4) . b6);

:: CAT_1:th 113
theorem
for b1, b2, b3 being non void Category-like CatStr
for b4 being Functor of b1,b2
for b5 being Functor of b2,b3
for b6 being Element of the Vertices of b1 holds
   (b5 * b4) . b6 = b5 . (b4 . b6);

:: CAT_1:funcnot 15 => CAT_1:func 15
definition
  let a1 be non void Category-like CatStr;
  func id A1 -> Functor of a1,a1 equals
    id the Edges of a1;
end;

:: CAT_1:def 21
theorem
for b1 being non void Category-like CatStr holds
   id b1 = id the Edges of b1;

:: CAT_1:th 116
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   (Obj id b1) . b2 = b2;

:: CAT_1:th 117
theorem
for b1 being non void Category-like CatStr holds
   Obj id b1 = id the Vertices of b1;

:: CAT_1:th 118
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   (id b1) . b2 = b2;

:: CAT_1:attrnot 9 => CAT_1:attr 9
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  attr a3 is isomorphic means
    a3 is one-to-one & proj2 a3 = the Edges of a2 & proj2 Obj a3 = the Vertices of a2;
end;

:: CAT_1:dfs 22
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
To prove
     a3 is isomorphic
it is sufficient to prove
  thus a3 is one-to-one & proj2 a3 = the Edges of a2 & proj2 Obj a3 = the Vertices of a2;

:: CAT_1:def 22
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
      b3 is isomorphic(b1, b2)
   iff
      b3 is one-to-one & proj2 b3 = the Edges of b2 & proj2 Obj b3 = the Vertices of b2;

:: CAT_1:attrnot 10 => CAT_1:attr 10
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  attr a3 is full means
    for b1, b2 being Element of the Vertices of a1
       st Hom(a3 . b1,a3 . b2) <> {}
    for b3 being Morphism of a3 . b1,a3 . b2 holds
       Hom(b1,b2) <> {} &
        (ex b4 being Morphism of b1,b2 st
           b3 = a3 . b4);
end;

:: CAT_1:dfs 23
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
To prove
     a3 is full
it is sufficient to prove
  thus for b1, b2 being Element of the Vertices of a1
       st Hom(a3 . b1,a3 . b2) <> {}
    for b3 being Morphism of a3 . b1,a3 . b2 holds
       Hom(b1,b2) <> {} &
        (ex b4 being Morphism of b1,b2 st
           b3 = a3 . b4);

:: CAT_1:def 23
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
      b3 is full(b1, b2)
   iff
      for b4, b5 being Element of the Vertices of b1
         st Hom(b3 . b4,b3 . b5) <> {}
      for b6 being Morphism of b3 . b4,b3 . b5 holds
         Hom(b4,b5) <> {} &
          (ex b7 being Morphism of b4,b5 st
             b6 = b3 . b7);

:: CAT_1:attrnot 11 => CAT_1:attr 11
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  attr a3 is faithful means
    for b1, b2 being Element of the Vertices of a1
       st Hom(b1,b2) <> {}
    for b3, b4 being Morphism of b1,b2
          st a3 . b3 = a3 . b4
       holds b3 = b4;
end;

:: CAT_1:dfs 24
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
To prove
     a3 is faithful
it is sufficient to prove
  thus for b1, b2 being Element of the Vertices of a1
       st Hom(b1,b2) <> {}
    for b3, b4 being Morphism of b1,b2
          st a3 . b3 = a3 . b4
       holds b3 = b4;

:: CAT_1:def 24
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
      b3 is faithful(b1, b2)
   iff
      for b4, b5 being Element of the Vertices of b1
         st Hom(b4,b5) <> {}
      for b6, b7 being Morphism of b4,b5
            st b3 . b6 = b3 . b7
         holds b6 = b7;

:: CAT_1:prednot 2 => CAT_1:attr 9
notation
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  synonym a3 is_an_isomorphism for isomorphic;
end;

:: CAT_1:th 122
theorem
for b1 being non void Category-like CatStr holds
   id b1 is isomorphic(b1, b1);

:: CAT_1:th 123
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1
for b6 being set
      st b6 in Hom(b4,b5)
   holds b3 . b6 in Hom(b3 . b4,b3 . b5);

:: CAT_1:th 124
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1
   st Hom(b4,b5) <> {}
for b6 being Morphism of b4,b5 holds
   b3 . b6 in Hom(b3 . b4,b3 . b5);

:: CAT_1:th 125
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1
   st Hom(b4,b5) <> {}
for b6 being Morphism of b4,b5 holds
   b3 . b6 is Morphism of b3 . b4,b3 . b5;

:: CAT_1:th 126
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1
      st Hom(b4,b5) <> {}
   holds Hom(b3 . b4,b3 . b5) <> {};

:: CAT_1:th 127
theorem
for b1, b2, b3 being non void Category-like CatStr
for b4 being Functor of b1,b2
for b5 being Functor of b2,b3
      st b4 is full(b1, b2) & b5 is full(b2, b3)
   holds b5 * b4 is full(b1, b3);

:: CAT_1:th 128
theorem
for b1, b2, b3 being non void Category-like CatStr
for b4 being Functor of b1,b2
for b5 being Functor of b2,b3
      st b4 is faithful(b1, b2) & b5 is faithful(b2, b3)
   holds b5 * b4 is faithful(b1, b3);

:: CAT_1:th 129
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1 holds
b3 .: Hom(b4,b5) c= Hom(b3 . b4,b3 . b5);

:: CAT_1:funcnot 16 => CAT_1:func 16
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  let a4, a5 be Element of the Vertices of a1;
  func hom(A3,A4,A5) -> Function-like quasi_total Relation of Hom(a4,a5),Hom(a3 . a4,a3 . a5) equals
    a3 | Hom(a4,a5);
end;

:: CAT_1:def 25
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1 holds
hom(b3,b4,b5) = b3 | Hom(b4,b5);

:: CAT_1:th 131
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4, b5 being Element of the Vertices of b1
   st Hom(b4,b5) <> {}
for b6 being Morphism of b4,b5 holds
   (hom(b3,b4,b5)) . b6 = b3 . b6;

:: CAT_1:th 132
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
      b3 is full(b1, b2)
   iff
      for b4, b5 being Element of the Vertices of b1 holds
      proj2 hom(b3,b4,b5) = Hom(b3 . b4,b3 . b5);

:: CAT_1:th 133
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
      b3 is faithful(b1, b2)
   iff
      for b4, b5 being Element of the Vertices of b1 holds
      hom(b3,b4,b5) is one-to-one;