Article INDEX_1, MML version 4.99.1005

:: INDEX_1:exreg 1
registration
  let a1 be non empty set;
  cluster Relation-like non empty-yielding Function-like ManySortedSet of a1;
end;

:: INDEX_1:condreg 1
registration
  let a1 be non empty set;
  cluster non-empty -> non empty-yielding (ManySortedSet of a1);
end;

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

:: INDEX_1:th 1
theorem
for b1 being non void Category-like Categorial CatStr
for b2, b3 being Element of the Edges of b1
      st dom b3 = cod b2
   holds b3 * b2 = [[dom b2,cod b3],b3 `2 * (b2 `2)];

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

:: INDEX_1:attrnot 1 => INDEX_1:attr 1
definition
  let a1 be Relation-like Function-like set;
  attr a1 is Category-yielding means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is non void Category-like CatStr;
end;

:: INDEX_1:dfs 1
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is Category-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is non void Category-like CatStr;

:: INDEX_1:def 1
theorem
for b1 being Relation-like Function-like set holds
      b1 is Category-yielding
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is non void Category-like CatStr;

:: INDEX_1:exreg 2
registration
  cluster Relation-like Function-like Category-yielding set;
end;

:: INDEX_1:exreg 3
registration
  let a1 be set;
  cluster Relation-like Function-like Category-yielding ManySortedSet of a1;
end;

:: INDEX_1:modenot 1
definition
  let a1 be set;
  mode ManySortedCategory of a1 is Category-yielding ManySortedSet of a1;
end;

:: INDEX_1:modenot 2
definition
  let a1 be non void Category-like CatStr;
  mode ManySortedSet of a1 is ManySortedSet of the Vertices of a1;
end;

:: INDEX_1:modenot 3
definition
  let a1 be non void Category-like CatStr;
  mode ManySortedCategory of a1 is Category-yielding ManySortedSet of the Vertices of a1;
end;

:: INDEX_1:funcreg 1
registration
  let a1 be set;
  let a2 be non void Category-like CatStr;
  cluster a1 --> a2 -> Category-yielding;
end;

:: INDEX_1:condreg 2
registration
  let a1 be non empty set;
  cluster -> non empty (ManySortedSet of a1);
end;

:: INDEX_1:funcreg 2
registration
  let a1 be Relation-like Function-like Category-yielding set;
  cluster proj2 a1 -> categorial;
end;

:: INDEX_1:funcnot 2 => INDEX_1:func 2
definition
  let a1 be non empty set;
  let a2 be Category-yielding ManySortedSet of a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> non void Category-like CatStr;
end;

:: INDEX_1:funcreg 3
registration
  let a1 be Relation-like Function-like set;
  let a2 be Relation-like Function-like Category-yielding set;
  cluster a1 * a2 -> Relation-like Category-yielding;
end;

:: INDEX_1:funcnot 3 => INDEX_1:func 3
definition
  let a1 be Relation-like Function-like Category-yielding set;
  func Objs A1 -> Relation-like non-empty Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being set
        st b1 in proj1 a1
     for b2 being non void Category-like CatStr
           st b2 = a1 . b1
        holds it . b1 = the Vertices of b2);
end;

:: INDEX_1:def 2
theorem
for b1 being Relation-like Function-like Category-yielding set
for b2 being Relation-like non-empty Function-like set holds
      b2 = Objs b1
   iff
      proj1 b2 = proj1 b1 &
       (for b3 being set
          st b3 in proj1 b1
       for b4 being non void Category-like CatStr
             st b4 = b1 . b3
          holds b2 . b3 = the Vertices of b4);

:: INDEX_1:funcnot 4 => INDEX_1:func 4
definition
  let a1 be Relation-like Function-like Category-yielding set;
  func Mphs A1 -> Relation-like non-empty Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being set
        st b1 in proj1 a1
     for b2 being non void Category-like CatStr
           st b2 = a1 . b1
        holds it . b1 = the Edges of b2);
end;

:: INDEX_1:def 3
theorem
for b1 being Relation-like Function-like Category-yielding set
for b2 being Relation-like non-empty Function-like set holds
      b2 = Mphs b1
   iff
      proj1 b2 = proj1 b1 &
       (for b3 being set
          st b3 in proj1 b1
       for b4 being non void Category-like CatStr
             st b4 = b1 . b3
          holds b2 . b3 = the Edges of b4);

:: INDEX_1:funcnot 5 => INDEX_1:func 5
definition
  let a1 be non empty set;
  let a2 be Category-yielding ManySortedSet of a1;
  redefine func Objs a2 -> non-empty ManySortedSet of a1;
end;

:: INDEX_1:funcnot 6 => INDEX_1:func 6
definition
  let a1 be non empty set;
  let a2 be Category-yielding ManySortedSet of a1;
  redefine func Mphs a2 -> non-empty ManySortedSet of a1;
end;

:: INDEX_1:th 3
theorem
for b1 being set
for b2 being non void Category-like CatStr holds
   Objs (b1 --> b2) = b1 --> the Vertices of b2 & Mphs (b1 --> b2) = b1 --> the Edges of b2;

:: INDEX_1:modenot 4 => INDEX_1:mode 1
definition
  let a1, a2 be set;
  mode ManySortedSet of A1,A2 means
    ex b1 being ManySortedSet of a1 st
       ex b2 being ManySortedSet of a2 st
          it = [b1,b2];
end;

:: INDEX_1:dfs 4
definiens
  let a1, a2, a3 be set;
To prove
     a3 is ManySortedSet of a1,a2
it is sufficient to prove
  thus ex b1 being ManySortedSet of a1 st
       ex b2 being ManySortedSet of a2 st
          a3 = [b1,b2];

:: INDEX_1:def 4
theorem
for b1, b2, b3 being set holds
   b3 is ManySortedSet of b1,b2
iff
   ex b4 being ManySortedSet of b1 st
      ex b5 being ManySortedSet of b2 st
         b3 = [b4,b5];

:: INDEX_1:funcnot 7 => INDEX_1:func 7
definition
  let a1, a2 be set;
  let a3 be ManySortedSet of a1;
  let a4 be ManySortedSet of a2;
  redefine func [a3, a4] -> ManySortedSet of a1,a2;
end;

:: INDEX_1:funcnot 8 => INDEX_1:func 8
definition
  let a1, a2 be set;
  let a3 be ManySortedSet of a1,a2;
  redefine func a3 `1 -> ManySortedSet of a1;
end;

:: INDEX_1:funcnot 9 => INDEX_1:func 9
definition
  let a1, a2 be set;
  let a3 be ManySortedSet of a1,a2;
  redefine func a3 `2 -> ManySortedSet of a2;
end;

:: INDEX_1:attrnot 2 => INDEX_1:attr 2
definition
  let a1, a2 be set;
  let a3 be ManySortedSet of a1,a2;
  attr a3 is Category-yielding_on_first means
    a3 `1 is Category-yielding;
end;

:: INDEX_1:dfs 5
definiens
  let a1, a2 be set;
  let a3 be ManySortedSet of a1,a2;
To prove
     a3 is Category-yielding_on_first
it is sufficient to prove
  thus a3 `1 is Category-yielding;

:: INDEX_1:def 5
theorem
for b1, b2 being set
for b3 being ManySortedSet of b1,b2 holds
      b3 is Category-yielding_on_first(b1, b2)
   iff
      b3 `1 is Category-yielding;

:: INDEX_1:attrnot 3 => INDEX_1:attr 3
definition
  let a1, a2 be set;
  let a3 be ManySortedSet of a1,a2;
  attr a3 is Function-yielding_on_second means
    a3 `2 is Function-yielding;
end;

:: INDEX_1:dfs 6
definiens
  let a1, a2 be set;
  let a3 be ManySortedSet of a1,a2;
To prove
     a3 is Function-yielding_on_second
it is sufficient to prove
  thus a3 `2 is Function-yielding;

:: INDEX_1:def 6
theorem
for b1, b2 being set
for b3 being ManySortedSet of b1,b2 holds
      b3 is Function-yielding_on_second(b1, b2)
   iff
      b3 `2 is Function-yielding;

:: INDEX_1:exreg 4
registration
  let a1, a2 be set;
  cluster Category-yielding_on_first Function-yielding_on_second ManySortedSet of a1,a2;
end;

:: INDEX_1:funcnot 10 => INDEX_1:func 10
definition
  let a1, a2 be set;
  let a3 be Category-yielding_on_first ManySortedSet of a1,a2;
  redefine func a3 `1 -> Category-yielding ManySortedSet of a1;
end;

:: INDEX_1:funcnot 11 => INDEX_1:func 11
definition
  let a1, a2 be set;
  let a3 be Function-yielding_on_second ManySortedSet of a1,a2;
  redefine func a3 `2 -> Function-yielding ManySortedSet of a2;
end;

:: INDEX_1:funcreg 4
registration
  let a1 be Relation-like Function-like Function-yielding set;
  cluster proj2 a1 -> functional;
end;

:: INDEX_1:funcnot 12 => INDEX_1:func 12
definition
  let a1, a2 be set;
  let a3 be Category-yielding ManySortedSet of a1;
  let a4 be Function-yielding ManySortedSet of a2;
  redefine func [a3, a4] -> Category-yielding_on_first Function-yielding_on_second ManySortedSet of a1,a2;
end;

:: INDEX_1:modenot 5 => INDEX_1:mode 2
definition
  let a1 be non empty set;
  let a2, a3 be Category-yielding ManySortedSet of a1;
  mode ManySortedFunctor of A2,A3 -> Function-yielding ManySortedSet of a1 means
    for b1 being Element of a1 holds
       it . b1 is Functor of a2 . b1,a3 . b1;
end;

:: INDEX_1:dfs 7
definiens
  let a1 be non empty set;
  let a2, a3 be Category-yielding ManySortedSet of a1;
  let a4 be Function-yielding ManySortedSet of a1;
To prove
     a4 is ManySortedFunctor of a2,a3
it is sufficient to prove
  thus for b1 being Element of a1 holds
       a4 . b1 is Functor of a2 . b1,a3 . b1;

:: INDEX_1:def 7
theorem
for b1 being non empty set
for b2, b3 being Category-yielding ManySortedSet of b1
for b4 being Function-yielding ManySortedSet of b1 holds
      b4 is ManySortedFunctor of b2,b3
   iff
      for b5 being Element of b1 holds
         b4 . b5 is Functor of b2 . b5,b3 . b5;

:: INDEX_1:sch 1
scheme INDEX_1:sch 1
{F1 -> non empty set,
  F2 -> Category-yielding ManySortedSet of F1(),
  F3 -> Category-yielding ManySortedSet of F1(),
  F4 -> set}:
ex b1 being ManySortedFunctor of F2(),F3() st
   for b2 being Element of F1() holds
      b1 . b2 = F4(b2)
provided
   for b1 being Element of F1() holds
      F4(b1) is Functor of F2() . b1,F3() . b1;


:: INDEX_1:funcnot 13 => INDEX_1:func 13
definition
  let a1 be non empty set;
  let a2, a3 be Category-yielding ManySortedSet of a1;
  let a4 be ManySortedFunctor of a2,a3;
  let a5 be Element of a1;
  redefine func a4 . a5 -> Functor of a2 . a5,a3 . a5;
end;

:: INDEX_1:modenot 6 => INDEX_1:mode 3
definition
  let a1, a2 be non empty set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  mode Indexing of A3,A4 -> Category-yielding_on_first ManySortedSet of a1,a2 means
    it `2 is ManySortedFunctor of it `1 * a3,it `1 * a4;
end;

:: INDEX_1:dfs 8
definiens
  let a1, a2 be non empty set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Category-yielding_on_first ManySortedSet of a1,a2;
To prove
     a5 is Indexing of a3,a4
it is sufficient to prove
  thus a5 `2 is ManySortedFunctor of a5 `1 * a3,a5 `1 * a4;

:: INDEX_1:def 8
theorem
for b1, b2 being non empty set
for b3, b4 being Function-like quasi_total Relation of b2,b1
for b5 being Category-yielding_on_first ManySortedSet of b1,b2 holds
      b5 is Indexing of b3,b4
   iff
      b5 `2 is ManySortedFunctor of b5 `1 * b3,b5 `1 * b4;

:: INDEX_1:th 4
theorem
for b1, b2 being non empty set
for b3, b4 being Function-like quasi_total Relation of b2,b1
for b5 being Indexing of b3,b4
for b6 being Element of b2 holds
   b5 `2 . b6 is Functor of b5 `1 . (b3 . b6),b5 `1 . (b4 . b6);

:: INDEX_1:th 5
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1
for b3 being Element of the Edges of b1 holds
   b2 `2 . b3 is Functor of b2 `1 . dom b3,b2 `1 . cod b3;

:: INDEX_1:funcnot 14 => INDEX_1:func 14
definition
  let a1, a2 be non empty set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Indexing of a3,a4;
  redefine func a5 `2 -> ManySortedFunctor of a5 `1 * a3,a5 `1 * a4;
end;

:: INDEX_1:modenot 7 => INDEX_1:mode 4
definition
  let a1, a2 be non empty set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Indexing of a3,a4;
  mode TargetCat of A5 -> non void Category-like Categorial CatStr means
    (for b1 being Element of a1 holds
        a5 `1 . b1 is Element of the Vertices of it) &
     (for b1 being Element of a2 holds
        [[a5 `1 . (a3 . b1),a5 `1 . (a4 . b1)],a5 `2 . b1] is Element of the Edges of it);
end;

:: INDEX_1:dfs 9
definiens
  let a1, a2 be non empty set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Indexing of a3,a4;
  let a6 be non void Category-like Categorial CatStr;
To prove
     a6 is TargetCat of a5
it is sufficient to prove
  thus (for b1 being Element of a1 holds
        a5 `1 . b1 is Element of the Vertices of a6) &
     (for b1 being Element of a2 holds
        [[a5 `1 . (a3 . b1),a5 `1 . (a4 . b1)],a5 `2 . b1] is Element of the Edges of a6);

:: INDEX_1:def 9
theorem
for b1, b2 being non empty set
for b3, b4 being Function-like quasi_total Relation of b2,b1
for b5 being Indexing of b3,b4
for b6 being non void Category-like Categorial CatStr holds
      b6 is TargetCat of b5
   iff
      (for b7 being Element of b1 holds
          b5 `1 . b7 is Element of the Vertices of b6) &
       (for b7 being Element of b2 holds
          [[b5 `1 . (b3 . b7),b5 `1 . (b4 . b7)],b5 `2 . b7] is Element of the Edges of b6);

:: INDEX_1:exreg 5
registration
  let a1, a2 be non empty set;
  let a3, a4 be Function-like quasi_total Relation of a2,a1;
  let a5 be Indexing of a3,a4;
  cluster strict non void Category-like with_triple-like_morphisms Categorial full TargetCat of a5;
end;

:: INDEX_1:modenot 8 => INDEX_1:mode 5
definition
  let a1, a2 be non empty 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;
  assume ex b1 being non void Category-like CatStr st
       b1 = CatStr(#a1,a2,a3,a4,a5,a6#);
  mode Indexing of A3,A4,A5,A6 -> Indexing of a3,a4 means
    (for b1 being Element of a1 holds
        it `2 . (a6 . b1) = id (it `1 . b1)) &
     (for b1, b2 being Element of a2
           st a3 . b2 = a4 . b1
        holds it `2 . (a5 . [b2,b1]) = (it `2 . b2) * (it `2 . b1));
end;

:: INDEX_1:dfs 10
definiens
  let a1, a2 be non empty 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 Indexing of a3,a4;
To prove
     a7 is Indexing of a3,a4,a5,a6
it is sufficient to prove
thus ex b1 being non void Category-like CatStr st
       b1 = CatStr(#a1,a2,a3,a4,a5,a6#);
  thus (for b1 being Element of a1 holds
        a7 `2 . (a6 . b1) = id (a7 `1 . b1)) &
     (for b1, b2 being Element of a2
           st a3 . b2 = a4 . b1
        holds a7 `2 . (a5 . [b2,b1]) = (a7 `2 . b2) * (a7 `2 . b1));

:: INDEX_1:def 10
theorem
for b1, b2 being non empty set
for b3, b4 being Function-like quasi_total Relation of b2,b1
for b5 being Function-like Relation of [:b2,b2:],b2
for b6 being Function-like quasi_total Relation of b1,b2
   st ex b7 being non void Category-like CatStr st
        b7 = CatStr(#b1,b2,b3,b4,b5,b6#)
for b7 being Indexing of b3,b4 holds
      b7 is Indexing of b3,b4,b5,b6
   iff
      (for b8 being Element of b1 holds
          b7 `2 . (b6 . b8) = id (b7 `1 . b8)) &
       (for b8, b9 being Element of b2
             st b3 . b9 = b4 . b8
          holds b7 `2 . (b5 . [b9,b8]) = (b7 `2 . b9) * (b7 `2 . b8));

:: INDEX_1:modenot 9
definition
  let a1 be non void Category-like CatStr;
  mode Indexing of a1 is Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1;
end;

:: INDEX_1:modenot 10
definition
  let a1 be non void Category-like CatStr;
  mode coIndexing of a1 is Indexing of the Target of a1,the Source of a1,~ the Comp of a1,the Id of a1;
end;

:: INDEX_1:th 6
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1 holds
      b2 is Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
   iff
      (for b3 being Element of the Vertices of b1 holds
          b2 `2 . id b3 = id (b2 `1 . b3)) &
       (for b3, b4 being Element of the Edges of b1
             st dom b4 = cod b3
          holds b2 `2 . (b4 * b3) = (b2 `2 . b4) * (b2 `2 . b3));

:: INDEX_1:th 7
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Target of b1,the Source of b1 holds
      b2 is Indexing of the Target of b1,the Source of b1,~ the Comp of b1,the Id of b1
   iff
      (for b3 being Element of the Vertices of b1 holds
          b2 `2 . id b3 = id (b2 `1 . b3)) &
       (for b3, b4 being Element of the Edges of b1
             st dom b4 = cod b3
          holds b2 `2 . (b4 * b3) = (b2 `2 . b3) * (b2 `2 . b4));

:: INDEX_1:th 8
theorem
for b1 being non void Category-like CatStr
for b2 being set holds
      b2 is Indexing of the Target of b1,the Source of b1,~ the Comp of b1,the Id of b1
   iff
      b2 is Indexing of the Source of b1 opp,the Target of b1 opp,the Comp of b1 opp,the Id of b1 opp;

:: INDEX_1:th 9
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3, b4 being Element of the Vertices of b1
   st Hom(b3,b4) is not empty
for b5 being Morphism of b3,b4 holds
   b2 `2 . b5 is Functor of b2 `1 . b3,b2 `1 . b4;

:: INDEX_1:th 10
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Target of b1,the Source of b1,~ the Comp of b1,the Id of b1
for b3, b4 being Element of the Vertices of b1
   st Hom(b3,b4) is not empty
for b5 being Morphism of b3,b4 holds
   b2 `2 . b5 is Functor of b2 `1 . b4,b2 `1 . b3;

:: INDEX_1:funcnot 15 => INDEX_1:func 15
definition
  let a1 be non void Category-like CatStr;
  let a2 be Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1;
  let a3 be TargetCat of a2;
  func A2 -functor(A1,A3) -> Functor of a1,a3 means
    for b1 being Element of the Edges of a1 holds
       it . b1 = [[a2 `1 . dom b1,a2 `1 . cod b1],a2 `2 . b1];
end;

:: INDEX_1:def 11
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being Functor of b1,b3 holds
      b4 = b2 -functor(b1,b3)
   iff
      for b5 being Element of the Edges of b1 holds
         b4 . b5 = [[b2 `1 . dom b5,b2 `1 . cod b5],b2 `2 . b5];

:: INDEX_1:th 11
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3, b4 being TargetCat of b2 holds
b2 -functor(b1,b3) = b2 -functor(b1,b4) &
 Obj (b2 -functor(b1,b3)) = Obj (b2 -functor(b1,b4));

:: INDEX_1:th 12
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2 holds
   Obj (b2 -functor(b1,b3)) = b2 `1;

:: INDEX_1:th 13
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being Element of the Vertices of b1 holds
   (b2 -functor(b1,b3)) . b4 = b2 `1 . b4;

:: INDEX_1:funcnot 16 => INDEX_1:func 16
definition
  let a1 be non void Category-like CatStr;
  let a2 be Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1;
  func rng A2 -> strict TargetCat of a2 means
    for b1 being TargetCat of a2 holds
       it = Image (a2 -functor(a1,b1));
end;

:: INDEX_1:def 12
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being strict TargetCat of b2 holds
      b3 = rng b2
   iff
      for b4 being TargetCat of b2 holds
         b3 = Image (b2 -functor(b1,b4));

:: INDEX_1:th 14
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being non void Category-like Categorial CatStr holds
      rng b2 is Subcategory of b3
   iff
      b3 is TargetCat of b2;

:: INDEX_1:funcnot 17 => INDEX_1:func 17
definition
  let a1 be non void Category-like CatStr;
  let a2 be Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1;
  let a3 be Element of the Edges of a1;
  func A2 . A3 -> Functor of a2 `1 . dom a3,a2 `1 . cod a3 equals
    a2 `2 . a3;
end;

:: INDEX_1:def 13
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being Element of the Edges of b1 holds
   b2 . b3 = b2 `2 . b3;

:: INDEX_1:funcnot 18 => INDEX_1:func 18
definition
  let a1 be non void Category-like CatStr;
  let a2 be Indexing of the Target of a1,the Source of a1,~ the Comp of a1,the Id of a1;
  let a3 be Element of the Edges of a1;
  func A2 . A3 -> Functor of a2 `1 . cod a3,a2 `1 . dom a3 equals
    a2 `2 . a3;
end;

:: INDEX_1:def 14
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Target of b1,the Source of b1,~ the Comp of b1,the Id of b1
for b3 being Element of the Edges of b1 holds
   b2 . b3 = b2 `2 . b3;

:: INDEX_1:th 15
theorem
for b1, b2 being non void Category-like CatStr holds
[(the Vertices of b1) --> b2,(the Edges of b1) --> id b2] is Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1 &
 [(the Vertices of b1) --> b2,(the Edges of b1) --> id b2] is Indexing of the Target of b1,the Source of b1,~ the Comp of b1,the Id of b1;

:: INDEX_1:funcreg 5
registration
  let a1 be non void Category-like CatStr;
  let a2 be non void Category-like Categorial CatStr;
  let a3 be Functor of a1,a2;
  cluster Obj a3 -> Function-like quasi_total Category-yielding;
end;

:: INDEX_1:th 16
theorem
for b1 being non void Category-like CatStr
for b2 being non void Category-like Categorial CatStr
for b3 being Functor of b1,b2 holds
   [Obj b3,pr2 b3] is Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1;

:: INDEX_1:funcnot 19 => INDEX_1:func 19
definition
  let a1 be non void Category-like CatStr;
  let a2 be non void Category-like Categorial CatStr;
  let a3 be Functor of a1,a2;
  func A3 -indexing_of A1 -> Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1 equals
    [Obj a3,pr2 a3];
end;

:: INDEX_1:def 15
theorem
for b1 being non void Category-like CatStr
for b2 being non void Category-like Categorial CatStr
for b3 being Functor of b1,b2 holds
   b3 -indexing_of b1 = [Obj b3,pr2 b3];

:: INDEX_1:th 17
theorem
for b1 being non void Category-like CatStr
for b2 being non void Category-like Categorial CatStr
for b3 being Functor of b1,b2 holds
   b2 is TargetCat of b3 -indexing_of b1;

:: INDEX_1:th 18
theorem
for b1 being non void Category-like CatStr
for b2 being non void Category-like Categorial CatStr
for b3 being Functor of b1,b2
for b4 being TargetCat of b3 -indexing_of b1 holds
   b3 = (b3 -indexing_of b1) -functor(b1,b4);

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

:: INDEX_1:th 20
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2 holds
   pr2 (b2 -functor(b1,b3)) = b2 `2;

:: INDEX_1:th 21
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2 holds
   (b2 -functor(b1,b3)) -indexing_of b1 = b2;

:: INDEX_1:funcnot 20 => INDEX_1:func 20
definition
  let a1, a2, a3 be non void Category-like CatStr;
  let a4 be Functor of a1,a2;
  let a5 be Indexing of the Source of a3,the Target of a3,the Comp of a3,the Id of a3;
  assume Image a4 is Subcategory of a3;
  func A5 * A4 -> Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1 means
    for b1 being Functor of a1,a3
          st b1 = a4
       holds it = ((a5 -functor(a3,rng a5)) * b1) -indexing_of a1;
end;

:: INDEX_1:def 16
theorem
for b1, b2, b3 being non void Category-like CatStr
for b4 being Functor of b1,b2
for b5 being Indexing of the Source of b3,the Target of b3,the Comp of b3,the Id of b3
   st Image b4 is Subcategory of b3
for b6 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1 holds
      b6 = b5 * b4
   iff
      for b7 being Functor of b1,b3
            st b7 = b4
         holds b6 = ((b5 -functor(b3,rng b5)) * b7) -indexing_of b1;

:: INDEX_1:th 22
theorem
for b1, b2, b3, b4 being non void Category-like CatStr
for b5 being Indexing of the Source of b4,the Target of b4,the Comp of b4,the Id of b4
for b6 being Functor of b1,b2
for b7 being Functor of b1,b3
      st Image b6 is Subcategory of b4 & Image b7 is Subcategory of b4 & b6 = b7
   holds b5 * b6 = b5 * b7;

:: INDEX_1:th 23
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b4 holds
   b4 * b3 = ((b4 -functor(b2,b5)) * b3) -indexing_of b1;

:: INDEX_1:th 24
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b4 holds
   b5 is TargetCat of b4 * b3;

:: INDEX_1:th 25
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b4 holds
   rng (b4 * b3) is Subcategory of b5;

:: INDEX_1:th 26
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 Indexing of the Source of b3,the Target of b3,the Comp of b3,the Id of b3 holds
   (b6 * b5) * b4 = b6 * (b5 * b4);

:: INDEX_1:funcnot 21 => INDEX_1:func 21
definition
  let a1 be non void Category-like CatStr;
  let a2 be Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1;
  let a3, a4 be non void Category-like Categorial CatStr;
  let a5 be Functor of a3,a4;
  assume a3 is TargetCat of a2;
  func A5 * A2 -> Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1 means
    for b1 being TargetCat of a2
    for b2 being Functor of b1,a4
          st b1 = a3 & b2 = a5
       holds it = (b2 * (a2 -functor(a1,b1))) -indexing_of a1;
end;

:: INDEX_1:def 17
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being non void Category-like Categorial CatStr
   st b3 is TargetCat of b2
for b4 being non void Category-like Categorial CatStr
for b5 being Functor of b3,b4
for b6 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1 holds
      b6 = b5 * b2
   iff
      for b7 being TargetCat of b2
      for b8 being Functor of b7,b4
            st b7 = b3 & b8 = b5
         holds b6 = (b8 * (b2 -functor(b1,b7))) -indexing_of b1;

:: INDEX_1:th 27
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4, b5 being non void Category-like Categorial CatStr
for b6 being Functor of b3,b4
for b7 being Functor of b3,b5
      st b6 = b7
   holds b6 * b2 = b7 * b2;

:: INDEX_1:th 28
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being non void Category-like Categorial CatStr
for b5 being Functor of b3,b4 holds
   Image b5 is TargetCat of b5 * b2;

:: INDEX_1:th 29
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being non void Category-like Categorial CatStr
for b5 being Functor of b3,b4 holds
   b4 is TargetCat of b5 * b2;

:: INDEX_1:th 30
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being non void Category-like Categorial CatStr
for b5 being Functor of b3,b4 holds
   rng (b5 * b2) is Subcategory of Image b5;

:: INDEX_1:th 31
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4, b5 being non void Category-like Categorial CatStr
for b6 being Functor of b3,b4
for b7 being Functor of b4,b5 holds
   (b7 * b6) * b2 = b7 * (b6 * b2);

:: INDEX_1:funcnot 22 => INDEX_1:func 22
definition
  let a1, a2 be non void Category-like CatStr;
  let a3 be Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1;
  let a4 be Indexing of the Source of a2,the Target of a2,the Comp of a2,the Id of a2;
  func A4 * A3 -> Indexing of the Source of a1,the Target of a1,the Comp of a1,the Id of a1 equals
    a4 * (a3 -functor(a1,rng a3));
end;

:: INDEX_1:def 18
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2 holds
   b4 * b3 = b4 * (b3 -functor(b1,rng b3));

:: INDEX_1:th 32
theorem
for b1 being non void Category-like CatStr
for b2 being non void Category-like Categorial CatStr
for b3 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b3
      st b2 is TargetCat of b3
   holds b4 * b3 = b4 * (b3 -functor(b1,b5));

:: INDEX_1:th 33
theorem
for b1 being non void Category-like CatStr
for b2 being non void Category-like Categorial CatStr
for b3 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b4
      st b2 is TargetCat of b3
   holds b4 * b3 = (b4 -functor(b2,b5)) * b3;

:: INDEX_1:th 34
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b4
for b6 being non void Category-like Categorial CatStr
for b7 being Functor of b5,b6 holds
   (b7 * b4) * b3 = b7 * (b4 * b3);

:: INDEX_1:th 35
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being non void Category-like Categorial CatStr
for b5 being Functor of b3,b4
for b6 being Indexing of the Source of b4,the Target of b4,the Comp of b4,the Id of b4 holds
   (b6 * b5) * b2 = b6 * (b5 * b2);

:: INDEX_1:th 36
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being Indexing of the Source of b3,the Target of b3,the Comp of b3,the Id of b3
for b5 being TargetCat of b4
for b6 being non void Category-like Categorial CatStr
for b7 being Functor of b5,b6 holds
   (b7 * b4) * b2 = b7 * (b4 * b2);

:: INDEX_1:th 37
theorem
for b1, b2 being non void Category-like CatStr
for b3 being Functor of b1,b2
for b4 being Indexing of the Source of b2,the Target of b2,the Comp of b2,the Id of b2
for b5 being TargetCat of b4
for b6 being Indexing of the Source of b5,the Target of b5,the Comp of b5,the Id of b5 holds
   (b6 * b4) * b3 = b6 * (b4 * b3);

:: INDEX_1:th 38
theorem
for b1 being non void Category-like CatStr
for b2 being Indexing of the Source of b1,the Target of b1,the Comp of b1,the Id of b1
for b3 being TargetCat of b2
for b4 being Indexing of the Source of b3,the Target of b3,the Comp of b3,the Id of b3
for b5 being TargetCat of b4
for b6 being Indexing of the Source of b5,the Target of b5,the Comp of b5,the Id of b5 holds
   (b6 * b4) * b2 = b6 * (b4 * b2);