Article NATTRA_1, MML version 4.99.1005

:: NATTRA_1:funcnot 1 => NATTRA_1:func 1
definition
  let a1 be set;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be Element of bool a1;
  redefine func a3 | a4 -> Function-like quasi_total Relation of a4,a2;
end;

:: NATTRA_1:th 1
theorem
for b1, b2, b3, b4 being non empty set
for b5 being Function-like quasi_total Relation of b3,b1
for b6 being Function-like quasi_total Relation of b4,b2
for b7 being non empty Element of bool b3
for b8 being non empty Element of bool b4 holds
   [:b5,b6:] | [:b7,b8:] = [:b5 | b7,b6 | b8:];

:: NATTRA_1:funcnot 2 => NATTRA_1:func 2
definition
  let a1, a2 be non empty set;
  let a3 be non empty Element of bool a1;
  let a4 be non empty Element of bool a2;
  let a5 be Function-like Relation of [:a3,a3:],a3;
  let a6 be Function-like Relation of [:a4,a4:],a4;
  redefine func |:a5, a6:| -> Function-like Relation of [:[:a3,a4:],[:a3,a4:]:],[:a3,a4:];
end;

:: NATTRA_1:th 2
theorem
for b1, b2 being non empty set
for b3 being non empty Element of bool b1
for b4 being non empty Element of bool b2
for b5 being Function-like Relation of [:b1,b1:],b1
for b6 being Function-like Relation of [:b2,b2:],b2
for b7 being Function-like Relation of [:b3,b3:],b3
   st b7 = b5 || b3
for b8 being Function-like Relation of [:b4,b4:],b4
      st b8 = b6 || b4
   holds |:b7,b8:| = |:b5,b6:| || [:b3,b4:];

:: NATTRA_1:th 3
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1
for b3 being Morphism of b2,b2 holds
   b3 in Hom(b2,b2);

:: NATTRA_1:th 4
theorem
for b1, b2 being set
for b3, b4 being Element of the Edges of 1Cat(b1,b2) holds
b3 = b4;

:: NATTRA_1:th 5
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] in the Comp of b1;

:: NATTRA_1:th 6
theorem
for b1, b2 being set holds
the Comp of 1Cat(b1,b2) = {[[b2,b2],b2]};

:: NATTRA_1:th 7
theorem
for b1 being non void Category-like CatStr
for b2 being Element of the Vertices of b1 holds
   1Cat(b2,id b2) is Subcategory of b1;

:: NATTRA_1:th 8
theorem
for b1 being non void Category-like CatStr
for b2 being Subcategory of b1 holds
   the Source of b2 = (the Source of b1) | the Edges of b2 & the Target of b2 = (the Target of b1) | the Edges of b2 & the Comp of b2 = (the Comp of b1) || the Edges of b2 & the Id of b2 = (the Id of b1) | the Vertices of b2;

:: NATTRA_1:th 9
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1
for b3 being non empty Element of bool the Edges of b1
for b4, b5 being Function-like quasi_total Relation of b3,b2
   st b4 = (the Source of b1) | b3 & b5 = (the Target of b1) | b3
for b6 being Function-like Relation of [:b3,b3:],b3
   st b6 = (the Comp of b1) || b3
for b7 being Function-like quasi_total Relation of b2,b3
      st b7 = (the Id of b1) | b2
   holds CatStr(#b2,b3,b4,b5,b6,b7#) is Subcategory of b1;

:: NATTRA_1:th 10
theorem
for b1 being strict non void Category-like CatStr
for b2 being strict Subcategory of b1
      st the Vertices of b2 = the Vertices of b1 & the Edges of b2 = the Edges of b1
   holds b2 = b1;

:: NATTRA_1:funcnot 3 => NATTRA_1:func 3
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;
  let a6 be Morphism of a4,a5;
  assume Hom(a4,a5) <> {};
  func A3 . A6 -> Morphism of a3 . a4,a3 . a5 equals
    a3 . a6;
end;

:: NATTRA_1:def 1
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 = b3 . b6;

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

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

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

:: NATTRA_1:th 14
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;

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

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

:: NATTRA_1:th 17
theorem
for b1 being non void Category-like CatStr
for b2, b3, b4, b5 being Element of the Vertices of b1
      st Hom(b2,b3) meets Hom(b4,b5)
   holds b2 = b4 & b3 = b5;

:: NATTRA_1:prednot 1 => NATTRA_1:pred 1
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  pred A3 is_transformable_to A4 means
    for b1 being Element of the Vertices of a1 holds
       Hom(a3 . b1,a4 . b1) <> {};
  reflexivity;
::  for a1, a2 being non void Category-like CatStr
::  for a3 being Functor of a1,a2 holds
::     a3 is_transformable_to a3;
end;

:: NATTRA_1:dfs 2
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
To prove
     a3 is_transformable_to a4
it is sufficient to prove
  thus for b1 being Element of the Vertices of a1 holds
       Hom(a3 . b1,a4 . b1) <> {};

:: NATTRA_1:def 2
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2 holds
   b3 is_transformable_to b4
iff
   for b5 being Element of the Vertices of b1 holds
      Hom(b3 . b5,b4 . b5) <> {};

:: NATTRA_1:th 19
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
      st b3 is_transformable_to b4 & b4 is_transformable_to b5
   holds b3 is_transformable_to b5;

:: NATTRA_1:modenot 1 => NATTRA_1:mode 1
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  assume a3 is_transformable_to a4;
  mode transformation of A3,A4 -> Function-like quasi_total Relation of the Vertices of a1,the Edges of a2 means
    for b1 being Element of the Vertices of a1 holds
       it . b1 is Morphism of a3 . b1,a4 . b1;
end;

:: NATTRA_1:dfs 3
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be Function-like quasi_total Relation of the Vertices of a1,the Edges of a2;
To prove
     a5 is transformation of a3,a4
it is sufficient to prove
thus a3 is_transformable_to a4;
  thus for b1 being Element of the Vertices of a1 holds
       a5 . b1 is Morphism of a3 . b1,a4 . b1;

:: NATTRA_1:def 3
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3 is_transformable_to b4
for b5 being Function-like quasi_total Relation of the Vertices of b1,the Edges of b2 holds
      b5 is transformation of b3,b4
   iff
      for b6 being Element of the Vertices of b1 holds
         b5 . b6 is Morphism of b3 . b6,b4 . b6;

:: NATTRA_1:funcnot 4 => NATTRA_1:func 4
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  func id A3 -> transformation of a3,a3 means
    for b1 being Element of the Vertices of a1 holds
       it . b1 = id (a3 . b1);
end;

:: NATTRA_1:def 4
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being transformation of b3,b3 holds
      b4 = id b3
   iff
      for b5 being Element of the Vertices of b1 holds
         b4 . b5 = id (b3 . b5);

:: NATTRA_1:funcnot 5 => NATTRA_1:func 5
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be transformation of a3,a4;
  let a6 be Element of the Vertices of a1;
  assume a3 is_transformable_to a4;
  func A5 . A6 -> Morphism of a3 . a6,a4 . a6 equals
    a5 . a6;
end;

:: NATTRA_1:def 5
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3 is_transformable_to b4
for b5 being transformation of b3,b4
for b6 being Element of the Vertices of b1 holds
   b5 . b6 = b5 . b6;

:: NATTRA_1:funcnot 6 => NATTRA_1:func 6
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4, a5 be Functor of a1,a2;
  let a6 be transformation of a3,a4;
  let a7 be transformation of a4,a5;
  assume a3 is_transformable_to a4 & a4 is_transformable_to a5;
  func A7 `*` A6 -> transformation of a3,a5 means
    for b1 being Element of the Vertices of a1 holds
       it . b1 = (a7 . b1) * (a6 . b1);
end;

:: NATTRA_1:def 6
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
   st b3 is_transformable_to b4 & b4 is_transformable_to b5
for b6 being transformation of b3,b4
for b7 being transformation of b4,b5
for b8 being transformation of b3,b5 holds
      b8 = b7 `*` b6
   iff
      for b9 being Element of the Vertices of b1 holds
         b8 . b9 = (b7 . b9) * (b6 . b9);

:: NATTRA_1:th 20
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b2,b1
   st b3 is_transformable_to b4
for b5, b6 being transformation of b3,b4
      st for b7 being Element of the Vertices of b2 holds
           b5 . b7 = b6 . b7
   holds b5 = b6;

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

:: NATTRA_1:th 22
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3 is_transformable_to b4
for b5 being transformation of b3,b4 holds
   (id b4) `*` b5 = b5 & b5 `*` id b3 = b5;

:: NATTRA_1:th 23
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5, b6 being Functor of b1,b2
   st b3 is_transformable_to b4 & b4 is_transformable_to b5 & b5 is_transformable_to b6
for b7 being transformation of b3,b4
for b8 being transformation of b4,b5
for b9 being transformation of b5,b6 holds
   (b9 `*` b8) `*` b7 = b9 `*` (b8 `*` b7);

:: NATTRA_1:prednot 2 => NATTRA_1:pred 2
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  pred A3 is_naturally_transformable_to A4 means
    a3 is_transformable_to a4 &
     (ex b1 being transformation of a3,a4 st
        for b2, b3 being Element of the Vertices of a1
           st Hom(b2,b3) <> {}
        for b4 being Morphism of b2,b3 holds
           (b1 . b3) * (a3 . b4) = (a4 . b4) * (b1 . b2));
  reflexivity;
::  for a1, a2 being non void Category-like CatStr
::  for a3 being Functor of a1,a2 holds
::     a3 is_naturally_transformable_to a3;
end;

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

:: NATTRA_1:def 7
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2 holds
   b3 is_naturally_transformable_to b4
iff
   b3 is_transformable_to b4 &
    (ex b5 being transformation of b3,b4 st
       for b6, b7 being Element of the Vertices of b1
          st Hom(b6,b7) <> {}
       for b8 being Morphism of b6,b7 holds
          (b5 . b7) * (b3 . b8) = (b4 . b8) * (b5 . b6));

:: NATTRA_1:th 25
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
      st b3 is_naturally_transformable_to b4 & b4 is_naturally_transformable_to b5
   holds b3 is_naturally_transformable_to b5;

:: NATTRA_1:modenot 2 => NATTRA_1:mode 2
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  assume a3 is_naturally_transformable_to a4;
  mode natural_transformation of A3,A4 -> transformation of a3,a4 means
    for b1, b2 being Element of the Vertices of a1
       st Hom(b1,b2) <> {}
    for b3 being Morphism of b1,b2 holds
       (it . b2) * (a3 . b3) = (a4 . b3) * (it . b1);
end;

:: NATTRA_1:dfs 8
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be transformation of a3,a4;
To prove
     a5 is natural_transformation of a3,a4
it is sufficient to prove
thus a3 is_naturally_transformable_to a4;
  thus for b1, b2 being Element of the Vertices of a1
       st Hom(b1,b2) <> {}
    for b3 being Morphism of b1,b2 holds
       (a5 . b2) * (a3 . b3) = (a4 . b3) * (a5 . b1);

:: NATTRA_1:def 8
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3 is_naturally_transformable_to b4
for b5 being transformation of b3,b4 holds
      b5 is natural_transformation of b3,b4
   iff
      for b6, b7 being Element of the Vertices of b1
         st Hom(b6,b7) <> {}
      for b8 being Morphism of b6,b7 holds
         (b5 . b7) * (b3 . b8) = (b4 . b8) * (b5 . b6);

:: NATTRA_1:funcnot 7 => NATTRA_1:func 7
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Functor of a1,a2;
  redefine func id a3 -> natural_transformation of a3,a3;
end;

:: NATTRA_1:funcnot 8 => NATTRA_1:func 8
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4, a5 be Functor of a1,a2;
  let a6 be natural_transformation of a3,a4;
  let a7 be natural_transformation of a4,a5;
  assume a3 is_naturally_transformable_to a4 & a4 is_naturally_transformable_to a5;
  func A7 `*` A6 -> natural_transformation of a3,a5 equals
    a7 `*` a6;
end;

:: NATTRA_1:def 9
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
   st b3 is_naturally_transformable_to b4 & b4 is_naturally_transformable_to b5
for b6 being natural_transformation of b3,b4
for b7 being natural_transformation of b4,b5 holds
   b7 `*` b6 = b7 `*` b6;

:: NATTRA_1:th 26
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3 is_naturally_transformable_to b4
for b5 being natural_transformation of b3,b4 holds
   (id b4) `*` b5 = b5 & b5 `*` id b3 = b5;

:: NATTRA_1:th 27
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b2,b1
   st b3 is_naturally_transformable_to b4 & b4 is_naturally_transformable_to b5
for b6 being natural_transformation of b3,b4
for b7 being natural_transformation of b4,b5
for b8 being Element of the Vertices of b2 holds
   (b7 `*` b6) . b8 = (b7 . b8) * (b6 . b8);

:: NATTRA_1:th 28
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5, b6 being Functor of b1,b2
for b7 being natural_transformation of b3,b4
for b8 being natural_transformation of b4,b5
   st b3 is_naturally_transformable_to b4 & b4 is_naturally_transformable_to b5 & b5 is_naturally_transformable_to b6
for b9 being natural_transformation of b5,b6 holds
   (b9 `*` b8) `*` b7 = b9 `*` (b8 `*` b7);

:: NATTRA_1:attrnot 1 => NATTRA_1:attr 1
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be transformation of a3,a4;
  attr a5 is invertible means
    for b1 being Element of the Vertices of a1 holds
       a5 . b1 is invertible(a2);
end;

:: NATTRA_1:dfs 10
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be transformation of a3,a4;
To prove
     a5 is invertible
it is sufficient to prove
  thus for b1 being Element of the Vertices of a1 holds
       a5 . b1 is invertible(a2);

:: NATTRA_1:def 10
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
for b5 being transformation of b3,b4 holds
      b5 is invertible(b1, b2, b3, b4)
   iff
      for b6 being Element of the Vertices of b1 holds
         b5 . b6 is invertible(b2);

:: NATTRA_1:prednot 3 => NATTRA_1:pred 3
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  pred A3,A4 are_naturally_equivalent means
    a3 is_naturally_transformable_to a4 &
     (ex b1 being natural_transformation of a3,a4 st
        b1 is invertible(a1, a2, a3, a4));
  reflexivity;
::  for a1, a2 being non void Category-like CatStr
::  for a3 being Functor of a1,a2 holds
::     a3,a3 are_naturally_equivalent;
end;

:: NATTRA_1:dfs 11
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
To prove
     a3,a4 are_naturally_equivalent
it is sufficient to prove
  thus a3 is_naturally_transformable_to a4 &
     (ex b1 being natural_transformation of a3,a4 st
        b1 is invertible(a1, a2, a3, a4));

:: NATTRA_1:def 11
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2 holds
   b3,b4 are_naturally_equivalent
iff
   b3 is_naturally_transformable_to b4 &
    (ex b5 being natural_transformation of b3,b4 st
       b5 is invertible(b1, b2, b3, b4));

:: NATTRA_1:prednot 4 => NATTRA_1:pred 3
notation
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  synonym a3 ~= a4 for a3,a4 are_naturally_equivalent;
end;

:: NATTRA_1:funcnot 9 => NATTRA_1:func 9
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be transformation of a3,a4;
  assume a3 is_transformable_to a4 & a5 is invertible(a1, a2, a3, a4);
  func A5 " -> transformation of a4,a3 means
    for b1 being Element of the Vertices of a1 holds
       it . b1 = (a5 . b1) ";
end;

:: NATTRA_1:def 12
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3 is_transformable_to b4
for b5 being transformation of b3,b4
   st b5 is invertible(b1, b2, b3, b4)
for b6 being transformation of b4,b3 holds
      b6 = b5 "
   iff
      for b7 being Element of the Vertices of b1 holds
         b6 . b7 = (b5 . b7) ";

:: NATTRA_1:funcnot 10 => NATTRA_1:func 10
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be natural_transformation of a3,a4;
  assume a3 is_naturally_transformable_to a4 & a5 is invertible(a1, a2, a3, a4);
  func A5 " -> natural_transformation of a4,a3 equals
    a5 ";
end;

:: NATTRA_1:def 13
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
for b5 being natural_transformation of b3,b4
      st b3 is_naturally_transformable_to b4 & b5 is invertible(b1, b2, b3, b4)
   holds b5 " = b5 ";

:: NATTRA_1:th 30
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
for b5 being natural_transformation of b3,b4
   st b3 is_naturally_transformable_to b4 & b5 is invertible(b1, b2, b3, b4)
for b6 being Element of the Vertices of b1 holds
   b5 " . b6 = (b5 . b6) ";

:: NATTRA_1:th 31
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
      st b3,b4 are_naturally_equivalent
   holds b4,b3 are_naturally_equivalent;

:: NATTRA_1:th 32
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
      st b3,b4 are_naturally_equivalent & b4,b5 are_naturally_equivalent
   holds b3,b5 are_naturally_equivalent;

:: NATTRA_1:modenot 3 => NATTRA_1:mode 3
definition
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  assume a3,a4 are_naturally_equivalent;
  mode natural_equivalence of A3,A4 -> natural_transformation of a3,a4 means
    it is invertible(a1, a2, a3, a4);
end;

:: NATTRA_1:dfs 14
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3, a4 be Functor of a1,a2;
  let a5 be natural_transformation of a3,a4;
To prove
     a5 is natural_equivalence of a3,a4
it is sufficient to prove
thus a3,a4 are_naturally_equivalent;
  thus a5 is invertible(a1, a2, a3, a4);

:: NATTRA_1:def 14
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
   st b3,b4 are_naturally_equivalent
for b5 being natural_transformation of b3,b4 holds
      b5 is natural_equivalence of b3,b4
   iff
      b5 is invertible(b1, b2, b3, b4);

:: NATTRA_1:th 33
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2 holds
   id b3 is natural_equivalence of b3,b3;

:: NATTRA_1:th 34
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
   st b3,b4 are_naturally_equivalent & b4,b5 are_naturally_equivalent
for b6 being natural_equivalence of b3,b4
for b7 being natural_equivalence of b4,b5 holds
   b7 `*` b6 is natural_equivalence of b3,b5;

:: NATTRA_1:modenot 4 => NATTRA_1:mode 4
definition
  let a1, a2 be non void Category-like CatStr;
  mode NatTrans-DOMAIN of A1,A2 -> non empty set means
    for b1 being set
          st b1 in it
       holds ex b2, b3 being Functor of a1,a2 st
          ex b4 being natural_transformation of b2,b3 st
             b1 = [[b2,b3],b4] & b2 is_naturally_transformable_to b3;
end;

:: NATTRA_1:dfs 15
definiens
  let a1, a2 be non void Category-like CatStr;
  let a3 be non empty set;
To prove
     a3 is NatTrans-DOMAIN of a1,a2
it is sufficient to prove
  thus for b1 being set
          st b1 in a3
       holds ex b2, b3 being Functor of a1,a2 st
          ex b4 being natural_transformation of b2,b3 st
             b1 = [[b2,b3],b4] & b2 is_naturally_transformable_to b3;

:: NATTRA_1:def 15
theorem
for b1, b2 being non void Category-like CatStr
for b3 being non empty set holds
      b3 is NatTrans-DOMAIN of b1,b2
   iff
      for b4 being set
            st b4 in b3
         holds ex b5, b6 being Functor of b1,b2 st
            ex b7 being natural_transformation of b5,b6 st
               b4 = [[b5,b6],b7] & b5 is_naturally_transformable_to b6;

:: NATTRA_1:funcnot 11 => NATTRA_1:func 11
definition
  let a1, a2 be non void Category-like CatStr;
  func NatTrans(A1,A2) -> NatTrans-DOMAIN of a1,a2 means
    for b1 being set holds
          b1 in it
       iff
          ex b2, b3 being Functor of a1,a2 st
             ex b4 being natural_transformation of b2,b3 st
                b1 = [[b2,b3],b4] & b2 is_naturally_transformable_to b3;
end;

:: NATTRA_1:def 16
theorem
for b1, b2 being non void Category-like CatStr
for b3 being NatTrans-DOMAIN of b1,b2 holds
      b3 = NatTrans(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5, b6 being Functor of b1,b2 st
               ex b7 being natural_transformation of b5,b6 st
                  b4 = [[b5,b6],b7] & b5 is_naturally_transformable_to b6;

:: NATTRA_1:th 35
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
for b5 being natural_transformation of b3,b4 holds
      b3 is_naturally_transformable_to b4
   iff
      [[b3,b4],b5] in NatTrans(b1,b2);

:: NATTRA_1:funcnot 12 => NATTRA_1:func 12
definition
  let a1, a2 be non void Category-like CatStr;
  func Functors(A1,A2) -> strict non void Category-like CatStr means
    the Vertices of it = Funct(a1,a2) &
     the Edges of it = NatTrans(a1,a2) &
     (for b1 being Element of the Edges of it holds
        dom b1 = b1 `1 `1 & cod b1 = b1 `1 `2) &
     (for b1, b2 being Element of the Edges of it
           st dom b2 = cod b1
        holds [b2,b1] in proj1 the Comp of it) &
     (for b1, b2 being Element of the Edges of it
           st [b2,b1] in proj1 the Comp of it
        holds ex b3, b4, b5 being Functor of a1,a2 st
           ex b6 being natural_transformation of b3,b4 st
              ex b7 being natural_transformation of b4,b5 st
                 b1 = [[b3,b4],b6] &
                  b2 = [[b4,b5],b7] &
                  (the Comp of it) . [b2,b1] = [[b3,b5],b7 `*` b6]) &
     (for b1 being Element of the Vertices of it
     for b2 being Functor of a1,a2
           st b2 = b1
        holds id b1 = [[b2,b2],id b2]);
end;

:: NATTRA_1:def 18
theorem
for b1, b2 being non void Category-like CatStr
for b3 being strict non void Category-like CatStr holds
      b3 = Functors(b1,b2)
   iff
      the Vertices of b3 = Funct(b1,b2) &
       the Edges of b3 = NatTrans(b1,b2) &
       (for b4 being Element of the Edges of b3 holds
          dom b4 = b4 `1 `1 & cod b4 = b4 `1 `2) &
       (for b4, b5 being Element of the Edges of b3
             st dom b5 = cod b4
          holds [b5,b4] in proj1 the Comp of b3) &
       (for b4, b5 being Element of the Edges of b3
             st [b5,b4] in proj1 the Comp of b3
          holds ex b6, b7, b8 being Functor of b1,b2 st
             ex b9 being natural_transformation of b6,b7 st
                ex b10 being natural_transformation of b7,b8 st
                   b4 = [[b6,b7],b9] &
                    b5 = [[b7,b8],b10] &
                    (the Comp of b3) . [b5,b4] = [[b6,b8],b10 `*` b9]) &
       (for b4 being Element of the Vertices of b3
       for b5 being Functor of b1,b2
             st b5 = b4
          holds id b4 = [[b5,b5],id b5]);

:: NATTRA_1:th 39
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Functor of b1,b2
for b5 being natural_transformation of b3,b4
for b6 being Element of the Edges of Functors(b1,b2)
      st b6 = [[b3,b4],b5]
   holds dom b6 = b3 & cod b6 = b4;

:: NATTRA_1:th 40
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4 being Element of the Vertices of Functors(b1,b2)
for b5 being Morphism of b3,b4
      st Hom(b3,b4) <> {}
   holds ex b6, b7 being Functor of b1,b2 st
      ex b8 being natural_transformation of b6,b7 st
         b3 = b6 & b4 = b7 & b5 = [[b6,b7],b8];

:: NATTRA_1:th 41
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5, b6 being Functor of b1,b2
for b7 being natural_transformation of b5,b6
for b8 being natural_transformation of b3,b4
for b9, b10 being Element of the Edges of Functors(b1,b2)
      st b9 = [[b5,b6],b7] & b10 = [[b3,b4],b8]
   holds    [b10,b9] in proj1 the Comp of Functors(b1,b2)
   iff
      b6 = b3;

:: NATTRA_1:th 42
theorem
for b1, b2 being non void Category-like CatStr
for b3, b4, b5 being Functor of b1,b2
for b6 being natural_transformation of b3,b4
for b7 being natural_transformation of b4,b5
for b8, b9 being Element of the Edges of Functors(b1,b2)
      st b8 = [[b3,b4],b6] & b9 = [[b4,b5],b7]
   holds b9 * b8 = [[b3,b5],b7 `*` b6];

:: NATTRA_1:attrnot 2 => NATTRA_1:attr 2
definition
  let a1 be non void Category-like CatStr;
  attr a1 is discrete means
    for b1 being Element of the Edges of a1 holds
       ex b2 being Element of the Vertices of a1 st
          b1 = id b2;
end;

:: NATTRA_1:dfs 18
definiens
  let a1 be non void Category-like CatStr;
To prove
     a1 is discrete
it is sufficient to prove
  thus for b1 being Element of the Edges of a1 holds
       ex b2 being Element of the Vertices of a1 st
          b1 = id b2;

:: NATTRA_1:def 19
theorem
for b1 being non void Category-like CatStr holds
      b1 is discrete
   iff
      for b2 being Element of the Edges of b1 holds
         ex b3 being Element of the Vertices of b1 st
            b2 = id b3;

:: NATTRA_1:exreg 1
registration
  cluster non void Category-like discrete CatStr;
end;

:: NATTRA_1:th 44
theorem
for b1 being non void Category-like discrete CatStr
for b2 being Element of the Vertices of b1 holds
   Hom(b2,b2) = {id b2};

:: NATTRA_1:th 45
theorem
for b1 being non void Category-like CatStr holds
      b1 is discrete
   iff
      (for b2 being Element of the Vertices of b1 holds
          ex b3 being finite set st
             b3 = Hom(b2,b2) & card b3 = 1) &
       (for b2, b3 being Element of the Vertices of b1
             st b2 <> b3
          holds Hom(b2,b3) = {});

:: NATTRA_1:th 46
theorem
for b1, b2 being set holds
1Cat(b1,b2) is discrete;

:: NATTRA_1:th 47
theorem
for b1 being non void Category-like discrete CatStr
for b2 being Subcategory of b1 holds
   b2 is discrete;

:: NATTRA_1:th 48
theorem
for b1, b2 being non void Category-like CatStr
      st b1 is discrete & b2 is discrete
   holds [:b1,b2:] is discrete;

:: NATTRA_1:th 49
theorem
for b1 being non void Category-like discrete CatStr
for b2 being non void Category-like CatStr
for b3, b4 being Functor of b2,b1
      st b3 is_transformable_to b4
   holds b3 = b4;

:: NATTRA_1:th 50
theorem
for b1 being non void Category-like discrete CatStr
for b2 being non void Category-like CatStr
for b3 being Functor of b2,b1
for b4 being transformation of b3,b3 holds
   b4 = id b3;

:: NATTRA_1:th 51
theorem
for b1, b2 being non void Category-like CatStr
      st b1 is discrete
   holds Functors(b2,b1) is discrete;

:: NATTRA_1:exreg 2
registration
  let a1 be non void Category-like CatStr;
  cluster strict non void Category-like discrete Subcategory of a1;
end;

:: NATTRA_1:funcnot 13 => NATTRA_1:func 13
definition
  let a1 be non void Category-like CatStr;
  func IdCat A1 -> strict discrete Subcategory of a1 means
    the Vertices of it = the Vertices of a1 &
     the Edges of it = {id b1 where b1 is Element of the Vertices of a1: TRUE};
end;

:: NATTRA_1:def 20
theorem
for b1 being non void Category-like CatStr
for b2 being strict discrete Subcategory of b1 holds
      b2 = IdCat b1
   iff
      the Vertices of b2 = the Vertices of b1 &
       the Edges of b2 = {id b3 where b3 is Element of the Vertices of b1: TRUE};

:: NATTRA_1:th 52
theorem
for b1 being strict non void Category-like CatStr
      st b1 is discrete
   holds IdCat b1 = b1;

:: NATTRA_1:th 53
theorem
for b1 being non void Category-like CatStr holds
   IdCat IdCat b1 = IdCat b1;

:: NATTRA_1:th 54
theorem
for b1, b2 being set holds
IdCat 1Cat(b1,b2) = 1Cat(b1,b2);

:: NATTRA_1:th 55
theorem
for b1, b2 being non void Category-like CatStr holds
IdCat [:b1,b2:] = [:IdCat b1,IdCat b2:];