Article FUNCTOR0, MML version 4.99.1005

:: FUNCTOR0:sch 1
scheme FUNCTOR0:sch 1
{F1 -> non empty set,
  F2 -> Relation-like Function-like set,
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> set}:
F2() .(F3(),F4()) = F5(F3(), F4())
provided
   F2() = {[[b1,b2],F5(b1, b2)] where b1 is Element of F1(), b2 is Element of F1(): P1[b1, b2]}
and
   P1[F3(), F4()];


:: FUNCTOR0:th 1
theorem
for b1 being set holds
   {} is Function-like quasi_total Relation of b1,{};

:: FUNCTOR0:th 3
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   (id b1) * b2 = b2;

:: FUNCTOR0:funcreg 1
registration
  let a1 be Relation-like Function-like empty set;
  cluster ~ a1 -> Relation-like Function-like empty;
end;

:: FUNCTOR0:funcreg 2
registration
  let a1 be Relation-like Function-like empty set;
  let a2 be Relation-like Function-like set;
  cluster [:a1,a2:] -> Relation-like Function-like empty;
end;

:: FUNCTOR0:funcreg 3
registration
  let a1 be Relation-like Function-like empty set;
  let a2 be Relation-like Function-like set;
  cluster [:a2,a1:] -> Relation-like Function-like empty;
end;

:: FUNCTOR0:th 4
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   b2 .: id b1 = (~ b2) .: id b1;

:: FUNCTOR0:th 5
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of b1,b2 holds
      b3 is onto(b1, b2)
   iff
      [:b3,b3:] is onto([:b1,b1:], [:b2,b2:]);

:: FUNCTOR0:funcreg 4
registration
  let a1 be Relation-like Function-like Function-yielding set;
  cluster ~ a1 -> Relation-like Function-like Function-yielding;
end;

:: FUNCTOR0:th 6
theorem
for b1, b2, b3 being set holds
~ ([:b1,b2:] --> b3) = [:b2,b1:] --> b3;

:: FUNCTOR0:th 7
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one & b2 is one-to-one
   holds [:b1,b2:] " = [:b1 ",b2 ":];

:: FUNCTOR0:th 8
theorem
for b1 being Relation-like Function-like set
      st [:b1,b1:] is one-to-one
   holds b1 is one-to-one;

:: FUNCTOR0:th 9
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds ~ b1 is one-to-one;

:: FUNCTOR0:th 10
theorem
for b1, b2 being Relation-like Function-like set
      st ~ [:b1,b2:] is one-to-one
   holds [:b2,b1:] is one-to-one;

:: FUNCTOR0:th 11
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one & b2 is one-to-one
   holds (~ [:b1,b2:]) " = ~ ([:b2,b1:] ");

:: FUNCTOR0:th 12
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of b1,b2
      st b3 is onto(b1, b2)
   holds id b2 c= [:b3,b3:] .: id b1;

:: FUNCTOR0:th 13
theorem
for b1, b2 being Relation-like Function-like Function-yielding set
for b3 being Relation-like Function-like set holds
   b3 * (b2 ** b1) = (b3 * b2) ** (b3 * b1);

:: FUNCTOR0:funcnot 1 => FUNCTOR0:func 1
definition
  let a1, a2, a3 be set;
  let a4 be Function-like quasi_total Relation of [:a1,a2:],a3;
  redefine func ~ a4 -> Function-like quasi_total Relation of [:a2,a1:],a3;
end;

:: FUNCTOR0:th 14
theorem
for b1, b2, b3 being set
for b4 being Function-like quasi_total Relation of [:b1,b2:],b3
      st ~ b4 is onto([:b2,b1:], b3)
   holds b4 is onto([:b1,b2:], b3);

:: FUNCTOR0:th 15
theorem
for b1 being set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b1,b2 holds
   [:b3,b3:] .: id b1 c= id b2;

:: FUNCTOR0:modenot 1
definition
  let a1, a2 be set;
  mode bifunction of a1,a2 is Function-like quasi_total Relation of [:a1,a1:],[:a2,a2:];
end;

:: FUNCTOR0:attrnot 1 => FUNCTOR0:attr 1
definition
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],[:a2,a2:];
  attr a3 is Covariant means
    ex b1 being Function-like quasi_total Relation of a1,a2 st
       a3 = [:b1,b1:];
end;

:: FUNCTOR0:dfs 1
definiens
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],[:a2,a2:];
To prove
     a3 is Covariant
it is sufficient to prove
  thus ex b1 being Function-like quasi_total Relation of a1,a2 st
       a3 = [:b1,b1:];

:: FUNCTOR0:def 2
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of [:b1,b1:],[:b2,b2:] holds
      b3 is Covariant(b1, b2)
   iff
      ex b4 being Function-like quasi_total Relation of b1,b2 st
         b3 = [:b4,b4:];

:: FUNCTOR0:attrnot 2 => FUNCTOR0:attr 2
definition
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],[:a2,a2:];
  attr a3 is Contravariant means
    ex b1 being Function-like quasi_total Relation of a1,a2 st
       a3 = ~ [:b1,b1:];
end;

:: FUNCTOR0:dfs 2
definiens
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],[:a2,a2:];
To prove
     a3 is Contravariant
it is sufficient to prove
  thus ex b1 being Function-like quasi_total Relation of a1,a2 st
       a3 = ~ [:b1,b1:];

:: FUNCTOR0:def 3
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of [:b1,b1:],[:b2,b2:] holds
      b3 is Contravariant(b1, b2)
   iff
      ex b4 being Function-like quasi_total Relation of b1,b2 st
         b3 = ~ [:b4,b4:];

:: FUNCTOR0:th 16
theorem
for b1 being set
for b2 being non empty set
for b3 being Element of b2
for b4 being Function-like quasi_total Relation of [:b1,b1:],[:b2,b2:]
      st b4 = [:b1,b1:] --> [b3,b3]
   holds b4 is Covariant(b1, b2) & b4 is Contravariant(b1, b2);

:: FUNCTOR0:exreg 1
registration
  let a1, a2 be set;
  cluster Relation-like Function-like quasi_total Covariant Contravariant Relation of [:a1,a1:],[:a2,a2:];
end;

:: FUNCTOR0:th 17
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total Covariant Contravariant Relation of [:b1,b1:],[:b2,b2:] holds
   ex b4 being Element of b2 st
      b3 = [:b1,b1:] --> [b4,b4];

:: FUNCTOR0:modenot 2 => FUNCTOR0:mode 1
definition
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be ManySortedSet of a1;
  let a5 be ManySortedSet of a2;
  mode MSUnTrans of A3,A4,A5 -> ManySortedSet of a1 means
    ex b1 being non empty set st
       ex b2 being ManySortedSet of b1 st
          ex b3 being Function-like quasi_total Relation of a1,b1 st
             a3 = b3 & a5 = b2 & it is ManySortedFunction of a4,b2 * b3
    if a2 <> {}
    otherwise it = [0] a1;
end;

:: FUNCTOR0:dfs 3
definiens
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be ManySortedSet of a1;
  let a5 be ManySortedSet of a2;
  let a6 be ManySortedSet of a1;
To prove
     a6 is MSUnTrans of a3,a4,a5
it is sufficient to prove
  per cases;
  case a2 <> {};
    thus ex b1 being non empty set st
       ex b2 being ManySortedSet of b1 st
          ex b3 being Function-like quasi_total Relation of a1,b1 st
             a3 = b3 & a5 = b2 & a6 is ManySortedFunction of a4,b2 * b3;
  end;
  case a2 = {};
    thus a6 = [0] a1;
  end;

:: FUNCTOR0:def 4
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being ManySortedSet of b1
for b5 being ManySortedSet of b2
for b6 being ManySortedSet of b1 holds
   (b2 = {} or    (b6 is MSUnTrans of b3,b4,b5
    iff
       ex b7 being non empty set st
          ex b8 being ManySortedSet of b7 st
             ex b9 being Function-like quasi_total Relation of b1,b7 st
                b3 = b9 & b5 = b8 & b6 is ManySortedFunction of b4,b8 * b9)) &
    (b2 = {} implies    (b6 is MSUnTrans of b3,b4,b5
    iff
       b6 = [0] b1));

:: FUNCTOR0:modenot 3 => FUNCTOR0:mode 1
definition
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be ManySortedSet of a1;
  let a5 be ManySortedSet of a2;
  mode MSUnTrans of A3,A4,A5 -> ManySortedSet of a1 means
    it is ManySortedFunction of a4,a5 * a3;
end;

:: FUNCTOR0:dfs 4
definiens
  let a1 be set;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be ManySortedSet of a1;
  let a5 be ManySortedSet of a2;
  let a6 be ManySortedSet of a1;
To prove
     a6 is MSUnTrans of a3,a4,a5
it is sufficient to prove
  thus a6 is ManySortedFunction of a4,a5 * a3;

:: FUNCTOR0:def 5
theorem
for b1 being set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being ManySortedSet of b1
for b5 being ManySortedSet of b2
for b6 being ManySortedSet of b1 holds
      b6 is MSUnTrans of b3,b4,b5
   iff
      b6 is ManySortedFunction of b4,b5 * b3;

:: FUNCTOR0:condreg 1
registration
  let a1, a2 be set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be ManySortedSet of a1;
  let a5 be ManySortedSet of a2;
  cluster -> Function-yielding (MSUnTrans of a3,a4,a5);
end;

:: FUNCTOR0:th 18
theorem
for b1 being set
for b2, b3 being non empty set
for b4 being Function-like quasi_total Relation of b1,b2
for b5 being Function-like quasi_total Relation of b2,b3
for b6 being ManySortedSet of b2
for b7 being ManySortedSet of b3
for b8 being MSUnTrans of b5,b6,b7 holds
   b8 * b4 is MSUnTrans of b5 * b4,b6 * b4,b7;

:: FUNCTOR0:funcnot 2 => FUNCTOR0:func 2
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 ManySortedSet of [:a1,a1:];
  let a5 be ManySortedSet of [:a2,a2:];
  let a6 be MSUnTrans of [:a3,a3:],a4,a5;
  redefine func ~ a6 -> MSUnTrans of [:a3,a3:],~ a4,~ a5;
end;

:: FUNCTOR0:th 19
theorem
for b1, b2 being non empty set
for b3 being ManySortedSet of b1
for b4 being ManySortedSet of b2
for b5 being Element of b2
   st b4 . b5 <> {}
for b6 being Element of b4 . b5
for b7 being Function-like quasi_total Relation of b1,b2
      st b7 = b1 --> b5
   holds {[b8,(b3 . b8) --> b6] where b8 is Element of b1: TRUE} is MSUnTrans of b7,b3,b4;

:: FUNCTOR0:th 20
theorem
for b1 being set
for b2, b3 being non empty set
for b4 being Function-like quasi_total Relation of b1,b2
for b5 being Function-like quasi_total Relation of b2,b3
for b6 being ManySortedSet of b1
for b7 being ManySortedSet of b2
for b8 being ManySortedSet of b3
for b9 being MSUnTrans of b4,b6,b7
for b10 being MSUnTrans of b5 * b4,b7 * b4,b8
      st for b11 being set
              st b11 in b1 & (b7 * b4) . b11 = {} & b6 . b11 <> {}
           holds (b8 * (b5 * b4)) . b11 = {}
   holds b10 ** b9 is MSUnTrans of b5 * b4,b6,b8;

:: FUNCTOR0:structnot 1 => FUNCTOR0:struct 1
definition
  let a1, a2 be 1-sorted;
  struct() BimapStr(#
    ObjectMap -> Function-like quasi_total Relation of [:the carrier of A1,the carrier of A1:],[:the carrier of A2,the carrier of A2:]
  #);
end;

:: FUNCTOR0:attrnot 3 => FUNCTOR0:attr 3
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is strict;
end;

:: FUNCTOR0:exreg 2
registration
  let a1, a2 be 1-sorted;
  cluster strict BimapStr over a1,a2;
end;

:: FUNCTOR0:aggrnot 1 => FUNCTOR0:aggr 1
definition
  let a1, a2 be 1-sorted;
  let a3 be Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],[:the carrier of a2,the carrier of a2:];
  aggr BimapStr(#a3#) -> strict BimapStr over a1,a2;
end;

:: FUNCTOR0:selnot 1 => FUNCTOR0:sel 1
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  sel the ObjectMap of a3 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],[:the carrier of a2,the carrier of a2:];
end;

:: FUNCTOR0:funcnot 3 => FUNCTOR0:func 3
definition
  let a1, a2 be non empty AltGraph;
  let a3 be BimapStr over a1,a2;
  let a4 be Element of the carrier of a1;
  func A3 . A4 -> Element of the carrier of a2 equals
    ((the ObjectMap of a3) .(a4,a4)) `1;
end;

:: FUNCTOR0:def 6
theorem
for b1, b2 being non empty AltGraph
for b3 being BimapStr over b1,b2
for b4 being Element of the carrier of b1 holds
   b3 . b4 = ((the ObjectMap of b3) .(b4,b4)) `1;

:: FUNCTOR0:attrnot 4 => FUNCTOR0:attr 4
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is one-to-one means
    the ObjectMap of a3 is one-to-one;
end;

:: FUNCTOR0:dfs 6
definiens
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is one-to-one
it is sufficient to prove
  thus the ObjectMap of a3 is one-to-one;

:: FUNCTOR0:def 7
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2 holds
      b3 is one-to-one(b1, b2)
   iff
      the ObjectMap of b3 is one-to-one;

:: FUNCTOR0:attrnot 5 => FUNCTOR0:attr 5
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is onto means
    the ObjectMap of a3 is onto([:the carrier of a1,the carrier of a1:], [:the carrier of a2,the carrier of a2:]);
end;

:: FUNCTOR0:dfs 7
definiens
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is onto
it is sufficient to prove
  thus the ObjectMap of a3 is onto([:the carrier of a1,the carrier of a1:], [:the carrier of a2,the carrier of a2:]);

:: FUNCTOR0:def 8
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2 holds
      b3 is onto(b1, b2)
   iff
      the ObjectMap of b3 is onto([:the carrier of b1,the carrier of b1:], [:the carrier of b2,the carrier of b2:]);

:: FUNCTOR0:attrnot 6 => FUNCTOR0:attr 6
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is reflexive means
    (the ObjectMap of a3) .: id the carrier of a1 c= id the carrier of a2;
end;

:: FUNCTOR0:dfs 8
definiens
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is reflexive
it is sufficient to prove
  thus (the ObjectMap of a3) .: id the carrier of a1 c= id the carrier of a2;

:: FUNCTOR0:def 9
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2 holds
      b3 is reflexive(b1, b2)
   iff
      (the ObjectMap of b3) .: id the carrier of b1 c= id the carrier of b2;

:: FUNCTOR0:attrnot 7 => FUNCTOR0:attr 7
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is coreflexive means
    id the carrier of a2 c= (the ObjectMap of a3) .: id the carrier of a1;
end;

:: FUNCTOR0:dfs 9
definiens
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is coreflexive
it is sufficient to prove
  thus id the carrier of a2 c= (the ObjectMap of a3) .: id the carrier of a1;

:: FUNCTOR0:def 10
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2 holds
      b3 is coreflexive(b1, b2)
   iff
      id the carrier of b2 c= (the ObjectMap of b3) .: id the carrier of b1;

:: FUNCTOR0:attrnot 8 => FUNCTOR0:attr 6
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is reflexive means
    for b1 being Element of the carrier of a1 holds
       (the ObjectMap of a3) .(b1,b1) = [a3 . b1,a3 . b1];
end;

:: FUNCTOR0:dfs 10
definiens
  let a1, a2 be non empty AltGraph;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is reflexive
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (the ObjectMap of a3) .(b1,b1) = [a3 . b1,a3 . b1];

:: FUNCTOR0:def 11
theorem
for b1, b2 being non empty AltGraph
for b3 being BimapStr over b1,b2 holds
      b3 is reflexive(b1, b2)
   iff
      for b4 being Element of the carrier of b1 holds
         (the ObjectMap of b3) .(b4,b4) = [b3 . b4,b3 . b4];

:: FUNCTOR0:th 21
theorem
for b1, b2 being non empty reflexive AltGraph
for b3 being BimapStr over b1,b2
   st b3 is coreflexive(b1, b2)
for b4 being Element of the carrier of b2 holds
   ex b5 being Element of the carrier of b1 st
      b3 . b5 = b4;

:: FUNCTOR0:attrnot 9 => FUNCTOR0:attr 8
definition
  let a1, a2 be non empty AltGraph;
  let a3 be BimapStr over a1,a2;
  attr a3 is feasible means
    for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds (the Arrows of a2) . ((the ObjectMap of a3) .(b1,b2)) <> {};
end;

:: FUNCTOR0:dfs 11
definiens
  let a1, a2 be non empty AltGraph;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is feasible
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds (the Arrows of a2) . ((the ObjectMap of a3) .(b1,b2)) <> {};

:: FUNCTOR0:def 12
theorem
for b1, b2 being non empty AltGraph
for b3 being BimapStr over b1,b2 holds
      b3 is feasible(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1
            st <^b4,b5^> <> {}
         holds (the Arrows of b2) . ((the ObjectMap of b3) .(b4,b5)) <> {};

:: FUNCTOR0:structnot 2 => FUNCTOR0:struct 2
definition
  let a1, a2 be AltGraph;
  struct(BimapStr over a1,a2) FunctorStr(#
    ObjectMap -> Function-like quasi_total Relation of [:the carrier of A1,the carrier of A1:],[:the carrier of A2,the carrier of A2:],
    MorphMap -> MSUnTrans of the ObjectMap of it,the Arrows of A1,the Arrows of A2
  #);
end;

:: FUNCTOR0:attrnot 10 => FUNCTOR0:attr 9
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is strict;
end;

:: FUNCTOR0:exreg 3
registration
  let a1, a2 be AltGraph;
  cluster strict FunctorStr over a1,a2;
end;

:: FUNCTOR0:aggrnot 2 => FUNCTOR0:aggr 2
definition
  let a1, a2 be AltGraph;
  let a3 be Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],[:the carrier of a2,the carrier of a2:];
  let a4 be MSUnTrans of a3,the Arrows of a1,the Arrows of a2;
  aggr FunctorStr(#a3,a4#) -> strict FunctorStr over a1,a2;
end;

:: FUNCTOR0:selnot 2 => FUNCTOR0:sel 2
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  sel the MorphMap of a3 -> MSUnTrans of the ObjectMap of a3,the Arrows of a1,the Arrows of a2;
end;

:: FUNCTOR0:attrnot 11 => FUNCTOR0:attr 10
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is Covariant means
    the ObjectMap of a3 is Covariant(the carrier of a1, the carrier of a2);
end;

:: FUNCTOR0:dfs 12
definiens
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is Covariant
it is sufficient to prove
  thus the ObjectMap of a3 is Covariant(the carrier of a1, the carrier of a2);

:: FUNCTOR0:def 13
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2 holds
      b3 is Covariant(b1, b2)
   iff
      the ObjectMap of b3 is Covariant(the carrier of b1, the carrier of b2);

:: FUNCTOR0:attrnot 12 => FUNCTOR0:attr 11
definition
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
  attr a3 is Contravariant means
    the ObjectMap of a3 is Contravariant(the carrier of a1, the carrier of a2);
end;

:: FUNCTOR0:dfs 13
definiens
  let a1, a2 be 1-sorted;
  let a3 be BimapStr over a1,a2;
To prove
     a3 is Contravariant
it is sufficient to prove
  thus the ObjectMap of a3 is Contravariant(the carrier of a1, the carrier of a2);

:: FUNCTOR0:def 14
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2 holds
      b3 is Contravariant(b1, b2)
   iff
      the ObjectMap of b3 is Contravariant(the carrier of b1, the carrier of b2);

:: FUNCTOR0:exreg 4
registration
  let a1, a2 be AltGraph;
  cluster Covariant FunctorStr over a1,a2;
end;

:: FUNCTOR0:exreg 5
registration
  let a1, a2 be AltGraph;
  cluster Contravariant FunctorStr over a1,a2;
end;

:: FUNCTOR0:funcnot 4 => FUNCTOR0:func 4
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  let a4, a5 be Element of the carrier of a1;
  func Morph-Map(A3,A4,A5) -> set equals
    (the MorphMap of a3) .(a4,a5);
end;

:: FUNCTOR0:def 15
theorem
for b1, b2 being AltGraph
for b3 being FunctorStr over b1,b2
for b4, b5 being Element of the carrier of b1 holds
Morph-Map(b3,b4,b5) = (the MorphMap of b3) .(b4,b5);

:: FUNCTOR0:funcreg 5
registration
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  let a4, a5 be Element of the carrier of a1;
  cluster Morph-Map(a3,a4,a5) -> Relation-like Function-like;
end;

:: FUNCTOR0:funcnot 5 => FUNCTOR0:func 5
definition
  let a1, a2 be non empty AltGraph;
  let a3 be Covariant FunctorStr over a1,a2;
  let a4, a5 be Element of the carrier of a1;
  redefine func Morph-Map(a3,a4,a5) -> Function-like quasi_total Relation of <^a4,a5^>,<^a3 . a4,a3 . a5^>;
end;

:: FUNCTOR0:funcnot 6 => FUNCTOR0:func 6
definition
  let a1, a2 be non empty AltGraph;
  let a3 be Covariant FunctorStr over a1,a2;
  let a4, a5 be Element of the carrier of a1;
  let a6 be Element of <^a4,a5^>;
  assume <^a4,a5^> <> {} &
     <^a3 . a4,a3 . a5^> <> {};
  func A3 . A6 -> Element of <^a3 . a4,a3 . a5^> equals
    (Morph-Map(a3,a4,a5)) . a6;
end;

:: FUNCTOR0:def 16
theorem
for b1, b2 being non empty AltGraph
for b3 being Covariant FunctorStr over b1,b2
for b4, b5 being Element of the carrier of b1
   st <^b4,b5^> <> {} &
      <^b3 . b4,b3 . b5^> <> {}
for b6 being Element of <^b4,b5^> holds
   b3 . b6 = (Morph-Map(b3,b4,b5)) . b6;

:: FUNCTOR0:funcnot 7 => FUNCTOR0:func 7
definition
  let a1, a2 be non empty AltGraph;
  let a3 be Contravariant FunctorStr over a1,a2;
  let a4, a5 be Element of the carrier of a1;
  redefine func Morph-Map(a3,a4,a5) -> Function-like quasi_total Relation of <^a4,a5^>,<^a3 . a5,a3 . a4^>;
end;

:: FUNCTOR0:funcnot 8 => FUNCTOR0:func 8
definition
  let a1, a2 be non empty AltGraph;
  let a3 be Contravariant FunctorStr over a1,a2;
  let a4, a5 be Element of the carrier of a1;
  let a6 be Element of <^a4,a5^>;
  assume <^a4,a5^> <> {} &
     <^a3 . a5,a3 . a4^> <> {};
  func A3 . A6 -> Element of <^a3 . a5,a3 . a4^> equals
    (Morph-Map(a3,a4,a5)) . a6;
end;

:: FUNCTOR0:def 17
theorem
for b1, b2 being non empty AltGraph
for b3 being Contravariant FunctorStr over b1,b2
for b4, b5 being Element of the carrier of b1
   st <^b4,b5^> <> {} &
      <^b3 . b5,b3 . b4^> <> {}
for b6 being Element of <^b4,b5^> holds
   b3 . b6 = (Morph-Map(b3,b4,b5)) . b6;

:: FUNCTOR0:funcnot 9 => FUNCTOR0:func 9
definition
  let a1, a2 be non empty AltGraph;
  let a3 be Element of the carrier of a2;
  let a4 be Element of <^a3,a3^>;
  assume <^a3,a3^> <> {};
  func A1 --> A4 -> strict FunctorStr over a1,a2 means
    the ObjectMap of it = [:the carrier of a1,the carrier of a1:] --> [a3,a3] &
     the MorphMap of it = {[[b1,b2],<^b1,b2^> --> a4] where b1 is Element of the carrier of a1, b2 is Element of the carrier of a1: TRUE};
end;

:: FUNCTOR0:def 18
theorem
for b1, b2 being non empty AltGraph
for b3 being Element of the carrier of b2
   st <^b3,b3^> <> {}
for b4 being Element of <^b3,b3^>
for b5 being strict FunctorStr over b1,b2 holds
      b5 = b1 --> b4
   iff
      the ObjectMap of b5 = [:the carrier of b1,the carrier of b1:] --> [b3,b3] &
       the MorphMap of b5 = {[[b6,b7],<^b6,b7^> --> b4] where b6 is Element of the carrier of b1, b7 is Element of the carrier of b1: TRUE};

:: FUNCTOR0:th 22
theorem
for b1, b2 being non empty AltGraph
for b3 being Element of the carrier of b2
   st <^b3,b3^> <> {}
for b4 being Element of <^b3,b3^>
for b5 being Element of the carrier of b1 holds
   (b1 --> b4) . b5 = b3;

:: FUNCTOR0:funcreg 6
registration
  let a1 be non empty AltGraph;
  let a2 be non empty reflexive AltGraph;
  let a3 be Element of the carrier of a2;
  let a4 be Element of <^a3,a3^>;
  cluster a1 --> a4 -> feasible strict Covariant Contravariant;
end;

:: FUNCTOR0:exreg 6
registration
  let a1 be non empty AltGraph;
  let a2 be non empty reflexive AltGraph;
  cluster feasible Covariant Contravariant FunctorStr over a1,a2;
end;

:: FUNCTOR0:th 23
theorem
for b1, b2 being non empty AltGraph
for b3 being Covariant FunctorStr over b1,b2
for b4, b5 being Element of the carrier of b1 holds
(the ObjectMap of b3) .(b4,b5) = [b3 . b4,b3 . b5];

:: FUNCTOR0:attrnot 13 => FUNCTOR0:attr 8
definition
  let a1, a2 be non empty AltGraph;
  let a3 be BimapStr over a1,a2;
  attr a3 is feasible means
    for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds <^a3 . b1,a3 . b2^> <> {};
end;

:: FUNCTOR0:dfs 18
definiens
  let a1, a2 be non empty AltGraph;
  let a3 be Covariant FunctorStr over a1,a2;
To prove
     a3 is feasible
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds <^a3 . b1,a3 . b2^> <> {};

:: FUNCTOR0:def 19
theorem
for b1, b2 being non empty AltGraph
for b3 being Covariant FunctorStr over b1,b2 holds
      b3 is feasible(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1
            st <^b4,b5^> <> {}
         holds <^b3 . b4,b3 . b5^> <> {};

:: FUNCTOR0:th 24
theorem
for b1, b2 being non empty AltGraph
for b3 being Contravariant FunctorStr over b1,b2
for b4, b5 being Element of the carrier of b1 holds
(the ObjectMap of b3) .(b4,b5) = [b3 . b5,b3 . b4];

:: FUNCTOR0:attrnot 14 => FUNCTOR0:attr 8
definition
  let a1, a2 be non empty AltGraph;
  let a3 be BimapStr over a1,a2;
  attr a3 is feasible means
    for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds <^a3 . b2,a3 . b1^> <> {};
end;

:: FUNCTOR0:dfs 19
definiens
  let a1, a2 be non empty AltGraph;
  let a3 be Contravariant FunctorStr over a1,a2;
To prove
     a3 is feasible
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds <^a3 . b2,a3 . b1^> <> {};

:: FUNCTOR0:def 20
theorem
for b1, b2 being non empty AltGraph
for b3 being Contravariant FunctorStr over b1,b2 holds
      b3 is feasible(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1
            st <^b4,b5^> <> {}
         holds <^b3 . b5,b3 . b4^> <> {};

:: FUNCTOR0:funcreg 7
registration
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  cluster the MorphMap of a3 -> Function-yielding;
end;

:: FUNCTOR0:exreg 7
registration
  cluster non empty reflexive AltCatStr;
end;

:: FUNCTOR0:attrnot 15 => FUNCTOR0:attr 12
definition
  let a1, a2 be non empty with_units AltCatStr;
  let a3 be FunctorStr over a1,a2;
  attr a3 is id-preserving means
    for b1 being Element of the carrier of a1 holds
       (Morph-Map(a3,b1,b1)) . idm b1 = idm (a3 . b1);
end;

:: FUNCTOR0:dfs 20
definiens
  let a1, a2 be non empty with_units AltCatStr;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is id-preserving
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (Morph-Map(a3,b1,b1)) . idm b1 = idm (a3 . b1);

:: FUNCTOR0:def 21
theorem
for b1, b2 being non empty with_units AltCatStr
for b3 being FunctorStr over b1,b2 holds
      b3 is id-preserving(b1, b2)
   iff
      for b4 being Element of the carrier of b1 holds
         (Morph-Map(b3,b4,b4)) . idm b4 = idm (b3 . b4);

:: FUNCTOR0:th 25
theorem
for b1, b2 being non empty AltGraph
for b3 being Element of the carrier of b2
   st <^b3,b3^> <> {}
for b4 being Element of <^b3,b3^>
for b5, b6 being Element of the carrier of b1
for b7 being Element of <^b5,b6^>
      st <^b5,b6^> <> {}
   holds (Morph-Map(b1 --> b4,b5,b6)) . b7 = b4;

:: FUNCTOR0:condreg 2
registration
  cluster non empty with_units -> reflexive (AltCatStr);
end;

:: FUNCTOR0:funcreg 8
registration
  let a1, a2 be non empty with_units AltCatStr;
  let a3 be Element of the carrier of a2;
  cluster a1 --> idm a3 -> strict id-preserving;
end;

:: FUNCTOR0:funcreg 9
registration
  let a1 be non empty AltGraph;
  let a2 be non empty reflexive AltGraph;
  let a3 be Element of the carrier of a2;
  let a4 be Element of <^a3,a3^>;
  cluster a1 --> a4 -> reflexive strict;
end;

:: FUNCTOR0:exreg 8
registration
  let a1 be non empty AltGraph;
  let a2 be non empty reflexive AltGraph;
  cluster reflexive feasible FunctorStr over a1,a2;
end;

:: FUNCTOR0:exreg 9
registration
  let a1, a2 be non empty with_units AltCatStr;
  cluster reflexive feasible strict id-preserving FunctorStr over a1,a2;
end;

:: FUNCTOR0:attrnot 16 => FUNCTOR0:attr 13
definition
  let a1, a2 be non empty AltCatStr;
  let a3 be FunctorStr over a1,a2;
  attr a3 is comp-preserving means
    for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       ex b6 being Element of <^a3 . b1,a3 . b2^> st
          ex b7 being Element of <^a3 . b2,a3 . b3^> st
             b6 = (Morph-Map(a3,b1,b2)) . b4 &
              b7 = (Morph-Map(a3,b2,b3)) . b5 &
              (Morph-Map(a3,b1,b3)) . (b5 * b4) = b7 * b6;
end;

:: FUNCTOR0:dfs 21
definiens
  let a1, a2 be non empty AltCatStr;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is comp-preserving
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       ex b6 being Element of <^a3 . b1,a3 . b2^> st
          ex b7 being Element of <^a3 . b2,a3 . b3^> st
             b6 = (Morph-Map(a3,b1,b2)) . b4 &
              b7 = (Morph-Map(a3,b2,b3)) . b5 &
              (Morph-Map(a3,b1,b3)) . (b5 * b4) = b7 * b6;

:: FUNCTOR0:def 22
theorem
for b1, b2 being non empty AltCatStr
for b3 being FunctorStr over b1,b2 holds
      b3 is comp-preserving(b1, b2)
   iff
      for b4, b5, b6 being Element of the carrier of b1
         st <^b4,b5^> <> {} & <^b5,b6^> <> {}
      for b7 being Element of <^b4,b5^>
      for b8 being Element of <^b5,b6^> holds
         ex b9 being Element of <^b3 . b4,b3 . b5^> st
            ex b10 being Element of <^b3 . b5,b3 . b6^> st
               b9 = (Morph-Map(b3,b4,b5)) . b7 &
                b10 = (Morph-Map(b3,b5,b6)) . b8 &
                (Morph-Map(b3,b4,b6)) . (b8 * b7) = b10 * b9;

:: FUNCTOR0:attrnot 17 => FUNCTOR0:attr 14
definition
  let a1, a2 be non empty AltCatStr;
  let a3 be FunctorStr over a1,a2;
  attr a3 is comp-reversing means
    for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       ex b6 being Element of <^a3 . b2,a3 . b1^> st
          ex b7 being Element of <^a3 . b3,a3 . b2^> st
             b6 = (Morph-Map(a3,b1,b2)) . b4 &
              b7 = (Morph-Map(a3,b2,b3)) . b5 &
              (Morph-Map(a3,b1,b3)) . (b5 * b4) = b6 * b7;
end;

:: FUNCTOR0:dfs 22
definiens
  let a1, a2 be non empty AltCatStr;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is comp-reversing
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       ex b6 being Element of <^a3 . b2,a3 . b1^> st
          ex b7 being Element of <^a3 . b3,a3 . b2^> st
             b6 = (Morph-Map(a3,b1,b2)) . b4 &
              b7 = (Morph-Map(a3,b2,b3)) . b5 &
              (Morph-Map(a3,b1,b3)) . (b5 * b4) = b6 * b7;

:: FUNCTOR0:def 23
theorem
for b1, b2 being non empty AltCatStr
for b3 being FunctorStr over b1,b2 holds
      b3 is comp-reversing(b1, b2)
   iff
      for b4, b5, b6 being Element of the carrier of b1
         st <^b4,b5^> <> {} & <^b5,b6^> <> {}
      for b7 being Element of <^b4,b5^>
      for b8 being Element of <^b5,b6^> holds
         ex b9 being Element of <^b3 . b5,b3 . b4^> st
            ex b10 being Element of <^b3 . b6,b3 . b5^> st
               b9 = (Morph-Map(b3,b4,b5)) . b7 &
                b10 = (Morph-Map(b3,b5,b6)) . b8 &
                (Morph-Map(b3,b4,b6)) . (b8 * b7) = b9 * b10;

:: FUNCTOR0:attrnot 18 => FUNCTOR0:attr 13
definition
  let a1, a2 be non empty AltCatStr;
  let a3 be FunctorStr over a1,a2;
  attr a3 is comp-preserving means
    for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       a3 . (b5 * b4) = (a3 . b5) * (a3 . b4);
end;

:: FUNCTOR0:dfs 23
definiens
  let a1 be non empty transitive AltCatStr;
  let a2 be non empty reflexive AltCatStr;
  let a3 be feasible Covariant FunctorStr over a1,a2;
To prove
     a3 is comp-preserving
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       a3 . (b5 * b4) = (a3 . b5) * (a3 . b4);

:: FUNCTOR0:def 24
theorem
for b1 being non empty transitive AltCatStr
for b2 being non empty reflexive AltCatStr
for b3 being feasible Covariant FunctorStr over b1,b2 holds
      b3 is comp-preserving(b1, b2)
   iff
      for b4, b5, b6 being Element of the carrier of b1
         st <^b4,b5^> <> {} & <^b5,b6^> <> {}
      for b7 being Element of <^b4,b5^>
      for b8 being Element of <^b5,b6^> holds
         b3 . (b8 * b7) = (b3 . b8) * (b3 . b7);

:: FUNCTOR0:attrnot 19 => FUNCTOR0:attr 14
definition
  let a1, a2 be non empty AltCatStr;
  let a3 be FunctorStr over a1,a2;
  attr a3 is comp-reversing means
    for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       a3 . (b5 * b4) = (a3 . b4) * (a3 . b5);
end;

:: FUNCTOR0:dfs 24
definiens
  let a1 be non empty transitive AltCatStr;
  let a2 be non empty reflexive AltCatStr;
  let a3 be feasible Contravariant FunctorStr over a1,a2;
To prove
     a3 is comp-reversing
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^> holds
       a3 . (b5 * b4) = (a3 . b4) * (a3 . b5);

:: FUNCTOR0:def 25
theorem
for b1 being non empty transitive AltCatStr
for b2 being non empty reflexive AltCatStr
for b3 being feasible Contravariant FunctorStr over b1,b2 holds
      b3 is comp-reversing(b1, b2)
   iff
      for b4, b5, b6 being Element of the carrier of b1
         st <^b4,b5^> <> {} & <^b5,b6^> <> {}
      for b7 being Element of <^b4,b5^>
      for b8 being Element of <^b5,b6^> holds
         b3 . (b8 * b7) = (b3 . b7) * (b3 . b8);

:: FUNCTOR0:th 26
theorem
for b1 being non empty AltGraph
for b2 being non empty reflexive AltGraph
for b3 being Element of the carrier of b2
for b4 being Element of <^b3,b3^>
for b5 being feasible Covariant FunctorStr over b1,b2
   st b5 = b1 --> b4
for b6, b7 being Element of the carrier of b1
for b8 being Element of <^b6,b7^>
      st <^b6,b7^> <> {}
   holds b5 . b8 = b4;

:: FUNCTOR0:th 27
theorem
for b1 being non empty AltGraph
for b2 being non empty reflexive AltGraph
for b3 being Element of the carrier of b2
for b4 being Element of <^b3,b3^>
for b5, b6 being Element of the carrier of b1
for b7 being Element of <^b5,b6^>
      st <^b5,b6^> <> {}
   holds (b1 --> b4) . b7 = b4;

:: FUNCTOR0:funcreg 10
registration
  let a1 be non empty transitive AltCatStr;
  let a2 be non empty with_units AltCatStr;
  let a3 be Element of the carrier of a2;
  cluster a1 --> idm a3 -> strict comp-preserving comp-reversing;
end;

:: FUNCTOR0:modenot 4 => FUNCTOR0:mode 2
definition
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  mode Functor of A1,A2 -> FunctorStr over a1,a2 means
    it is feasible(a1, a2) &
     it is id-preserving(a1, a2) &
     (it is Covariant(a1, a2) & it is comp-preserving(a1, a2) or it is Contravariant(a1, a2) & it is comp-reversing(a1, a2));
end;

:: FUNCTOR0:dfs 25
definiens
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is Functor of a1,a2
it is sufficient to prove
  thus a3 is feasible(a1, a2) &
     a3 is id-preserving(a1, a2) &
     (a3 is Covariant(a1, a2) & a3 is comp-preserving(a1, a2) or a3 is Contravariant(a1, a2) & a3 is comp-reversing(a1, a2));

:: FUNCTOR0:def 26
theorem
for b1 being non empty transitive with_units AltCatStr
for b2 being non empty with_units AltCatStr
for b3 being FunctorStr over b1,b2 holds
      b3 is Functor of b1,b2
   iff
      b3 is feasible(b1, b2) &
       b3 is id-preserving(b1, b2) &
       (b3 is Covariant(b1, b2) & b3 is comp-preserving(b1, b2) or b3 is Contravariant(b1, b2) & b3 is comp-reversing(b1, b2));

:: FUNCTOR0:attrnot 20 => FUNCTOR0:attr 15
definition
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  let a3 be Functor of a1,a2;
  attr a3 is covariant means
    a3 is Covariant(a1, a2) & a3 is comp-preserving(a1, a2);
end;

:: FUNCTOR0:dfs 26
definiens
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  let a3 be Functor of a1,a2;
To prove
     a3 is covariant
it is sufficient to prove
  thus a3 is Covariant(a1, a2) & a3 is comp-preserving(a1, a2);

:: FUNCTOR0:def 27
theorem
for b1 being non empty transitive with_units AltCatStr
for b2 being non empty with_units AltCatStr
for b3 being Functor of b1,b2 holds
      b3 is covariant(b1, b2)
   iff
      b3 is Covariant(b1, b2) & b3 is comp-preserving(b1, b2);

:: FUNCTOR0:attrnot 21 => FUNCTOR0:attr 16
definition
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  let a3 be Functor of a1,a2;
  attr a3 is contravariant means
    a3 is Contravariant(a1, a2) & a3 is comp-reversing(a1, a2);
end;

:: FUNCTOR0:dfs 27
definiens
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  let a3 be Functor of a1,a2;
To prove
     a3 is contravariant
it is sufficient to prove
  thus a3 is Contravariant(a1, a2) & a3 is comp-reversing(a1, a2);

:: FUNCTOR0:def 28
theorem
for b1 being non empty transitive with_units AltCatStr
for b2 being non empty with_units AltCatStr
for b3 being Functor of b1,b2 holds
      b3 is contravariant(b1, b2)
   iff
      b3 is Contravariant(b1, b2) & b3 is comp-reversing(b1, b2);

:: FUNCTOR0:funcnot 10 => FUNCTOR0:func 10
definition
  let a1 be AltCatStr;
  let a2 be SubCatStr of a1;
  func incl A2 -> strict FunctorStr over a2,a1 means
    the ObjectMap of it = id [:the carrier of a2,the carrier of a2:] &
     the MorphMap of it = id the Arrows of a2;
end;

:: FUNCTOR0:def 29
theorem
for b1 being AltCatStr
for b2 being SubCatStr of b1
for b3 being strict FunctorStr over b2,b1 holds
      b3 = incl b2
   iff
      the ObjectMap of b3 = id [:the carrier of b2,the carrier of b2:] &
       the MorphMap of b3 = id the Arrows of b2;

:: FUNCTOR0:funcnot 11 => FUNCTOR0:func 11
definition
  let a1 be AltGraph;
  func id A1 -> strict FunctorStr over a1,a1 means
    the ObjectMap of it = id [:the carrier of a1,the carrier of a1:] &
     the MorphMap of it = id the Arrows of a1;
end;

:: FUNCTOR0:def 30
theorem
for b1 being AltGraph
for b2 being strict FunctorStr over b1,b1 holds
      b2 = id b1
   iff
      the ObjectMap of b2 = id [:the carrier of b1,the carrier of b1:] &
       the MorphMap of b2 = id the Arrows of b1;

:: FUNCTOR0:funcreg 11
registration
  let a1 be AltCatStr;
  let a2 be SubCatStr of a1;
  cluster incl a2 -> strict Covariant;
end;

:: FUNCTOR0:th 28
theorem
for b1 being non empty AltCatStr
for b2 being non empty SubCatStr of b1
for b3 being Element of the carrier of b2 holds
   (incl b2) . b3 = b3;

:: FUNCTOR0:th 29
theorem
for b1 being non empty AltCatStr
for b2 being non empty SubCatStr of b1
for b3, b4 being Element of the carrier of b2 holds
<^b3,b4^> c= <^(incl b2) . b3,(incl b2) . b4^>;

:: FUNCTOR0:funcreg 12
registration
  let a1 be non empty AltCatStr;
  let a2 be non empty SubCatStr of a1;
  cluster incl a2 -> feasible strict;
end;

:: FUNCTOR0:attrnot 22 => FUNCTOR0:attr 17
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is faithful means
    the MorphMap of a3 is "1-1";
end;

:: FUNCTOR0:dfs 30
definiens
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is faithful
it is sufficient to prove
  thus the MorphMap of a3 is "1-1";

:: FUNCTOR0:def 31
theorem
for b1, b2 being AltGraph
for b3 being FunctorStr over b1,b2 holds
      b3 is faithful(b1, b2)
   iff
      the MorphMap of b3 is "1-1";

:: FUNCTOR0:attrnot 23 => FUNCTOR0:attr 18
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is full means
    ex b1 being ManySortedSet of [:the carrier of a1,the carrier of a1:] st
       ex b2 being ManySortedFunction of the Arrows of a1,b1 st
          b1 = (the ObjectMap of a3) * the Arrows of a2 &
           b2 = the MorphMap of a3 &
           b2 is "onto"([:the carrier of a1,the carrier of a1:], the Arrows of a1, b1);
end;

:: FUNCTOR0:dfs 31
definiens
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is full
it is sufficient to prove
  thus ex b1 being ManySortedSet of [:the carrier of a1,the carrier of a1:] st
       ex b2 being ManySortedFunction of the Arrows of a1,b1 st
          b1 = (the ObjectMap of a3) * the Arrows of a2 &
           b2 = the MorphMap of a3 &
           b2 is "onto"([:the carrier of a1,the carrier of a1:], the Arrows of a1, b1);

:: FUNCTOR0:def 32
theorem
for b1, b2 being AltGraph
for b3 being FunctorStr over b1,b2 holds
      b3 is full(b1, b2)
   iff
      ex b4 being ManySortedSet of [:the carrier of b1,the carrier of b1:] st
         ex b5 being ManySortedFunction of the Arrows of b1,b4 st
            b4 = (the ObjectMap of b3) * the Arrows of b2 &
             b5 = the MorphMap of b3 &
             b5 is "onto"([:the carrier of b1,the carrier of b1:], the Arrows of b1, b4);

:: FUNCTOR0:attrnot 24 => FUNCTOR0:attr 18
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is full means
    ex b1 being ManySortedFunction of the Arrows of a1,(the Arrows of a2) * the ObjectMap of a3 st
       b1 = the MorphMap of a3 &
        b1 is "onto"([:the carrier of a1,the carrier of a1:], the Arrows of a1, (the Arrows of a2) * the ObjectMap of a3);
end;

:: FUNCTOR0:dfs 32
definiens
  let a1 be AltGraph;
  let a2 be non empty AltGraph;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is full
it is sufficient to prove
  thus ex b1 being ManySortedFunction of the Arrows of a1,(the Arrows of a2) * the ObjectMap of a3 st
       b1 = the MorphMap of a3 &
        b1 is "onto"([:the carrier of a1,the carrier of a1:], the Arrows of a1, (the Arrows of a2) * the ObjectMap of a3);

:: FUNCTOR0:def 33
theorem
for b1 being AltGraph
for b2 being non empty AltGraph
for b3 being FunctorStr over b1,b2 holds
      b3 is full(b1, b2)
   iff
      ex b4 being ManySortedFunction of the Arrows of b1,(the Arrows of b2) * the ObjectMap of b3 st
         b4 = the MorphMap of b3 &
          b4 is "onto"([:the carrier of b1,the carrier of b1:], the Arrows of b1, (the Arrows of b2) * the ObjectMap of b3);

:: FUNCTOR0:attrnot 25 => FUNCTOR0:attr 19
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is injective means
    a3 is one-to-one(a1, a2) & a3 is faithful(a1, a2);
end;

:: FUNCTOR0:dfs 33
definiens
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is injective
it is sufficient to prove
  thus a3 is one-to-one(a1, a2) & a3 is faithful(a1, a2);

:: FUNCTOR0:def 34
theorem
for b1, b2 being AltGraph
for b3 being FunctorStr over b1,b2 holds
      b3 is injective(b1, b2)
   iff
      b3 is one-to-one(b1, b2) & b3 is faithful(b1, b2);

:: FUNCTOR0:attrnot 26 => FUNCTOR0:attr 20
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is surjective means
    a3 is full(a1, a2) & a3 is onto(a1, a2);
end;

:: FUNCTOR0:dfs 34
definiens
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is surjective
it is sufficient to prove
  thus a3 is full(a1, a2) & a3 is onto(a1, a2);

:: FUNCTOR0:def 35
theorem
for b1, b2 being AltGraph
for b3 being FunctorStr over b1,b2 holds
      b3 is surjective(b1, b2)
   iff
      b3 is full(b1, b2) & b3 is onto(b1, b2);

:: FUNCTOR0:attrnot 27 => FUNCTOR0:attr 21
definition
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
  attr a3 is bijective means
    a3 is injective(a1, a2) & a3 is surjective(a1, a2);
end;

:: FUNCTOR0:dfs 35
definiens
  let a1, a2 be AltGraph;
  let a3 be FunctorStr over a1,a2;
To prove
     a3 is bijective
it is sufficient to prove
  thus a3 is injective(a1, a2) & a3 is surjective(a1, a2);

:: FUNCTOR0:def 36
theorem
for b1, b2 being AltGraph
for b3 being FunctorStr over b1,b2 holds
      b3 is bijective(b1, b2)
   iff
      b3 is injective(b1, b2) & b3 is surjective(b1, b2);

:: FUNCTOR0:exreg 10
registration
  let a1, a2 be non empty transitive with_units AltCatStr;
  cluster feasible strict covariant contravariant Functor of a1,a2;
end;

:: FUNCTOR0:th 30
theorem
for b1 being non empty AltGraph
for b2 being Element of the carrier of b1 holds
   (id b1) . b2 = b2;

:: FUNCTOR0:th 31
theorem
for b1 being non empty AltGraph
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being Element of <^b2,b3^> holds
   (Morph-Map(id b1,b2,b3)) . b4 = b4;

:: FUNCTOR0:funcreg 13
registration
  let a1 be non empty AltGraph;
  cluster id a1 -> feasible strict Covariant;
end;

:: FUNCTOR0:exreg 11
registration
  let a1 be non empty AltGraph;
  cluster feasible Covariant FunctorStr over a1,a1;
end;

:: FUNCTOR0:th 32
theorem
for b1 being non empty AltGraph
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being feasible Covariant FunctorStr over b1,b1
   st b4 = id b1
for b5 being Element of <^b2,b3^> holds
   b4 . b5 = b5;

:: FUNCTOR0:funcreg 14
registration
  let a1 be non empty transitive with_units AltCatStr;
  cluster id a1 -> strict id-preserving comp-preserving;
end;

:: FUNCTOR0:funcnot 12 => FUNCTOR0:func 12
definition
  let a1 be non empty transitive with_units AltCatStr;
  redefine func id a1 -> strict covariant Functor of a1,a1;
end;

:: FUNCTOR0:funcreg 15
registration
  let a1 be AltGraph;
  cluster id a1 -> strict bijective;
end;

:: FUNCTOR0:funcnot 13 => FUNCTOR0:func 13
definition
  let a1 be non empty AltGraph;
  let a2, a3 be non empty reflexive AltGraph;
  let a4 be feasible FunctorStr over a1,a2;
  let a5 be FunctorStr over a2,a3;
  func A5 * A4 -> strict FunctorStr over a1,a3 means
    the ObjectMap of it = (the ObjectMap of a5) * the ObjectMap of a4 &
     the MorphMap of it = ((the MorphMap of a5) * the ObjectMap of a4) ** the MorphMap of a4;
end;

:: FUNCTOR0:def 37
theorem
for b1 being non empty AltGraph
for b2, b3 being non empty reflexive AltGraph
for b4 being feasible FunctorStr over b1,b2
for b5 being FunctorStr over b2,b3
for b6 being strict FunctorStr over b1,b3 holds
      b6 = b5 * b4
   iff
      the ObjectMap of b6 = (the ObjectMap of b5) * the ObjectMap of b4 &
       the MorphMap of b6 = ((the MorphMap of b5) * the ObjectMap of b4) ** the MorphMap of b4;

:: FUNCTOR0:funcreg 16
registration
  let a1 be non empty AltGraph;
  let a2, a3 be non empty reflexive AltGraph;
  let a4 be feasible Covariant FunctorStr over a1,a2;
  let a5 be Covariant FunctorStr over a2,a3;
  cluster a5 * a4 -> strict Covariant;
end;

:: FUNCTOR0:funcreg 17
registration
  let a1 be non empty AltGraph;
  let a2, a3 be non empty reflexive AltGraph;
  let a4 be feasible Contravariant FunctorStr over a1,a2;
  let a5 be Covariant FunctorStr over a2,a3;
  cluster a5 * a4 -> strict Contravariant;
end;

:: FUNCTOR0:funcreg 18
registration
  let a1 be non empty AltGraph;
  let a2, a3 be non empty reflexive AltGraph;
  let a4 be feasible Covariant FunctorStr over a1,a2;
  let a5 be Contravariant FunctorStr over a2,a3;
  cluster a5 * a4 -> strict Contravariant;
end;

:: FUNCTOR0:funcreg 19
registration
  let a1 be non empty AltGraph;
  let a2, a3 be non empty reflexive AltGraph;
  let a4 be feasible Contravariant FunctorStr over a1,a2;
  let a5 be Contravariant FunctorStr over a2,a3;
  cluster a5 * a4 -> strict Covariant;
end;

:: FUNCTOR0:funcreg 20
registration
  let a1 be non empty AltGraph;
  let a2, a3 be non empty reflexive AltGraph;
  let a4 be feasible FunctorStr over a1,a2;
  let a5 be feasible FunctorStr over a2,a3;
  cluster a5 * a4 -> feasible strict;
end;

:: FUNCTOR0:th 33
theorem
for b1 being non empty AltGraph
for b2, b3, b4 being non empty reflexive AltGraph
for b5 being feasible FunctorStr over b1,b2
for b6 being feasible FunctorStr over b2,b3
for b7 being FunctorStr over b3,b4 holds
   (b7 * b6) * b5 = b7 * (b6 * b5);

:: FUNCTOR0:th 34
theorem
for b1 being non empty AltCatStr
for b2, b3 being non empty reflexive AltCatStr
for b4 being reflexive feasible FunctorStr over b1,b2
for b5 being FunctorStr over b2,b3
for b6 being Element of the carrier of b1 holds
   (b5 * b4) . b6 = b5 . (b4 . b6);

:: FUNCTOR0:th 35
theorem
for b1 being non empty AltGraph
for b2, b3 being non empty reflexive AltGraph
for b4 being reflexive feasible FunctorStr over b1,b2
for b5 being FunctorStr over b2,b3
for b6 being Element of the carrier of b1 holds
   Morph-Map(b5 * b4,b6,b6) = (Morph-Map(b4,b6,b6)) * Morph-Map(b5,b4 . b6,b4 . b6);

:: FUNCTOR0:funcreg 21
registration
  let a1, a2, a3 be non empty with_units AltCatStr;
  let a4 be reflexive feasible id-preserving FunctorStr over a1,a2;
  let a5 be id-preserving FunctorStr over a2,a3;
  cluster a5 * a4 -> strict id-preserving;
end;

:: FUNCTOR0:funcnot 14 => FUNCTOR0:func 14
definition
  let a1, a2 be non empty reflexive AltCatStr;
  let a3 be non empty SubCatStr of a1;
  let a4 be FunctorStr over a1,a2;
  func A4 | A3 -> FunctorStr over a3,a2 equals
    a4 * incl a3;
end;

:: FUNCTOR0:def 38
theorem
for b1, b2 being non empty reflexive AltCatStr
for b3 being non empty SubCatStr of b1
for b4 being FunctorStr over b1,b2 holds
   b4 | b3 = b4 * incl b3;

:: FUNCTOR0:funcnot 15 => FUNCTOR0:func 15
definition
  let a1, a2 be non empty AltGraph;
  let a3 be FunctorStr over a1,a2;
  assume a3 is bijective(a1, a2);
  func A3 " -> strict FunctorStr over a2,a1 means
    the ObjectMap of it = (the ObjectMap of a3) " &
     (ex b1 being ManySortedFunction of the Arrows of a1,(the Arrows of a2) * the ObjectMap of a3 st
        b1 = the MorphMap of a3 &
         the MorphMap of it = (the ObjectMap of a3) " * (b1 ""));
end;

:: FUNCTOR0:def 39
theorem
for b1, b2 being non empty AltGraph
for b3 being FunctorStr over b1,b2
   st b3 is bijective(b1, b2)
for b4 being strict FunctorStr over b2,b1 holds
      b4 = b3 "
   iff
      the ObjectMap of b4 = (the ObjectMap of b3) " &
       (ex b5 being ManySortedFunction of the Arrows of b1,(the Arrows of b2) * the ObjectMap of b3 st
          b5 = the MorphMap of b3 &
           the MorphMap of b4 = (the ObjectMap of b3) " * (b5 ""));

:: FUNCTOR0:th 36
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being feasible FunctorStr over b1,b2
      st b3 is bijective(b1, b2)
   holds b3 " is bijective(b2, b1) & b3 " is feasible(b2, b1);

:: FUNCTOR0:th 37
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being reflexive feasible FunctorStr over b1,b2
      st b3 is bijective(b1, b2) & b3 is coreflexive(b1, b2)
   holds b3 " is reflexive(b2, b1);

:: FUNCTOR0:th 38
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being reflexive feasible id-preserving FunctorStr over b1,b2
      st b3 is bijective(b1, b2) & b3 is coreflexive(b1, b2)
   holds b3 " is id-preserving(b2, b1);

:: FUNCTOR0:th 39
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being feasible FunctorStr over b1,b2
      st b3 is bijective(b1, b2) & b3 is Covariant(b1, b2)
   holds b3 " is Covariant(b2, b1);

:: FUNCTOR0:th 40
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being feasible FunctorStr over b1,b2
      st b3 is bijective(b1, b2) & b3 is Contravariant(b1, b2)
   holds b3 " is Contravariant(b2, b1);

:: FUNCTOR0:th 41
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being reflexive feasible FunctorStr over b1,b2
   st b3 is bijective(b1, b2) & b3 is coreflexive(b1, b2) & b3 is Covariant(b1, b2)
for b4, b5 being Element of the carrier of b2
for b6 being Element of <^b4,b5^>
      st <^b4,b5^> <> {}
   holds (Morph-Map(b3,b3 " . b4,b3 " . b5)) . ((Morph-Map(b3 ",b4,b5)) . b6) = b6;

:: FUNCTOR0:th 42
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being reflexive feasible FunctorStr over b1,b2
   st b3 is bijective(b1, b2) & b3 is coreflexive(b1, b2) & b3 is Contravariant(b1, b2)
for b4, b5 being Element of the carrier of b2
for b6 being Element of <^b4,b5^>
      st <^b4,b5^> <> {}
   holds (Morph-Map(b3,b3 " . b5,b3 " . b4)) . ((Morph-Map(b3 ",b4,b5)) . b6) = b6;

:: FUNCTOR0:th 43
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being reflexive feasible FunctorStr over b1,b2
      st b3 is bijective(b1, b2) & b3 is comp-preserving(b1, b2) & b3 is Covariant(b1, b2) & b3 is coreflexive(b1, b2)
   holds b3 " is comp-preserving(b2, b1);

:: FUNCTOR0:th 44
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being reflexive feasible FunctorStr over b1,b2
      st b3 is bijective(b1, b2) & b3 is comp-reversing(b1, b2) & b3 is Contravariant(b1, b2) & b3 is coreflexive(b1, b2)
   holds b3 " is comp-reversing(b2, b1);

:: FUNCTOR0:condreg 3
registration
  let a1 be 1-sorted;
  let a2 be non empty 1-sorted;
  cluster Covariant -> reflexive (BimapStr over a1,a2);
end;

:: FUNCTOR0:condreg 4
registration
  let a1 be 1-sorted;
  let a2 be non empty 1-sorted;
  cluster Contravariant -> reflexive (BimapStr over a1,a2);
end;

:: FUNCTOR0:th 45
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2
      st b3 is Covariant(b1, b2) & b3 is onto(b1, b2)
   holds b3 is coreflexive(b1, b2);

:: FUNCTOR0:th 46
theorem
for b1, b2 being 1-sorted
for b3 being BimapStr over b1,b2
      st b3 is Contravariant(b1, b2) & b3 is onto(b1, b2)
   holds b3 is coreflexive(b1, b2);

:: FUNCTOR0:condreg 5
registration
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  cluster covariant -> reflexive (Functor of a1,a2);
end;

:: FUNCTOR0:condreg 6
registration
  let a1 be non empty transitive with_units AltCatStr;
  let a2 be non empty with_units AltCatStr;
  cluster contravariant -> reflexive (Functor of a1,a2);
end;

:: FUNCTOR0:th 47
theorem
for b1 being non empty transitive with_units AltCatStr
for b2 being non empty with_units AltCatStr
for b3 being Functor of b1,b2
      st b3 is covariant(b1, b2) & b3 is onto(b1, b2)
   holds b3 is coreflexive(b1, b2);

:: FUNCTOR0:th 48
theorem
for b1 being non empty transitive with_units AltCatStr
for b2 being non empty with_units AltCatStr
for b3 being Functor of b1,b2
      st b3 is contravariant(b1, b2) & b3 is onto(b1, b2)
   holds b3 is coreflexive(b1, b2);

:: FUNCTOR0:th 49
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being covariant Functor of b1,b2
      st b3 is bijective(b1, b2)
   holds ex b4 being Functor of b2,b1 st
      b4 = b3 " & b4 is bijective(b2, b1) & b4 is covariant(b2, b1);

:: FUNCTOR0:th 50
theorem
for b1, b2 being non empty transitive with_units AltCatStr
for b3 being contravariant Functor of b1,b2
      st b3 is bijective(b1, b2)
   holds ex b4 being Functor of b2,b1 st
      b4 = b3 " & b4 is bijective(b2, b1) & b4 is contravariant(b2, b1);

:: FUNCTOR0:prednot 1 => FUNCTOR0:pred 1
definition
  let a1, a2 be non empty transitive with_units AltCatStr;
  pred A1,A2 are_isomorphic means
    ex b1 being Functor of a1,a2 st
       b1 is bijective(a1, a2) & b1 is covariant(a1, a2);
  symmetry;
::  for a1, a2 being non empty transitive with_units AltCatStr
::        st a1,a2 are_isomorphic
::     holds a2,a1 are_isomorphic;
  reflexivity;
::  for a1 being non empty transitive with_units AltCatStr holds
::     a1,a1 are_isomorphic;
end;

:: FUNCTOR0:dfs 39
definiens
  let a1, a2 be non empty transitive with_units AltCatStr;
To prove
     a1,a2 are_isomorphic
it is sufficient to prove
  thus ex b1 being Functor of a1,a2 st
       b1 is bijective(a1, a2) & b1 is covariant(a1, a2);

:: FUNCTOR0:def 40
theorem
for b1, b2 being non empty transitive with_units AltCatStr holds
   b1,b2 are_isomorphic
iff
   ex b3 being Functor of b1,b2 st
      b3 is bijective(b1, b2) & b3 is covariant(b1, b2);

:: FUNCTOR0:prednot 2 => FUNCTOR0:pred 2
definition
  let a1, a2 be non empty transitive with_units AltCatStr;
  pred A1,A2 are_anti-isomorphic means
    ex b1 being Functor of a1,a2 st
       b1 is bijective(a1, a2) & b1 is contravariant(a1, a2);
  symmetry;
::  for a1, a2 being non empty transitive with_units AltCatStr
::        st a1,a2 are_anti-isomorphic
::     holds a2,a1 are_anti-isomorphic;
end;

:: FUNCTOR0:dfs 40
definiens
  let a1, a2 be non empty transitive with_units AltCatStr;
To prove
     a1,a2 are_anti-isomorphic
it is sufficient to prove
  thus ex b1 being Functor of a1,a2 st
       b1 is bijective(a1, a2) & b1 is contravariant(a1, a2);

:: FUNCTOR0:def 41
theorem
for b1, b2 being non empty transitive with_units AltCatStr holds
   b1,b2 are_anti-isomorphic
iff
   ex b3 being Functor of b1,b2 st
      b3 is bijective(b1, b2) & b3 is contravariant(b1, b2);