Article YELLOW18, MML version 4.99.1005

:: YELLOW18:sch 1
scheme YELLOW18:sch 1
{F1 -> non empty set,
  F2 -> set,
  F3 -> set}:
ex b1 being non empty transitive strict AltCatStr st
   the carrier of b1 = F1() &
    (for b2, b3 being Element of the carrier of b1 holds
    <^b2,b3^> = F2(b2, b3)) &
    (for b2, b3, b4 being Element of the carrier of b1
       st <^b2,b3^> <> {} & <^b3,b4^> <> {}
    for b5 being Element of <^b2,b3^>
    for b6 being Element of <^b3,b4^> holds
       b6 * b5 = F3(b2, b3, b4, b5, b6))
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being set
         st b4 in F2(b1, b2) & b5 in F2(b2, b3)
      holds F3(b1, b2, b3, b4, b5) in F2(b1, b3);


:: YELLOW18:sch 2
scheme YELLOW18:sch 2
{F1 -> non empty transitive AltCatStr,
  F2 -> set}:
F1() is associative
provided
   for b1, b2, b3 being Element of the carrier of F1()
      st <^b1,b2^> <> {} & <^b2,b3^> <> {}
   for b4 being Element of <^b1,b2^>
   for b5 being Element of <^b2,b3^> holds
      b5 * b4 = F2(b1, b2, b3, b4, b5)
and
   for b1, b2, b3, b4 being Element of the carrier of F1()
   for b5, b6, b7 being set
         st b5 in <^b1,b2^> & b6 in <^b2,b3^> & b7 in <^b3,b4^>
      holds F2(b1, b3, b4, F2(b1, b2, b3, b5, b6), b7) = F2(b1, b2, b4, b5, F2(b2, b3, b4, b6, b7));


:: YELLOW18:sch 3
scheme YELLOW18:sch 3
{F1 -> non empty transitive AltCatStr,
  F2 -> set}:
F1() is with_units
provided
   for b1, b2, b3 being Element of the carrier of F1()
      st <^b1,b2^> <> {} & <^b2,b3^> <> {}
   for b4 being Element of <^b1,b2^>
   for b5 being Element of <^b2,b3^> holds
      b5 * b4 = F2(b1, b2, b3, b4, b5)
and
   for b1 being Element of the carrier of F1() holds
      ex b2 being set st
         b2 in <^b1,b1^> &
          (for b3 being Element of the carrier of F1()
          for b4 being set
                st b4 in <^b1,b3^>
             holds F2(b1, b1, b3, b2, b4) = b4)
and
   for b1 being Element of the carrier of F1() holds
      ex b2 being set st
         b2 in <^b1,b1^> &
          (for b3 being Element of the carrier of F1()
          for b4 being set
                st b4 in <^b3,b1^>
             holds F2(b3, b1, b1, b4, b2) = b4);


:: YELLOW18:sch 4
scheme YELLOW18:sch 4
{F1 -> non empty set,
  F2 -> set,
  F3 -> set}:
ex b1 being non empty transitive strict associative with_units AltCatStr st
   the carrier of b1 = F1() &
    (for b2, b3 being Element of the carrier of b1 holds
    <^b2,b3^> = F2(b2, b3)) &
    (for b2, b3, b4 being Element of the carrier of b1
       st <^b2,b3^> <> {} & <^b3,b4^> <> {}
    for b5 being Element of <^b2,b3^>
    for b6 being Element of <^b3,b4^> holds
       b6 * b5 = F3(b2, b3, b4, b5, b6))
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being set
         st b4 in F2(b1, b2) & b5 in F2(b2, b3)
      holds F3(b1, b2, b3, b4, b5) in F2(b1, b3)
and
   for b1, b2, b3, b4 being Element of F1()
   for b5, b6, b7 being set
         st b5 in F2(b1, b2) & b6 in F2(b2, b3) & b7 in F2(b3, b4)
      holds F3(b1, b3, b4, F3(b1, b2, b3, b5, b6), b7) = F3(b1, b2, b4, b5, F3(b2, b3, b4, b6, b7))
and
   for b1 being Element of F1() holds
      ex b2 being set st
         b2 in F2(b1, b1) &
          (for b3 being Element of F1()
          for b4 being set
                st b4 in F2(b1, b3)
             holds F3(b1, b1, b3, b2, b4) = b4)
and
   for b1 being Element of F1() holds
      ex b2 being set st
         b2 in F2(b1, b1) &
          (for b3 being Element of F1()
          for b4 being set
                st b4 in F2(b3, b1)
             holds F3(b3, b1, b1, b4, b2) = b4);


:: YELLOW18:sch 5
scheme YELLOW18:sch 5
{F1 -> non empty set,
  F2 -> set,
  F3 -> set}:
for b1, b2 being non empty transitive AltCatStr
      st the carrier of b1 = F1() &
         (for b3, b4 being Element of the carrier of b1 holds
         <^b3,b4^> = F2(b3, b4)) &
         (for b3, b4, b5 being Element of the carrier of b1
            st <^b3,b4^> <> {} & <^b4,b5^> <> {}
         for b6 being Element of <^b3,b4^>
         for b7 being Element of <^b4,b5^> holds
            b7 * b6 = F3(b3, b4, b5, b6, b7)) &
         the carrier of b2 = F1() &
         (for b3, b4 being Element of the carrier of b2 holds
         <^b3,b4^> = F2(b3, b4)) &
         (for b3, b4, b5 being Element of the carrier of b2
            st <^b3,b4^> <> {} & <^b4,b5^> <> {}
         for b6 being Element of <^b3,b4^>
         for b7 being Element of <^b4,b5^> holds
            b7 * b6 = F3(b3, b4, b5, b6, b7))
   holds AltCatStr(#the carrier of b1,the Arrows of b1,the Comp of b1#) = AltCatStr(#the carrier of b2,the Arrows of b2,the Comp of b2#)


:: YELLOW18:sch 6
scheme YELLOW18:sch 6
{F1 -> non empty set,
  F2 -> set,
  F3 -> set}:
ex b1 being non empty transitive strict associative with_units AltCatStr st
   the carrier of b1 = F1() &
    (for b2, b3 being Element of the carrier of b1
    for b4 being set holds
          b4 in <^b2,b3^>
       iff
          b4 in F2(b2, b3) & P1[b2, b3, b4]) &
    (for b2, b3, b4 being Element of the carrier of b1
       st <^b2,b3^> <> {} & <^b3,b4^> <> {}
    for b5 being Element of <^b2,b3^>
    for b6 being Element of <^b3,b4^> holds
       b6 * b5 = F3(b2, b3, b4, b5, b6))
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being set
         st b4 in F2(b1, b2) & P1[b1, b2, b4] & b5 in F2(b2, b3) & P1[b2, b3, b5]
      holds F3(b1, b2, b3, b4, b5) in F2(b1, b3) & P1[b1, b3, F3(b1, b2, b3, b4, b5)]
and
   for b1, b2, b3, b4 being Element of F1()
   for b5, b6, b7 being set
         st b5 in F2(b1, b2) & P1[b1, b2, b5] & b6 in F2(b2, b3) & P1[b2, b3, b6] & b7 in F2(b3, b4) & P1[b3, b4, b7]
      holds F3(b1, b3, b4, F3(b1, b2, b3, b5, b6), b7) = F3(b1, b2, b4, b5, F3(b2, b3, b4, b6, b7))
and
   for b1 being Element of F1() holds
      ex b2 being set st
         b2 in F2(b1, b1) &
          P1[b1, b1, b2] &
          (for b3 being Element of F1()
          for b4 being set
                st b4 in F2(b1, b3) & P1[b1, b3, b4]
             holds F3(b1, b1, b3, b2, b4) = b4)
and
   for b1 being Element of F1() holds
      ex b2 being set st
         b2 in F2(b1, b1) &
          P1[b1, b1, b2] &
          (for b3 being Element of F1()
          for b4 being set
                st b4 in F2(b3, b1) & P1[b3, b1, b4]
             holds F3(b3, b1, b1, b4, b2) = b4);


:: YELLOW18:funcreg 1
registration
  let a1 be Relation-like Function-like Function-yielding set;
  let a2, a3, a4 be set;
  cluster a1 .(a2,a3,a4) -> Relation-like Function-like;
end;

:: YELLOW18:sch 7
scheme YELLOW18:sch 7
{F1 -> non empty transitive associative with_units AltCatStr}:
ex b1 being non empty transitive strict id-inheriting SubCatStr of F1() st
   (for b2 being Element of the carrier of F1() holds
          b2 is Element of the carrier of b1
       iff
          P1[b2]) &
    (for b2, b3 being Element of the carrier of F1()
    for b4, b5 being Element of the carrier of b1
       st b4 = b2 & b5 = b3 & <^b2,b3^> <> {}
    for b6 being Element of <^b2,b3^> holds
          b6 in <^b4,b5^>
       iff
          P2[b2, b3, b6])
provided
   ex b1 being Element of the carrier of F1() st
      P1[b1]
and
   for b1, b2, b3 being Element of the carrier of F1()
      st P1[b1] & P1[b2] & P1[b3] & <^b1,b2^> <> {} & <^b2,b3^> <> {}
   for b4 being Element of <^b1,b2^>
   for b5 being Element of <^b2,b3^>
         st P2[b1, b2, b4] & P2[b2, b3, b5]
      holds P2[b1, b3, b5 * b4]
and
   for b1 being Element of the carrier of F1()
         st P1[b1]
      holds P2[b1, b1, idm b1];


:: YELLOW18:sch 8
scheme YELLOW18:sch 8
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> set,
  F4 -> set}:
ex b1 being strict covariant Functor of F1(),F2() st
   (for b2 being Element of the carrier of F1() holds
       b1 . b2 = F3(b2)) &
    (for b2, b3 being Element of the carrier of F1()
       st <^b2,b3^> <> {}
    for b4 being Element of <^b2,b3^> holds
       b1 . b4 = F4(b2, b3, b4))
provided
   for b1 being Element of the carrier of F1() holds
      F3(b1) is Element of the carrier of F2()
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      F4(b1, b2, b3) in (the Arrows of F2()) .(F3(b1),F3(b2))
and
   for b1, b2, b3 being Element of the carrier of F1()
      st <^b1,b2^> <> {} & <^b2,b3^> <> {}
   for b4 being Element of <^b1,b2^>
   for b5 being Element of <^b2,b3^>
   for b6, b7, b8 being Element of the carrier of F2()
      st b6 = F3(b1) & b7 = F3(b2) & b8 = F3(b3)
   for b9 being Element of <^b6,b7^>
   for b10 being Element of <^b7,b8^>
         st b9 = F4(b1, b2, b4) & b10 = F4(b2, b3, b5)
      holds F4(b1, b3, b5 * b4) = b10 * b9
and
   for b1 being Element of the carrier of F1()
   for b2 being Element of the carrier of F2()
         st b2 = F3(b1)
      holds F4(b1, b1, idm b1) = idm b2;


:: YELLOW18:th 1
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
for b3, b4 being covariant Functor of b1,b2
      st (for b5 being Element of the carrier of b1 holds
            b3 . b5 = b4 . b5) &
         (for b5, b6 being Element of the carrier of b1
            st <^b5,b6^> <> {}
         for b7 being Element of <^b5,b6^> holds
            b3 . b7 = b4 . b7)
   holds FunctorStr(#the ObjectMap of b3,the MorphMap of b3#) = FunctorStr(#the ObjectMap of b4,the MorphMap of b4#);

:: YELLOW18:sch 9
scheme YELLOW18:sch 9
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> set,
  F4 -> set}:
ex b1 being strict contravariant Functor of F1(),F2() st
   (for b2 being Element of the carrier of F1() holds
       b1 . b2 = F3(b2)) &
    (for b2, b3 being Element of the carrier of F1()
       st <^b2,b3^> <> {}
    for b4 being Element of <^b2,b3^> holds
       b1 . b4 = F4(b2, b3, b4))
provided
   for b1 being Element of the carrier of F1() holds
      F3(b1) is Element of the carrier of F2()
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      F4(b1, b2, b3) in (the Arrows of F2()) .(F3(b2),F3(b1))
and
   for b1, b2, b3 being Element of the carrier of F1()
      st <^b1,b2^> <> {} & <^b2,b3^> <> {}
   for b4 being Element of <^b1,b2^>
   for b5 being Element of <^b2,b3^>
   for b6, b7, b8 being Element of the carrier of F2()
      st b6 = F3(b1) & b7 = F3(b2) & b8 = F3(b3)
   for b9 being Element of <^b7,b6^>
   for b10 being Element of <^b8,b7^>
         st b9 = F4(b1, b2, b4) & b10 = F4(b2, b3, b5)
      holds F4(b1, b3, b5 * b4) = b9 * b10
and
   for b1 being Element of the carrier of F1()
   for b2 being Element of the carrier of F2()
         st b2 = F3(b1)
      holds F4(b1, b1, idm b1) = idm b2;


:: YELLOW18:th 2
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
for b3, b4 being contravariant Functor of b1,b2
      st (for b5 being Element of the carrier of b1 holds
            b3 . b5 = b4 . b5) &
         (for b5, b6 being Element of the carrier of b1
            st <^b5,b6^> <> {}
         for b7 being Element of <^b5,b6^> holds
            b3 . b7 = b4 . b7)
   holds FunctorStr(#the ObjectMap of b3,the MorphMap of b3#) = FunctorStr(#the ObjectMap of b4,the MorphMap of b4#);

:: YELLOW18:attrnot 1 => YELLOW18:attr 1
definition
  let a1, a2, a3 be non empty set;
  let a4 be Function-like quasi_total Relation of [:a1,a2:],a3;
  redefine attr a4 is one-to-one means
    for b1, b2 being Element of a1
    for b3, b4 being Element of a2
          st a4 .(b1,b3) = a4 .(b2,b4)
       holds b1 = b2 & b3 = b4;
end;

:: YELLOW18:dfs 1
definiens
  let a1, a2, a3 be non empty set;
  let a4 be Function-like quasi_total Relation of [:a1,a2:],a3;
To prove
     a1 is one-to-one
it is sufficient to prove
  thus for b1, b2 being Element of a1
    for b3, b4 being Element of a2
          st a4 .(b1,b3) = a4 .(b2,b4)
       holds b1 = b2 & b3 = b4;

:: YELLOW18:def 1
theorem
for b1, b2, b3 being non empty set
for b4 being Function-like quasi_total Relation of [:b1,b2:],b3 holds
      b4 is one-to-one
   iff
      for b5, b6 being Element of b1
      for b7, b8 being Element of b2
            st b4 .(b5,b7) = b4 .(b6,b8)
         holds b5 = b6 & b7 = b8;

:: YELLOW18:sch 10
scheme YELLOW18:sch 10
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> covariant Functor of F1(),F2(),
  F4 -> set,
  F5 -> set}:
F3() is bijective(F1(), F2())
provided
   for b1 being Element of the carrier of F1() holds
      F3() . b1 = F4(b1)
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      F3() . b3 = F5(b1, b2, b3)
and
   for b1, b2 being Element of the carrier of F1()
         st F4(b1) = F4(b2)
      holds b1 = b2
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3, b4 being Element of <^b1,b2^>
         st F5(b1, b2, b3) = F5(b1, b2, b4)
      holds b3 = b4
and
   for b1, b2 being Element of the carrier of F2()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      ex b4, b5 being Element of the carrier of F1() st
         ex b6 being Element of <^b4,b5^> st
            b1 = F4(b4) & b2 = F4(b5) & <^b4,b5^> <> {} & b3 = F5(b4, b5, b6);


:: YELLOW18:sch 11
scheme YELLOW18:sch 11
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> set,
  F4 -> set}:
F1(),F2() are_isomorphic
provided
   ex b1 being covariant Functor of F1(),F2() st
      (for b2 being Element of the carrier of F1() holds
          b1 . b2 = F3(b2)) &
       (for b2, b3 being Element of the carrier of F1()
          st <^b2,b3^> <> {}
       for b4 being Element of <^b2,b3^> holds
          b1 . b4 = F4(b2, b3, b4))
and
   for b1, b2 being Element of the carrier of F1()
         st F3(b1) = F3(b2)
      holds b1 = b2
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3, b4 being Element of <^b1,b2^>
         st F4(b1, b2, b3) = F4(b1, b2, b4)
      holds b3 = b4
and
   for b1, b2 being Element of the carrier of F2()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      ex b4, b5 being Element of the carrier of F1() st
         ex b6 being Element of <^b4,b5^> st
            b1 = F3(b4) & b2 = F3(b5) & <^b4,b5^> <> {} & b3 = F4(b4, b5, b6);


:: YELLOW18:sch 12
scheme YELLOW18:sch 12
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> contravariant Functor of F1(),F2(),
  F4 -> set,
  F5 -> set}:
F3() is bijective(F1(), F2())
provided
   for b1 being Element of the carrier of F1() holds
      F3() . b1 = F4(b1)
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      F3() . b3 = F5(b1, b2, b3)
and
   for b1, b2 being Element of the carrier of F1()
         st F4(b1) = F4(b2)
      holds b1 = b2
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3, b4 being Element of <^b1,b2^>
         st F5(b1, b2, b3) = F5(b1, b2, b4)
      holds b3 = b4
and
   for b1, b2 being Element of the carrier of F2()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      ex b4, b5 being Element of the carrier of F1() st
         ex b6 being Element of <^b4,b5^> st
            b2 = F4(b4) & b1 = F4(b5) & <^b4,b5^> <> {} & b3 = F5(b4, b5, b6);


:: YELLOW18:sch 13
scheme YELLOW18:sch 13
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> set,
  F4 -> set}:
F1(),F2() are_anti-isomorphic
provided
   ex b1 being contravariant Functor of F1(),F2() st
      (for b2 being Element of the carrier of F1() holds
          b1 . b2 = F3(b2)) &
       (for b2, b3 being Element of the carrier of F1()
          st <^b2,b3^> <> {}
       for b4 being Element of <^b2,b3^> holds
          b1 . b4 = F4(b2, b3, b4))
and
   for b1, b2 being Element of the carrier of F1()
         st F3(b1) = F3(b2)
      holds b1 = b2
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3, b4 being Element of <^b1,b2^>
         st F4(b1, b2, b3) = F4(b1, b2, b4)
      holds b3 = b4
and
   for b1, b2 being Element of the carrier of F2()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      ex b4, b5 being Element of the carrier of F1() st
         ex b6 being Element of <^b4,b5^> st
            b2 = F3(b4) & b1 = F3(b5) & <^b4,b5^> <> {} & b3 = F4(b4, b5, b6);


:: YELLOW18:prednot 1 => YELLOW18:pred 1
definition
  let a1, a2 be non empty transitive associative with_units AltCatStr;
  pred A1,A2 are_equivalent means
    ex b1 being covariant Functor of a1,a2 st
       ex b2 being covariant Functor of a2,a1 st
          b2 * b1,id a1 are_naturally_equivalent & b1 * b2,id a2 are_naturally_equivalent;
  symmetry;
::  for a1, a2 being non empty transitive associative with_units AltCatStr
::        st a1,a2 are_equivalent
::     holds a2,a1 are_equivalent;
  reflexivity;
::  for a1 being non empty transitive associative with_units AltCatStr holds
::     a1,a1 are_equivalent;
end;

:: YELLOW18:dfs 2
definiens
  let a1, a2 be non empty transitive associative with_units AltCatStr;
To prove
     a1,a2 are_equivalent
it is sufficient to prove
  thus ex b1 being covariant Functor of a1,a2 st
       ex b2 being covariant Functor of a2,a1 st
          b2 * b1,id a1 are_naturally_equivalent & b1 * b2,id a2 are_naturally_equivalent;

:: YELLOW18:def 2
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr holds
   b1,b2 are_equivalent
iff
   ex b3 being covariant Functor of b1,b2 st
      ex b4 being covariant Functor of b2,b1 st
         b4 * b3,id b1 are_naturally_equivalent & b3 * b4,id b2 are_naturally_equivalent;

:: YELLOW18:th 3
theorem
for b1, b2, b3 being non empty reflexive AltGraph
for b4, b5 being feasible FunctorStr over b1,b2
for b6, b7 being FunctorStr over b2,b3
      st FunctorStr(#the ObjectMap of b4,the MorphMap of b4#) = FunctorStr(#the ObjectMap of b5,the MorphMap of b5#) &
         FunctorStr(#the ObjectMap of b6,the MorphMap of b6#) = FunctorStr(#the ObjectMap of b7,the MorphMap of b7#)
   holds b6 * b4 = b7 * b5;

:: YELLOW18:th 4
theorem
for b1, b2, b3 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_equivalent & b2,b3 are_equivalent
   holds b1,b3 are_equivalent;

:: YELLOW18:th 5
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_isomorphic
   holds b1,b2 are_equivalent;

:: YELLOW18:sch 14
scheme YELLOW18:sch 14
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> covariant Functor of F1(),F2(),
  F4 -> covariant Functor of F1(),F2(),
  F5 -> set}:
ex b1 being natural_transformation of F3(),F4() st
   F3() is_naturally_transformable_to F4() &
    (for b2 being Element of the carrier of F1() holds
       b1 ! b2 = F5(b2))
provided
   for b1 being Element of the carrier of F1() holds
      F5(b1) in <^F3() . b1,F4() . b1^>
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^>
   for b4 being Element of <^F3() . b1,F4() . b1^>
      st b4 = F5(b1)
   for b5 being Element of <^F3() . b2,F4() . b2^>
         st b5 = F5(b2)
      holds b5 * (F3() . b3) = (F4() . b3) * b4;


:: YELLOW18:sch 15
scheme YELLOW18:sch 15
{F1 -> non empty transitive associative with_units AltCatStr,
  F2 -> non empty transitive associative with_units AltCatStr,
  F3 -> covariant Functor of F1(),F2(),
  F4 -> covariant Functor of F1(),F2(),
  F5 -> set}:
ex b1 being natural_equivalence of F3(),F4() st
   F3(),F4() are_naturally_equivalent &
    (for b2 being Element of the carrier of F1() holds
       b1 ! b2 = F5(b2))
provided
   for b1 being Element of the carrier of F1() holds
      F5(b1) in <^F3() . b1,F4() . b1^> &
       <^F4() . b1,F3() . b1^> <> {} &
       (for b2 being Element of <^F3() . b1,F4() . b1^>
             st b2 = F5(b1)
          holds b2 is iso(F2(), F3() . b1, F4() . b1))
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^>
   for b4 being Element of <^F3() . b1,F4() . b1^>
      st b4 = F5(b1)
   for b5 being Element of <^F3() . b2,F4() . b2^>
         st b5 = F5(b2)
      holds b5 * (F3() . b3) = (F4() . b3) * b4;


:: YELLOW18:prednot 2 => YELLOW18:pred 2
definition
  let a1, a2 be non empty AltCatStr;
  pred A1,A2 are_opposite means
    the carrier of a2 = the carrier of a1 &
     the Arrows of a2 = ~ the Arrows of a1 &
     (for b1, b2, b3 being Element of the carrier of a1
     for b4, b5, b6 being Element of the carrier of a2
           st b4 = b1 & b5 = b2 & b6 = b3
        holds (the Comp of a2) .(b4,b5,b6) = ~ ((the Comp of a1) .(b3,b2,b1)));
  symmetry;
::  for a1, a2 being non empty AltCatStr
::        st a1,a2 are_opposite
::     holds a2,a1 are_opposite;
end;

:: YELLOW18:dfs 3
definiens
  let a1, a2 be non empty AltCatStr;
To prove
     a1,a2 are_opposite
it is sufficient to prove
  thus the carrier of a2 = the carrier of a1 &
     the Arrows of a2 = ~ the Arrows of a1 &
     (for b1, b2, b3 being Element of the carrier of a1
     for b4, b5, b6 being Element of the carrier of a2
           st b4 = b1 & b5 = b2 & b6 = b3
        holds (the Comp of a2) .(b4,b5,b6) = ~ ((the Comp of a1) .(b3,b2,b1)));

:: YELLOW18:def 3
theorem
for b1, b2 being non empty AltCatStr holds
   b1,b2 are_opposite
iff
   the carrier of b2 = the carrier of b1 &
    the Arrows of b2 = ~ the Arrows of b1 &
    (for b3, b4, b5 being Element of the carrier of b1
    for b6, b7, b8 being Element of the carrier of b2
          st b6 = b3 & b7 = b4 & b8 = b5
       holds (the Comp of b2) .(b6,b7,b8) = ~ ((the Comp of b1) .(b5,b4,b3)));

:: YELLOW18:th 6
theorem
for b1, b2 being non empty AltCatStr
   st b1,b2 are_opposite
for b3 being Element of the carrier of b1 holds
   b3 is Element of the carrier of b2;

:: YELLOW18:th 7
theorem
for b1, b2 being non empty AltCatStr
   st b1,b2 are_opposite
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b5 = b3 & b6 = b4
   holds <^b3,b4^> = <^b6,b5^>;

:: YELLOW18:th 8
theorem
for b1, b2 being non empty AltCatStr
   st b1,b2 are_opposite
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
   st b5 = b3 & b6 = b4
for b7 being Element of <^b3,b4^> holds
   b7 is Element of <^b6,b5^>;

:: YELLOW18:th 9
theorem
for b1, b2 being non empty transitive AltCatStr holds
   b1,b2 are_opposite
iff
   the carrier of b2 = the carrier of b1 &
    (for b3, b4, b5 being Element of the carrier of b1
    for b6, b7, b8 being Element of the carrier of b2
          st b6 = b3 & b7 = b4 & b8 = b5
       holds <^b3,b4^> = <^b7,b6^> &
        (<^b3,b4^> <> {} & <^b4,b5^> <> {} implies for b9 being Element of <^b3,b4^>
        for b10 being Element of <^b4,b5^>
        for b11 being Element of <^b7,b6^>
        for b12 being Element of <^b8,b7^>
              st b11 = b9 & b12 = b10
           holds b11 * b12 = b10 * b9));

:: YELLOW18:th 10
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2
      st b3 = b4
   holds idm b3 = idm b4;

:: YELLOW18:th 11
theorem
for b1 being non empty transitive AltCatStr holds
   ex b2 being non empty transitive strict AltCatStr st
      b1,b2 are_opposite;

:: YELLOW18:th 12
theorem
for b1, b2 being non empty transitive AltCatStr
      st b1,b2 are_opposite & b1 is associative
   holds b2 is associative;

:: YELLOW18:th 13
theorem
for b1, b2 being non empty transitive AltCatStr
      st b1,b2 are_opposite & b1 is with_units
   holds b2 is with_units;

:: YELLOW18:th 14
theorem
for b1, b2, b3 being non empty AltCatStr
      st b1,b2 are_opposite
   holds    b1,b3 are_opposite
   iff
      AltCatStr(#the carrier of b2,the Arrows of b2,the Comp of b2#) = AltCatStr(#the carrier of b3,the Arrows of b3,the Comp of b3#);

:: YELLOW18:funcnot 1 => YELLOW18:func 1
definition
  let a1 be non empty transitive AltCatStr;
  func A1 opp -> non empty transitive strict AltCatStr means
    a1,it are_opposite;
end;

:: YELLOW18:def 4
theorem
for b1 being non empty transitive AltCatStr
for b2 being non empty transitive strict AltCatStr holds
      b2 = b1 opp
   iff
      b1,b2 are_opposite;

:: YELLOW18:funcreg 2
registration
  let a1 be non empty transitive associative AltCatStr;
  cluster a1 opp -> non empty transitive strict associative;
end;

:: YELLOW18:funcreg 3
registration
  let a1 be non empty transitive with_units AltCatStr;
  cluster a1 opp -> non empty transitive strict with_units;
end;

:: YELLOW18:funcnot 2 => YELLOW18:func 2
definition
  let a1, a2 be non empty transitive associative with_units AltCatStr;
  assume a1,a2 are_opposite;
  func dualizing-func(A1,A2) -> strict contravariant Functor of a1,a2 means
    (for b1 being Element of the carrier of a1 holds
        it . b1 = b1) &
     (for b1, b2 being Element of the carrier of a1
        st <^b1,b2^> <> {}
     for b3 being Element of <^b1,b2^> holds
        it . b3 = b3);
end;

:: YELLOW18:def 5
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite
for b3 being strict contravariant Functor of b1,b2 holds
      b3 = dualizing-func(b1,b2)
   iff
      (for b4 being Element of the carrier of b1 holds
          b3 . b4 = b4) &
       (for b4, b5 being Element of the carrier of b1
          st <^b4,b5^> <> {}
       for b6 being Element of <^b4,b5^> holds
          b3 . b6 = b6);

:: YELLOW18:th 15
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite
   holds (dualizing-func(b1,b2)) * dualizing-func(b2,b1) = id b2;

:: YELLOW18:th 16
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite
   holds dualizing-func(b1,b2) is bijective(b1, b2);

:: YELLOW18:funcreg 4
registration
  let a1 be non empty transitive associative with_units AltCatStr;
  cluster dualizing-func(a1,a1 opp) -> strict contravariant bijective;
end;

:: YELLOW18:funcreg 5
registration
  let a1 be non empty transitive associative with_units AltCatStr;
  cluster dualizing-func(a1 opp,a1) -> strict contravariant bijective;
end;

:: YELLOW18:th 17
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite
   holds b1,b2 are_anti-isomorphic;

:: YELLOW18:th 18
theorem
for b1, b2, b3 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite
   holds    b1,b3 are_isomorphic
   iff
      b2,b3 are_anti-isomorphic;

:: YELLOW18:th 19
theorem
for b1, b2, b3, b4 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite & b3,b4 are_opposite & b1,b3 are_isomorphic
   holds b2,b4 are_isomorphic;

:: YELLOW18:th 20
theorem
for b1, b2, b3, b4 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite & b3,b4 are_opposite & b1,b3 are_anti-isomorphic
   holds b2,b4 are_anti-isomorphic;

:: YELLOW18:th 21
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite
for b3, b4 being Element of the carrier of b1
   st <^b3,b4^> <> {} & <^b4,b3^> <> {}
for b5, b6 being Element of the carrier of b2
   st b5 = b3 & b6 = b4
for b7 being Element of <^b3,b4^>
for b8 being Element of <^b6,b5^>
      st b8 = b7
   holds    b7 is retraction(b1, b3, b4)
   iff
      b8 is coretraction(b2, b6, b5);

:: YELLOW18:th 22
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite
for b3, b4 being Element of the carrier of b1
   st <^b3,b4^> <> {} & <^b4,b3^> <> {}
for b5, b6 being Element of the carrier of b2
   st b5 = b3 & b6 = b4
for b7 being Element of <^b3,b4^>
for b8 being Element of <^b6,b5^>
      st b8 = b7
   holds    b7 is coretraction(b1, b3, b4)
   iff
      b8 is retraction(b2, b6, b5);

:: YELLOW18:th 23
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite
for b3, b4 being Element of the carrier of b1
   st <^b3,b4^> <> {} & <^b4,b3^> <> {}
for b5, b6 being Element of the carrier of b2
   st b5 = b3 & b6 = b4
for b7 being Element of <^b3,b4^>
for b8 being Element of <^b6,b5^>
      st b8 = b7 & b7 is retraction(b1, b3, b4) & b7 is coretraction(b1, b3, b4)
   holds b8 " = b7 ";

:: YELLOW18:th 24
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite
for b3, b4 being Element of the carrier of b1
   st <^b3,b4^> <> {} & <^b4,b3^> <> {}
for b5, b6 being Element of the carrier of b2
   st b5 = b3 & b6 = b4
for b7 being Element of <^b3,b4^>
for b8 being Element of <^b6,b5^>
      st b8 = b7
   holds    b7 is iso(b1, b3, b4)
   iff
      b8 is iso(b2, b6, b5);

:: YELLOW18:th 25
theorem
for b1, b2, b3, b4 being non empty transitive associative with_units AltCatStr
   st b1,b2 are_opposite & b3,b4 are_opposite
for b5, b6 being covariant Functor of b2,b3
      st b5,b6 are_naturally_equivalent
   holds ((dualizing-func(b3,b4)) * b6) * dualizing-func(b1,b2),((dualizing-func(b3,b4)) * b5) * dualizing-func(b1,b2) are_naturally_equivalent;

:: YELLOW18:th 26
theorem
for b1, b2, b3, b4 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite & b3,b4 are_opposite & b1,b3 are_equivalent
   holds b2,b4 are_equivalent;

:: YELLOW18:prednot 3 => YELLOW18:pred 3
definition
  let a1, a2 be non empty transitive associative with_units AltCatStr;
  pred A1,A2 are_dual means
    a1,a2 opp are_equivalent;
  symmetry;
::  for a1, a2 being non empty transitive associative with_units AltCatStr
::        st a1,a2 are_dual
::     holds a2,a1 are_dual;
end;

:: YELLOW18:dfs 6
definiens
  let a1, a2 be non empty transitive associative with_units AltCatStr;
To prove
     a1,a2 are_dual
it is sufficient to prove
  thus a1,a2 opp are_equivalent;

:: YELLOW18:def 6
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr holds
   b1,b2 are_dual
iff
   b1,b2 opp are_equivalent;

:: YELLOW18:th 27
theorem
for b1, b2 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_anti-isomorphic
   holds b1,b2 are_dual;

:: YELLOW18:th 28
theorem
for b1, b2, b3 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_opposite
   holds    b1,b3 are_equivalent
   iff
      b2,b3 are_dual;

:: YELLOW18:th 29
theorem
for b1, b2, b3 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_dual & b2,b3 are_equivalent
   holds b1,b3 are_dual;

:: YELLOW18:th 30
theorem
for b1, b2, b3 being non empty transitive associative with_units AltCatStr
      st b1,b2 are_dual & b2,b3 are_dual
   holds b1,b3 are_equivalent;

:: YELLOW18:th 31
theorem
for b1, b2, b3 being set holds
   b3 in Funcs(b1,b2)
iff
   b3 is Relation-like Function-like set & proj1 b3 = b1 & proj2 b3 c= b2;

:: YELLOW18:attrnot 2 => YELLOW18:attr 2
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  attr a1 is para-functional means
    ex b1 being ManySortedSet of the carrier of a1 st
       for b2, b3 being Element of the carrier of a1 holds
       <^b2,b3^> c= Funcs(b1 . b2,b1 . b3);
end;

:: YELLOW18:dfs 7
definiens
  let a1 be non empty transitive associative with_units AltCatStr;
To prove
     a1 is para-functional
it is sufficient to prove
  thus ex b1 being ManySortedSet of the carrier of a1 st
       for b2, b3 being Element of the carrier of a1 holds
       <^b2,b3^> c= Funcs(b1 . b2,b1 . b3);

:: YELLOW18:def 7
theorem
for b1 being non empty transitive associative with_units AltCatStr holds
      b1 is para-functional
   iff
      ex b2 being ManySortedSet of the carrier of b1 st
         for b3, b4 being Element of the carrier of b1 holds
         <^b3,b4^> c= Funcs(b2 . b3,b2 . b4);

:: YELLOW18:condreg 1
registration
  cluster non empty transitive quasi-functional associative with_units -> para-functional (AltCatStr);
end;

:: YELLOW18:funcnot 3 => YELLOW18:func 3
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  let a2 be set;
  func A1 -carrier_of A2 -> set means
    ex b1 being Element of the carrier of a1 st
       b1 = a2 & it = proj1 idm b1
    if a2 is Element of the carrier of a1
    otherwise it = {};
end;

:: YELLOW18:def 8
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2, b3 being set holds
(b2 is Element of the carrier of b1 implies    (b3 = b1 -carrier_of b2
 iff
    ex b4 being Element of the carrier of b1 st
       b4 = b2 & b3 = proj1 idm b4)) &
 (b2 is Element of the carrier of b1 or    (b3 = b1 -carrier_of b2
 iff
    b3 = {}));

:: YELLOW18:funcnot 4 => YELLOW18:func 3
notation
  let a1 be non empty transitive associative with_units AltCatStr;
  let a2 be Element of the carrier of a1;
  synonym the_carrier_of a2 for a1 -carrier_of a2;
end;

:: YELLOW18:funcnot 5 => YELLOW18:func 3
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  let a2 be set;
  func the_carrier_of A2 -> set equals
    proj1 idm a2;
end;

:: YELLOW18:def 9
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2 being Element of the carrier of b1 holds
   b1 -carrier_of b2 = proj1 idm b2;

:: YELLOW18:th 32
theorem
for b1 being non empty set
for b2 being Element of the carrier of EnsCat b1 holds
   idm b2 = id b2;

:: YELLOW18:th 33
theorem
for b1 being non empty set
for b2 being Element of the carrier of EnsCat b1 holds
   (EnsCat b1) -carrier_of b2 = b2;

:: YELLOW18:attrnot 3 => YELLOW18:attr 3
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  attr a1 is set-id-inheriting means
    for b1 being Element of the carrier of a1 holds
       idm b1 = id (a1 -carrier_of b1);
end;

:: YELLOW18:dfs 10
definiens
  let a1 be non empty transitive associative with_units AltCatStr;
To prove
     a1 is set-id-inheriting
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       idm b1 = id (a1 -carrier_of b1);

:: YELLOW18:def 10
theorem
for b1 being non empty transitive associative with_units AltCatStr holds
      b1 is set-id-inheriting
   iff
      for b2 being Element of the carrier of b1 holds
         idm b2 = id (b1 -carrier_of b2);

:: YELLOW18:funcreg 6
registration
  let a1 be non empty set;
  cluster EnsCat a1 -> non empty strict pseudo-functional set-id-inheriting;
end;

:: YELLOW18:attrnot 4 => YELLOW18:attr 4
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  attr a1 is concrete means
    a1 is para-functional & a1 is semi-functional & a1 is set-id-inheriting;
end;

:: YELLOW18:dfs 11
definiens
  let a1 be non empty transitive associative with_units AltCatStr;
To prove
     a1 is concrete
it is sufficient to prove
  thus a1 is para-functional & a1 is semi-functional & a1 is set-id-inheriting;

:: YELLOW18:def 11
theorem
for b1 being non empty transitive associative with_units AltCatStr holds
      b1 is concrete
   iff
      b1 is para-functional & b1 is semi-functional & b1 is set-id-inheriting;

:: YELLOW18:condreg 2
registration
  cluster non empty transitive associative with_units concrete -> semi-functional para-functional set-id-inheriting (AltCatStr);
end;

:: YELLOW18:condreg 3
registration
  cluster non empty transitive semi-functional associative with_units para-functional set-id-inheriting -> concrete (AltCatStr);
end;

:: YELLOW18:exreg 1
registration
  cluster non empty transitive strict quasi-functional associative with_units reflexive concrete AltCatStr;
end;

:: YELLOW18:th 34
theorem
for b1 being non empty transitive associative with_units AltCatStr holds
      b1 is para-functional
   iff
      for b2, b3 being Element of the carrier of b1 holds
      <^b2,b3^> c= Funcs(b1 -carrier_of b2,b1 -carrier_of b3);

:: YELLOW18:th 35
theorem
for b1 being non empty transitive associative with_units para-functional AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being Element of <^b2,b3^> holds
   b4 is Function-like quasi_total Relation of b1 -carrier_of b2,b1 -carrier_of b3;

:: YELLOW18:condreg 4
registration
  let a1 be non empty transitive associative with_units para-functional AltCatStr;
  let a2, a3 be Element of the carrier of a1;
  cluster -> Relation-like Function-like (Element of <^a2,a3^>);
end;

:: YELLOW18:th 36
theorem
for b1 being non empty transitive associative with_units para-functional AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being Element of <^b2,b3^> holds
   proj1 b4 = b1 -carrier_of b2 & proj2 b4 c= b1 -carrier_of b3;

:: YELLOW18:th 38
theorem
for b1 being non empty transitive semi-functional associative with_units para-functional AltCatStr
for b2, b3, b4 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b4^> <> {}
for b5 being Element of <^b2,b3^>
for b6 being Element of <^b3,b4^> holds
   b6 * b5 = b5 * b6;

:: YELLOW18:th 39
theorem
for b1 being non empty transitive semi-functional associative with_units para-functional AltCatStr
for b2 being Element of the carrier of b1
      st id (b1 -carrier_of b2) in <^b2,b2^>
   holds idm b2 = id (b1 -carrier_of b2);

:: YELLOW18:sch 16
scheme YELLOW18:sch 16
{F1 -> non empty set,
  F2 -> set,
  F3 -> set}:
ex b1 being non empty transitive strict associative with_units concrete AltCatStr st
   the carrier of b1 = F1() &
    (for b2 being Element of the carrier of b1 holds
       b1 -carrier_of b2 = F3(b2)) &
    (for b2, b3 being Element of the carrier of b1 holds
    <^b2,b3^> = F2(b2, b3))
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being Relation-like Function-like set
         st b4 in F2(b1, b2) & b5 in F2(b2, b3)
      holds b4 * b5 in F2(b1, b3)
and
   for b1, b2 being Element of F1() holds
   F2(b1, b2) c= Funcs(F3(b1),F3(b2))
and
   for b1 being Element of F1() holds
      id F3(b1) in F2(b1, b1);


:: YELLOW18:sch 17
scheme YELLOW18:sch 17
{F1 -> non empty set,
  F2 -> set}:
ex b1 being non empty transitive strict associative with_units concrete AltCatStr st
   the carrier of b1 = F1() &
    (for b2 being Element of the carrier of b1 holds
       b1 -carrier_of b2 = F2(b2)) &
    (for b2, b3 being Element of F1()
    for b4 being Relation-like Function-like set holds
          b4 in (the Arrows of b1) .(b2,b3)
       iff
          b4 in Funcs(F2(b2),F2(b3)) & P1[b2, b3, b4])
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being Relation-like Function-like set
         st P1[b1, b2, b4] & P1[b2, b3, b5]
      holds P1[b1, b3, b4 * b5]
and
   for b1 being Element of F1() holds
      P1[b1, b1, id F2(b1)];


:: YELLOW18:sch 18
scheme YELLOW18:sch 18
{F1 -> non empty set,
  F2 -> set}:
ex b1 being non empty transitive strict associative with_units concrete AltCatStr st
   the carrier of b1 = F1() &
    (for b2 being Element of the carrier of b1
    for b3 being set holds
          b3 in b1 -carrier_of b2
       iff
          b3 in F2(b2) & P1[b2, b3]) &
    (for b2, b3 being Element of F1()
    for b4 being Relation-like Function-like set holds
          b4 in (the Arrows of b1) .(b2,b3)
       iff
          b4 in Funcs(b1 -carrier_of b2,b1 -carrier_of b3) & P2[b2, b3, b4])
provided
   for b1, b2, b3 being Element of F1()
   for b4, b5 being Relation-like Function-like set
         st P2[b1, b2, b4] & P2[b2, b3, b5]
      holds P2[b1, b3, b4 * b5]
and
   for b1 being Element of F1()
   for b2 being set
         st for b3 being set holds
                 b3 in b2
              iff
                 b3 in F2(b1) & P1[b1, b3]
      holds P2[b1, b1, id b2];


:: YELLOW18:sch 19
scheme YELLOW18:sch 19
{F1 -> non empty set,
  F2 -> set}:
for b1, b2 being non empty transitive semi-functional associative with_units para-functional AltCatStr
      st the carrier of b1 = F1() &
         (for b3, b4 being Element of the carrier of b1 holds
         <^b3,b4^> = F2(b3, b4)) &
         the carrier of b2 = F1() &
         (for b3, b4 being Element of the carrier of b2 holds
         <^b3,b4^> = F2(b3, b4))
   holds AltCatStr(#the carrier of b1,the Arrows of b1,the Comp of b1#) = AltCatStr(#the carrier of b2,the Arrows of b2,the Comp of b2#)


:: YELLOW18:sch 20
scheme YELLOW18:sch 20
{F1 -> non empty set,
  F2 -> set}:
for b1, b2 being non empty transitive semi-functional associative with_units para-functional AltCatStr
      st the carrier of b1 = F1() &
         (for b3, b4 being Element of F1()
         for b5 being Relation-like Function-like set holds
               b5 in (the Arrows of b1) .(b3,b4)
            iff
               b5 in Funcs(F2(b3),F2(b4)) & P1[b3, b4, b5]) &
         the carrier of b2 = F1() &
         (for b3, b4 being Element of F1()
         for b5 being Relation-like Function-like set holds
               b5 in (the Arrows of b2) .(b3,b4)
            iff
               b5 in Funcs(F2(b3),F2(b4)) & P1[b3, b4, b5])
   holds AltCatStr(#the carrier of b1,the Arrows of b1,the Comp of b1#) = AltCatStr(#the carrier of b2,the Arrows of b2,the Comp of b2#)


:: YELLOW18:sch 21
scheme YELLOW18:sch 21
{F1 -> non empty set,
  F2 -> set}:
for b1, b2 being non empty transitive semi-functional associative with_units para-functional AltCatStr
      st the carrier of b1 = F1() &
         (for b3 being Element of the carrier of b1
         for b4 being set holds
               b4 in b1 -carrier_of b3
            iff
               b4 in F2(b3) & P1[b3, b4]) &
         (for b3, b4 being Element of F1()
         for b5 being Relation-like Function-like set holds
               b5 in (the Arrows of b1) .(b3,b4)
            iff
               b5 in Funcs(b1 -carrier_of b3,b1 -carrier_of b4) & P2[b3, b4, b5]) &
         the carrier of b2 = F1() &
         (for b3 being Element of the carrier of b2
         for b4 being set holds
               b4 in b2 -carrier_of b3
            iff
               b4 in F2(b3) & P1[b3, b4]) &
         (for b3, b4 being Element of F1()
         for b5 being Relation-like Function-like set holds
               b5 in (the Arrows of b2) .(b3,b4)
            iff
               b5 in Funcs(b2 -carrier_of b3,b2 -carrier_of b4) & P2[b3, b4, b5])
   holds AltCatStr(#the carrier of b1,the Arrows of b1,the Comp of b1#) = AltCatStr(#the carrier of b2,the Arrows of b2,the Comp of b2#)


:: YELLOW18:th 40
theorem
for b1 being non empty transitive associative with_units concrete AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b2^> <> {}
for b4 being Element of <^b2,b3^>
      st b4 is retraction(b1, b2, b3)
   holds proj2 b4 = b1 -carrier_of b3;

:: YELLOW18:th 41
theorem
for b1 being non empty transitive associative with_units concrete AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b2^> <> {}
for b4 being Element of <^b2,b3^>
      st b4 is coretraction(b1, b2, b3)
   holds b4 is one-to-one;

:: YELLOW18:th 42
theorem
for b1 being non empty transitive associative with_units concrete AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b2^> <> {}
for b4 being Element of <^b2,b3^>
      st b4 is iso(b1, b2, b3)
   holds b4 is one-to-one & proj2 b4 = b1 -carrier_of b3;

:: YELLOW18:th 43
theorem
for b1 being non empty transitive semi-functional associative with_units para-functional AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being Element of <^b2,b3^>
      st b4 is one-to-one & b4 " in <^b3,b2^>
   holds b4 is iso(b1, b2, b3);

:: YELLOW18:th 44
theorem
for b1 being non empty transitive associative with_units concrete AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b2^> <> {}
for b4 being Element of <^b2,b3^>
      st b4 is iso(b1, b2, b3)
   holds b4 " = b4 ";

:: YELLOW18:sch 22
scheme YELLOW18:sch 22
{F1 -> non empty transitive semi-functional associative with_units para-functional AltCatStr,
  F2 -> non empty transitive semi-functional associative with_units para-functional AltCatStr,
  F3 -> set,
  F4 -> set,
  F5 -> Relation-like Function-like set,
  F6 -> Relation-like Function-like set,
  F7 -> Relation-like Function-like set,
  F8 -> Relation-like Function-like set}:
F1(),F2() are_equivalent
provided
   ex b1 being covariant Functor of F1(),F2() st
      (for b2 being Element of the carrier of F1() holds
          b1 . b2 = F3(b2)) &
       (for b2, b3 being Element of the carrier of F1()
          st <^b2,b3^> <> {}
       for b4 being Element of <^b2,b3^> holds
          b1 . b4 = F5(b2, b3, b4))
and
   ex b1 being covariant Functor of F2(),F1() st
      (for b2 being Element of the carrier of F2() holds
          b1 . b2 = F4(b2)) &
       (for b2, b3 being Element of the carrier of F2()
          st <^b2,b3^> <> {}
       for b4 being Element of <^b2,b3^> holds
          b1 . b4 = F6(b2, b3, b4))
and
   for b1, b2 being Element of the carrier of F1()
         st b1 = F4(F3(b2))
      holds F7(b2) in <^b1,b2^> & F7(b2) " in <^b2,b1^> & F7(b2) is one-to-one
and
   for b1, b2 being Element of the carrier of F2()
         st b2 = F3(F4(b1))
      holds F8(b1) in <^b1,b2^> & F8(b1) " in <^b2,b1^> & F8(b1) is one-to-one
and
   for b1, b2 being Element of the carrier of F1()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      F6(F3(b1), F3(b2), F5(b1, b2, b3)) * F7(b2) = F7(b1) * b3
and
   for b1, b2 being Element of the carrier of F2()
      st <^b1,b2^> <> {}
   for b3 being Element of <^b1,b2^> holds
      F8(b1) * F5(F4(b1), F4(b2), F6(b1, b2, b3)) = b3 * F8(b2);


:: YELLOW18:funcnot 6 => YELLOW18:func 4
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  func Concretized A1 -> non empty transitive strict associative with_units concrete AltCatStr means
    the carrier of it = the carrier of a1 &
     (for b1 being Element of the carrier of it
     for b2 being set holds
           b2 in it -carrier_of b1
        iff
           b2 in Union disjoin the Arrows of a1 & b1 = b2 `22) &
     (for b1, b2 being Element of the carrier of a1
     for b3 being Relation-like Function-like set holds
           b3 in (the Arrows of it) .(b1,b2)
        iff
           b3 in Funcs(it -carrier_of b1,it -carrier_of b2) &
            (ex b4, b5 being Element of the carrier of a1 st
               ex b6 being Element of <^b4,b5^> st
                  b4 = b1 &
                   b5 = b2 &
                   <^b4,b5^> <> {} &
                   (for b7 being Element of the carrier of a1
                      st <^b7,b4^> <> {}
                   for b8 being Element of <^b7,b4^> holds
                      b3 . [b8,[b7,b4]] = [b6 * b8,[b7,b5]])));
end;

:: YELLOW18:def 12
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2 being non empty transitive strict associative with_units concrete AltCatStr holds
      b2 = Concretized b1
   iff
      the carrier of b2 = the carrier of b1 &
       (for b3 being Element of the carrier of b2
       for b4 being set holds
             b4 in b2 -carrier_of b3
          iff
             b4 in Union disjoin the Arrows of b1 & b3 = b4 `22) &
       (for b3, b4 being Element of the carrier of b1
       for b5 being Relation-like Function-like set holds
             b5 in (the Arrows of b2) .(b3,b4)
          iff
             b5 in Funcs(b2 -carrier_of b3,b2 -carrier_of b4) &
              (ex b6, b7 being Element of the carrier of b1 st
                 ex b8 being Element of <^b6,b7^> st
                    b6 = b3 &
                     b7 = b4 &
                     <^b6,b7^> <> {} &
                     (for b9 being Element of the carrier of b1
                        st <^b9,b6^> <> {}
                     for b10 being Element of <^b9,b6^> holds
                        b5 . [b10,[b9,b6]] = [b8 * b10,[b9,b7]])));

:: YELLOW18:th 45
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b3 in (Concretized b1) -carrier_of b2
   iff
      ex b4 being Element of the carrier of b1 st
         ex b5 being Element of <^b4,b2^> st
            <^b4,b2^> <> {} & b3 = [b5,[b4,b2]];

:: YELLOW18:funcreg 7
registration
  let a1 be non empty transitive associative with_units AltCatStr;
  let a2 be Element of the carrier of a1;
  cluster (Concretized a1) -carrier_of a2 -> non empty;
end;

:: YELLOW18:th 46
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being Element of <^b2,b3^> holds
   ex b5 being Function-like quasi_total Relation of (Concretized b1) -carrier_of b2,(Concretized b1) -carrier_of b3 st
      b5 in (the Arrows of Concretized b1) .(b2,b3) &
       (for b6 being Element of the carrier of b1
       for b7 being Element of <^b6,b2^>
             st <^b6,b2^> <> {}
          holds b5 . [b7,[b6,b2]] = [b4 * b7,[b6,b3]]);

:: YELLOW18:th 47
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4, b5 being Relation-like Function-like set
      st b4 in (the Arrows of Concretized b1) .(b2,b3) &
         b5 in (the Arrows of Concretized b1) .(b2,b3) &
         b4 . [idm b2,[b2,b2]] = b5 . [idm b2,[b2,b2]]
   holds b4 = b5;

:: YELLOW18:sch 23
scheme YELLOW18:sch 23
{F1 -> set,
  F2 -> ManySortedSet of F1(),
  F3 -> ManySortedSet of F1()}:
ex b1 being ManySortedFunction of F2(),F3() st
   for b2, b3 being set
         st b2 in F1() & b3 in F2() . b2
      holds (b1 . b2) . b3 in F3() . b2 & P1[b2, b3, (b1 . b2) . b3]
provided
   for b1, b2 being set
         st b1 in F1() & b2 in F2() . b1
      holds ex b3 being set st
         b3 in F3() . b1 & P1[b1, b2, b3];


:: YELLOW18:funcnot 7 => YELLOW18:func 5
definition
  let a1 be non empty transitive associative with_units AltCatStr;
  func Concretization A1 -> strict covariant Functor of a1,Concretized a1 means
    (for b1 being Element of the carrier of a1 holds
        it . b1 = b1) &
     (for b1, b2 being Element of the carrier of a1
        st <^b1,b2^> <> {}
     for b3 being Element of <^b1,b2^> holds
        (it . b3) . [idm b1,[b1,b1]] = [b3,[b1,b2]]);
end;

:: YELLOW18:def 13
theorem
for b1 being non empty transitive associative with_units AltCatStr
for b2 being strict covariant Functor of b1,Concretized b1 holds
      b2 = Concretization b1
   iff
      (for b3 being Element of the carrier of b1 holds
          b2 . b3 = b3) &
       (for b3, b4 being Element of the carrier of b1
          st <^b3,b4^> <> {}
       for b5 being Element of <^b3,b4^> holds
          (b2 . b5) . [idm b3,[b3,b3]] = [b5,[b3,b4]]);

:: YELLOW18:funcreg 8
registration
  let a1 be non empty transitive associative with_units AltCatStr;
  cluster Concretization a1 -> strict covariant bijective;
end;

:: YELLOW18:th 48
theorem
for b1 being non empty transitive associative with_units AltCatStr holds
   b1,Concretized b1 are_isomorphic;