Article ALTCAT_1, MML version 4.99.1005

:: ALTCAT_1:condreg 1
registration
  let a1 be functional set;
  cluster -> functional (Element of bool a1);
end;

:: ALTCAT_1:funcreg 1
registration
  let a1 be Relation-like Function-like Function-yielding set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like Function-yielding;
end;

:: ALTCAT_1:funcreg 2
registration
  let a1 be Relation-like Function-like set;
  cluster {a1} -> functional;
end;

:: ALTCAT_1:th 2
theorem
for b1 being set holds
   id b1 in Funcs(b1,b1);

:: ALTCAT_1:th 3
theorem
Funcs({},{}) = {id {}};

:: ALTCAT_1:th 4
theorem
for b1, b2, b3 being set
for b4, b5 being Relation-like Function-like set
      st b4 in Funcs(b1,b2) & b5 in Funcs(b2,b3)
   holds b4 * b5 in Funcs(b1,b3);

:: ALTCAT_1:th 5
theorem
for b1, b2, b3 being set
      st Funcs(b1,b2) <> {} & Funcs(b2,b3) <> {}
   holds Funcs(b1,b3) <> {};

:: ALTCAT_1:th 7
theorem
for b1, b2 being set
for b3 being ManySortedSet of [:b2,b1:]
for b4 being Element of bool b1
for b5 being Element of bool b2
for b6, b7 being set
      st b6 in b4 & b7 in b5
   holds b3 .(b7,b6) = (b3 | [:b5,b4:]) .(b7,b6);

:: ALTCAT_1:sch 1
scheme ALTCAT_1:sch 1
{F1 -> set,
  F2 -> set,
  F3 -> set}:
ex b1 being ManySortedSet of [:F1(),F2():] st
   for b2, b3 being set
         st b2 in F1() & b3 in F2()
      holds b1 .(b2,b3) = F3(b2, b3)


:: ALTCAT_1:sch 2
scheme ALTCAT_1:sch 2
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set}:
ex b1 being ManySortedSet of [:F1(),F2():] st
   for b2 being Element of F1()
   for b3 being Element of F2() holds
      b1 .(b2,b3) = F3(b2, b3)


:: ALTCAT_1:sch 3
scheme ALTCAT_1:sch 3
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set}:
ex b1 being ManySortedSet of [:F1(),F2(),F3():] st
   for b2, b3, b4 being set
         st b2 in F1() & b3 in F2() & b4 in F3()
      holds b1 .(b2,b3,b4) = F4(b2, b3, b4)


:: ALTCAT_1:sch 4
scheme ALTCAT_1:sch 4
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> set}:
ex b1 being ManySortedSet of [:F1(),F2(),F3():] st
   for b2 being Element of F1()
   for b3 being Element of F2()
   for b4 being Element of F3() holds
      b1 .(b2,b3,b4) = F4(b2, b3, b4)


:: ALTCAT_1:th 8
theorem
for b1, b2 being set
for b3, b4 being ManySortedSet of [:b1,b2:]
      st for b5, b6 being set
              st b5 in b1 & b6 in b2
           holds b3 .(b5,b6) = b4 .(b5,b6)
   holds b4 = b3;

:: ALTCAT_1:th 9
theorem
for b1, b2 being non empty set
for b3, b4 being ManySortedSet of [:b1,b2:]
      st for b5 being Element of b1
        for b6 being Element of b2 holds
           b3 .(b5,b6) = b4 .(b5,b6)
   holds b4 = b3;

:: ALTCAT_1:th 10
theorem
for b1 being set
for b2, b3 being ManySortedSet of [:b1,b1,b1:]
      st for b4, b5, b6 being set
              st b4 in b1 & b5 in b1 & b6 in b1
           holds b2 .(b4,b5,b6) = b3 .(b4,b5,b6)
   holds b3 = b2;

:: ALTCAT_1:th 11
theorem
for b1, b2, b3 being set holds
(b1,b2):-> b3 = [b1,b2] .--> b3;

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

:: ALTCAT_1:structnot 1 => ALTCAT_1:struct 1
definition
  struct(1-sorted) AltGraph(#
    carrier -> set,
    Arrows -> ManySortedSet of [:the carrier of it,the carrier of it:]
  #);
end;

:: ALTCAT_1:attrnot 1 => ALTCAT_1:attr 1
definition
  let a1 be AltGraph;
  attr a1 is strict;
end;

:: ALTCAT_1:exreg 1
registration
  cluster strict AltGraph;
end;

:: ALTCAT_1:aggrnot 1 => ALTCAT_1:aggr 1
definition
  let a1 be set;
  let a2 be ManySortedSet of [:a1,a1:];
  aggr AltGraph(#a1,a2#) -> strict AltGraph;
end;

:: ALTCAT_1:selnot 1 => ALTCAT_1:sel 1
definition
  let a1 be AltGraph;
  sel the Arrows of a1 -> ManySortedSet of [:the carrier of a1,the carrier of a1:];
end;

:: ALTCAT_1:modenot 1
definition
  let a1 be AltGraph;
  mode object of a1 is Element of the carrier of a1;
end;

:: ALTCAT_1:funcnot 1 => ALTCAT_1:func 1
definition
  let a1 be AltGraph;
  let a2, a3 be Element of the carrier of a1;
  func <^A2,A3^> -> set equals
    (the Arrows of a1) .(a2,a3);
end;

:: ALTCAT_1:def 2
theorem
for b1 being AltGraph
for b2, b3 being Element of the carrier of b1 holds
<^b2,b3^> = (the Arrows of b1) .(b2,b3);

:: ALTCAT_1:modenot 2
definition
  let a1 be AltGraph;
  let a2, a3 be Element of the carrier of a1;
  mode Morphism of a2,a3 is Element of <^a2,a3^>;
end;

:: ALTCAT_1:attrnot 2 => ALTCAT_1:attr 2
definition
  let a1 be AltGraph;
  attr a1 is transitive means
    for b1, b2, b3 being Element of the carrier of a1
          st <^b1,b2^> <> {} & <^b2,b3^> <> {}
       holds <^b1,b3^> <> {};
end;

:: ALTCAT_1:dfs 2
definiens
  let a1 be AltGraph;
To prove
     a1 is transitive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
          st <^b1,b2^> <> {} & <^b2,b3^> <> {}
       holds <^b1,b3^> <> {};

:: ALTCAT_1:def 4
theorem
for b1 being AltGraph holds
      b1 is transitive
   iff
      for b2, b3, b4 being Element of the carrier of b1
            st <^b2,b3^> <> {} & <^b3,b4^> <> {}
         holds <^b2,b4^> <> {};

:: ALTCAT_1:funcnot 2 => ALTCAT_1:func 2
definition
  let a1 be set;
  let a2 be ManySortedSet of [:a1,a1:];
  func {|A2|} -> ManySortedSet of [:a1,a1,a1:] means
    for b1, b2, b3 being set
          st b1 in a1 & b2 in a1 & b3 in a1
       holds it .(b1,b2,b3) = a2 .(b1,b3);
end;

:: ALTCAT_1:def 5
theorem
for b1 being set
for b2 being ManySortedSet of [:b1,b1:]
for b3 being ManySortedSet of [:b1,b1,b1:] holds
      b3 = {|b2|}
   iff
      for b4, b5, b6 being set
            st b4 in b1 & b5 in b1 & b6 in b1
         holds b3 .(b4,b5,b6) = b2 .(b4,b6);

:: ALTCAT_1:funcnot 3 => ALTCAT_1:func 3
definition
  let a1 be set;
  let a2, a3 be ManySortedSet of [:a1,a1:];
  func {|A2,A3|} -> ManySortedSet of [:a1,a1,a1:] means
    for b1, b2, b3 being set
          st b1 in a1 & b2 in a1 & b3 in a1
       holds it .(b1,b2,b3) = [:a3 .(b2,b3),a2 .(b1,b2):];
end;

:: ALTCAT_1:def 6
theorem
for b1 being set
for b2, b3 being ManySortedSet of [:b1,b1:]
for b4 being ManySortedSet of [:b1,b1,b1:] holds
      b4 = {|b2,b3|}
   iff
      for b5, b6, b7 being set
            st b5 in b1 & b6 in b1 & b7 in b1
         holds b4 .(b5,b6,b7) = [:b3 .(b6,b7),b2 .(b5,b6):];

:: ALTCAT_1:modenot 3
definition
  let a1 be set;
  let a2 be ManySortedSet of [:a1,a1:];
  mode BinComp of a2 is ManySortedFunction of {|a2,a2|},{|a2|};
end;

:: ALTCAT_1:funcnot 4 => ALTCAT_1:func 4
definition
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
  let a4, a5, a6 be Element of a1;
  redefine func a3 .(a4,a5,a6) -> Function-like quasi_total Relation of [:a2 .(a5,a6),a2 .(a4,a5):],a2 .(a4,a6);
end;

:: ALTCAT_1:attrnot 3 => ALTCAT_1:attr 3
definition
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
  attr a3 is associative means
    for b1, b2, b3, b4 being Element of a1
    for b5, b6, b7 being set
          st b5 in a2 .(b1,b2) & b6 in a2 .(b2,b3) & b7 in a2 .(b3,b4)
       holds (a3 .(b1,b3,b4)) .(b7,(a3 .(b1,b2,b3)) .(b6,b5)) = (a3 .(b1,b2,b4)) .((a3 .(b2,b3,b4)) .(b7,b6),b5);
end;

:: ALTCAT_1:dfs 5
definiens
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
To prove
     a3 is associative
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of a1
    for b5, b6, b7 being set
          st b5 in a2 .(b1,b2) & b6 in a2 .(b2,b3) & b7 in a2 .(b3,b4)
       holds (a3 .(b1,b3,b4)) .(b7,(a3 .(b1,b2,b3)) .(b6,b5)) = (a3 .(b1,b2,b4)) .((a3 .(b2,b3,b4)) .(b7,b6),b5);

:: ALTCAT_1:def 7
theorem
for b1 being non empty set
for b2 being ManySortedSet of [:b1,b1:]
for b3 being ManySortedFunction of {|b2,b2|},{|b2|} holds
      b3 is associative(b1, b2)
   iff
      for b4, b5, b6, b7 being Element of b1
      for b8, b9, b10 being set
            st b8 in b2 .(b4,b5) & b9 in b2 .(b5,b6) & b10 in b2 .(b6,b7)
         holds (b3 .(b4,b6,b7)) .(b10,(b3 .(b4,b5,b6)) .(b9,b8)) = (b3 .(b4,b5,b7)) .((b3 .(b5,b6,b7)) .(b10,b9),b8);

:: ALTCAT_1:attrnot 4 => ALTCAT_1:attr 4
definition
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
  attr a3 is with_right_units means
    for b1 being Element of a1 holds
       ex b2 being set st
          b2 in a2 .(b1,b1) &
           (for b3 being Element of a1
           for b4 being set
                 st b4 in a2 .(b1,b3)
              holds (a3 .(b1,b1,b3)) .(b4,b2) = b4);
end;

:: ALTCAT_1:dfs 6
definiens
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
To prove
     a3 is with_right_units
it is sufficient to prove
  thus for b1 being Element of a1 holds
       ex b2 being set st
          b2 in a2 .(b1,b1) &
           (for b3 being Element of a1
           for b4 being set
                 st b4 in a2 .(b1,b3)
              holds (a3 .(b1,b1,b3)) .(b4,b2) = b4);

:: ALTCAT_1:def 8
theorem
for b1 being non empty set
for b2 being ManySortedSet of [:b1,b1:]
for b3 being ManySortedFunction of {|b2,b2|},{|b2|} holds
      b3 is with_right_units(b1, b2)
   iff
      for b4 being Element of b1 holds
         ex b5 being set st
            b5 in b2 .(b4,b4) &
             (for b6 being Element of b1
             for b7 being set
                   st b7 in b2 .(b4,b6)
                holds (b3 .(b4,b4,b6)) .(b7,b5) = b7);

:: ALTCAT_1:attrnot 5 => ALTCAT_1:attr 5
definition
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
  attr a3 is with_left_units means
    for b1 being Element of a1 holds
       ex b2 being set st
          b2 in a2 .(b1,b1) &
           (for b3 being Element of a1
           for b4 being set
                 st b4 in a2 .(b3,b1)
              holds (a3 .(b3,b1,b1)) .(b2,b4) = b4);
end;

:: ALTCAT_1:dfs 7
definiens
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
To prove
     a3 is with_left_units
it is sufficient to prove
  thus for b1 being Element of a1 holds
       ex b2 being set st
          b2 in a2 .(b1,b1) &
           (for b3 being Element of a1
           for b4 being set
                 st b4 in a2 .(b3,b1)
              holds (a3 .(b3,b1,b1)) .(b2,b4) = b4);

:: ALTCAT_1:def 9
theorem
for b1 being non empty set
for b2 being ManySortedSet of [:b1,b1:]
for b3 being ManySortedFunction of {|b2,b2|},{|b2|} holds
      b3 is with_left_units(b1, b2)
   iff
      for b4 being Element of b1 holds
         ex b5 being set st
            b5 in b2 .(b4,b4) &
             (for b6 being Element of b1
             for b7 being set
                   st b7 in b2 .(b6,b4)
                holds (b3 .(b6,b4,b4)) .(b5,b7) = b7);

:: ALTCAT_1:structnot 2 => ALTCAT_1:struct 2
definition
  struct(AltGraph) AltCatStr(#
    carrier -> set,
    Arrows -> ManySortedSet of [:the carrier of it,the carrier of it:],
    Comp -> ManySortedFunction of {|the Arrows of it,the Arrows of it|},{|the Arrows of it|}
  #);
end;

:: ALTCAT_1:attrnot 6 => ALTCAT_1:attr 6
definition
  let a1 be AltCatStr;
  attr a1 is strict;
end;

:: ALTCAT_1:exreg 2
registration
  cluster strict AltCatStr;
end;

:: ALTCAT_1:aggrnot 2 => ALTCAT_1:aggr 2
definition
  let a1 be set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
  aggr AltCatStr(#a1,a2,a3#) -> strict AltCatStr;
end;

:: ALTCAT_1:selnot 2 => ALTCAT_1:sel 2
definition
  let a1 be AltCatStr;
  sel the Comp of a1 -> ManySortedFunction of {|the Arrows of a1,the Arrows of a1|},{|the Arrows of a1|};
end;

:: ALTCAT_1:exreg 3
registration
  cluster non empty strict AltCatStr;
end;

:: ALTCAT_1:funcnot 5 => ALTCAT_1:func 5
definition
  let a1 be non empty AltCatStr;
  let a2, a3, a4 be Element of the carrier of a1;
  let a5 be Element of <^a2,a3^>;
  let a6 be Element of <^a3,a4^>;
  assume <^a2,a3^> <> {} & <^a3,a4^> <> {};
  func A6 * A5 -> Element of <^a2,a4^> equals
    ((the Comp of a1) .(a2,a3,a4)) .(a6,a5);
end;

:: ALTCAT_1:def 10
theorem
for b1 being non empty 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 = ((the Comp of b1) .(b2,b3,b4)) .(b6,b5);

:: ALTCAT_1:attrnot 7 => ALTCAT_1:attr 7
definition
  let a1 be Relation-like Function-like set;
  attr a1 is compositional means
    for b1 being set
          st b1 in proj1 a1
       holds ex b2, b3 being Relation-like Function-like set st
          b1 = [b3,b2] & a1 . b1 = b2 * b3;
end;

:: ALTCAT_1:dfs 9
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is compositional
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds ex b2, b3 being Relation-like Function-like set st
          b1 = [b3,b2] & a1 . b1 = b2 * b3;

:: ALTCAT_1:def 11
theorem
for b1 being Relation-like Function-like set holds
      b1 is compositional
   iff
      for b2 being set
            st b2 in proj1 b1
         holds ex b3, b4 being Relation-like Function-like set st
            b2 = [b4,b3] & b1 . b2 = b3 * b4;

:: ALTCAT_1:exreg 4
registration
  let a1, a2 be functional set;
  cluster Relation-like Function-like Function-yielding compositional ManySortedSet of [:a1,a2:];
end;

:: ALTCAT_1:th 13
theorem
for b1, b2 being functional set
for b3 being compositional ManySortedSet of [:b1,b2:]
for b4, b5 being Relation-like Function-like set
      st b4 in b1 & b5 in b2
   holds b3 .(b4,b5) = b5 * b4;

:: ALTCAT_1:funcnot 6 => ALTCAT_1:func 6
definition
  let a1, a2 be functional set;
  func FuncComp(A1,A2) -> Function-yielding compositional ManySortedSet of [:a2,a1:] means
    TRUE;
end;

:: ALTCAT_1:def 12
theorem
for b1, b2 being functional set
for b3 being Function-yielding compositional ManySortedSet of [:b2,b1:] holds
   (b3 = FuncComp(b1,b2) implies TRUE) & b3 = FuncComp(b1,b2);

:: ALTCAT_1:th 14
theorem
for b1, b2, b3 being set holds
proj2 FuncComp(Funcs(b1,b2),Funcs(b2,b3)) c= Funcs(b1,b3);

:: ALTCAT_1:th 15
theorem
for b1 being set holds
   FuncComp({id b1},{id b1}) = (id b1,id b1):-> id b1;

:: ALTCAT_1:th 16
theorem
for b1, b2 being functional set
for b3 being Element of bool b1
for b4 being Element of bool b2 holds
   FuncComp(b3,b4) = (FuncComp(b1,b2)) | [:b4,b3:];

:: ALTCAT_1:attrnot 8 => ALTCAT_1:attr 8
definition
  let a1 be non empty AltCatStr;
  attr a1 is quasi-functional means
    for b1, b2 being Element of the carrier of a1 holds
    <^b1,b2^> c= Funcs(b1,b2);
end;

:: ALTCAT_1:dfs 11
definiens
  let a1 be non empty AltCatStr;
To prove
     a1 is quasi-functional
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    <^b1,b2^> c= Funcs(b1,b2);

:: ALTCAT_1:def 13
theorem
for b1 being non empty AltCatStr holds
      b1 is quasi-functional
   iff
      for b2, b3 being Element of the carrier of b1 holds
      <^b2,b3^> c= Funcs(b2,b3);

:: ALTCAT_1:attrnot 9 => ALTCAT_1:attr 9
definition
  let a1 be non empty AltCatStr;
  attr a1 is semi-functional means
    for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {} & <^b1,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^>
    for b6, b7 being Relation-like Function-like set
          st b4 = b6 & b5 = b7
       holds b5 * b4 = b6 * b7;
end;

:: ALTCAT_1:dfs 12
definiens
  let a1 be non empty AltCatStr;
To prove
     a1 is semi-functional
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
       st <^b1,b2^> <> {} & <^b2,b3^> <> {} & <^b1,b3^> <> {}
    for b4 being Element of <^b1,b2^>
    for b5 being Element of <^b2,b3^>
    for b6, b7 being Relation-like Function-like set
          st b4 = b6 & b5 = b7
       holds b5 * b4 = b6 * b7;

:: ALTCAT_1:def 14
theorem
for b1 being non empty AltCatStr holds
      b1 is semi-functional
   iff
      for b2, b3, b4 being Element of the carrier of b1
         st <^b2,b3^> <> {} & <^b3,b4^> <> {} & <^b2,b4^> <> {}
      for b5 being Element of <^b2,b3^>
      for b6 being Element of <^b3,b4^>
      for b7, b8 being Relation-like Function-like set
            st b5 = b7 & b6 = b8
         holds b6 * b5 = b7 * b8;

:: ALTCAT_1:attrnot 10 => ALTCAT_1:attr 10
definition
  let a1 be non empty AltCatStr;
  attr a1 is pseudo-functional means
    for b1, b2, b3 being Element of the carrier of a1 holds
    (the Comp of a1) .(b1,b2,b3) = (FuncComp(Funcs(b1,b2),Funcs(b2,b3))) | [:<^b2,b3^>,<^b1,b2^>:];
end;

:: ALTCAT_1:dfs 13
definiens
  let a1 be non empty AltCatStr;
To prove
     a1 is pseudo-functional
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    (the Comp of a1) .(b1,b2,b3) = (FuncComp(Funcs(b1,b2),Funcs(b2,b3))) | [:<^b2,b3^>,<^b1,b2^>:];

:: ALTCAT_1:def 15
theorem
for b1 being non empty AltCatStr holds
      b1 is pseudo-functional
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      (the Comp of b1) .(b2,b3,b4) = (FuncComp(Funcs(b2,b3),Funcs(b3,b4))) | [:<^b3,b4^>,<^b2,b3^>:];

:: ALTCAT_1:funcreg 3
registration
  let a1 be non empty set;
  let a2 be ManySortedSet of [:a1,a1:];
  let a3 be ManySortedFunction of {|a2,a2|},{|a2|};
  cluster AltCatStr(#a1,a2,a3#) -> non empty strict;
end;

:: ALTCAT_1:exreg 5
registration
  cluster non empty strict pseudo-functional AltCatStr;
end;

:: ALTCAT_1:th 17
theorem
for b1 being non empty AltCatStr
for b2, b3, b4 being Element of the carrier of b1 holds
(the Comp of b1) .(b2,b3,b4) is Function-like quasi_total Relation of [:<^b3,b4^>,<^b2,b3^>:],<^b2,b4^>;

:: ALTCAT_1:th 18
theorem
for b1 being non empty pseudo-functional AltCatStr
for b2, b3, b4 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b4^> <> {} & <^b2,b4^> <> {}
for b5 being Element of <^b2,b3^>
for b6 being Element of <^b3,b4^>
for b7, b8 being Relation-like Function-like set
      st b5 = b7 & b6 = b8
   holds b6 * b5 = b7 * b8;

:: ALTCAT_1:funcnot 7 => ALTCAT_1:func 7
definition
  let a1 be non empty set;
  func EnsCat A1 -> non empty strict pseudo-functional AltCatStr means
    the carrier of it = a1 &
     (for b1, b2 being Element of the carrier of it holds
     <^b1,b2^> = Funcs(b1,b2));
end;

:: ALTCAT_1:def 16
theorem
for b1 being non empty set
for b2 being non empty strict pseudo-functional AltCatStr holds
      b2 = EnsCat b1
   iff
      the carrier of b2 = b1 &
       (for b3, b4 being Element of the carrier of b2 holds
       <^b3,b4^> = Funcs(b3,b4));

:: ALTCAT_1:attrnot 11 => ALTCAT_1:attr 11
definition
  let a1 be non empty AltCatStr;
  attr a1 is associative means
    the Comp of a1 is associative(the carrier of a1, the Arrows of a1);
end;

:: ALTCAT_1:dfs 15
definiens
  let a1 be non empty AltCatStr;
To prove
     a1 is associative
it is sufficient to prove
  thus the Comp of a1 is associative(the carrier of a1, the Arrows of a1);

:: ALTCAT_1:def 17
theorem
for b1 being non empty AltCatStr holds
      b1 is associative
   iff
      the Comp of b1 is associative(the carrier of b1, the Arrows of b1);

:: ALTCAT_1:attrnot 12 => ALTCAT_1:attr 12
definition
  let a1 be non empty AltCatStr;
  attr a1 is with_units means
    the Comp of a1 is with_left_units(the carrier of a1, the Arrows of a1) & the Comp of a1 is with_right_units(the carrier of a1, the Arrows of a1);
end;

:: ALTCAT_1:dfs 16
definiens
  let a1 be non empty AltCatStr;
To prove
     a1 is with_units
it is sufficient to prove
  thus the Comp of a1 is with_left_units(the carrier of a1, the Arrows of a1) & the Comp of a1 is with_right_units(the carrier of a1, the Arrows of a1);

:: ALTCAT_1:def 18
theorem
for b1 being non empty AltCatStr holds
      b1 is with_units
   iff
      the Comp of b1 is with_left_units(the carrier of b1, the Arrows of b1) & the Comp of b1 is with_right_units(the carrier of b1, the Arrows of b1);

:: ALTCAT_1:exreg 6
registration
  cluster non empty transitive strict associative with_units AltCatStr;
end;

:: ALTCAT_1:th 20
theorem
for b1 being non empty transitive AltCatStr
for b2, b3, b4 being Element of the carrier of b1 holds
proj1 ((the Comp of b1) .(b2,b3,b4)) = [:<^b3,b4^>,<^b2,b3^>:] &
 proj2 ((the Comp of b1) .(b2,b3,b4)) c= <^b2,b4^>;

:: ALTCAT_1:th 21
theorem
for b1 being non empty with_units AltCatStr
for b2 being Element of the carrier of b1 holds
   <^b2,b2^> <> {};

:: ALTCAT_1:funcreg 4
registration
  let a1 be non empty set;
  cluster EnsCat a1 -> non empty transitive strict pseudo-functional associative with_units;
end;

:: ALTCAT_1:condreg 2
registration
  cluster non empty transitive quasi-functional semi-functional -> pseudo-functional (AltCatStr);
end;

:: ALTCAT_1:condreg 3
registration
  cluster non empty transitive pseudo-functional with_units -> quasi-functional semi-functional (AltCatStr);
end;

:: ALTCAT_1:modenot 4
definition
  mode category is non empty transitive associative with_units AltCatStr;
end;

:: ALTCAT_1:funcnot 8 => ALTCAT_1:func 8
definition
  let a1 be non empty with_units AltCatStr;
  let a2 be Element of the carrier of a1;
  func idm A2 -> Element of <^a2,a2^> means
    for b1 being Element of the carrier of a1
       st <^a2,b1^> <> {}
    for b2 being Element of <^a2,b1^> holds
       b2 * it = b2;
end;

:: ALTCAT_1:def 19
theorem
for b1 being non empty with_units AltCatStr
for b2 being Element of the carrier of b1
for b3 being Element of <^b2,b2^> holds
      b3 = idm b2
   iff
      for b4 being Element of the carrier of b1
         st <^b2,b4^> <> {}
      for b5 being Element of <^b2,b4^> holds
         b5 * b3 = b5;

:: ALTCAT_1:th 23
theorem
for b1 being non empty with_units AltCatStr
for b2 being Element of the carrier of b1 holds
   idm b2 in <^b2,b2^>;

:: ALTCAT_1:th 24
theorem
for b1 being non empty with_units AltCatStr
for b2, b3 being Element of the carrier of b1
   st <^b2,b3^> <> {}
for b4 being Element of <^b2,b3^> holds
   (idm b3) * b4 = b4;

:: ALTCAT_1:th 25
theorem
for b1 being non empty transitive associative AltCatStr
for b2, b3, b4, b5 being Element of the carrier of b1
   st <^b2,b3^> <> {} & <^b3,b4^> <> {} & <^b4,b5^> <> {}
for b6 being Element of <^b2,b3^>
for b7 being Element of <^b3,b4^>
for b8 being Element of <^b4,b5^> holds
   b8 * (b7 * b6) = (b8 * b7) * b6;

:: ALTCAT_1:attrnot 13 => ALTCAT_1:attr 13
definition
  let a1 be AltCatStr;
  attr a1 is quasi-discrete means
    for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds b1 = b2;
end;

:: ALTCAT_1:dfs 18
definiens
  let a1 be AltCatStr;
To prove
     a1 is quasi-discrete
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st <^b1,b2^> <> {}
       holds b1 = b2;

:: ALTCAT_1:def 20
theorem
for b1 being AltCatStr holds
      b1 is quasi-discrete
   iff
      for b2, b3 being Element of the carrier of b1
            st <^b2,b3^> <> {}
         holds b2 = b3;

:: ALTCAT_1:attrnot 14 => ALTCAT_1:attr 14
definition
  let a1 be AltCatStr;
  attr a1 is pseudo-discrete means
    for b1 being Element of the carrier of a1 holds
       <^b1,b1^> is trivial;
end;

:: ALTCAT_1:dfs 19
definiens
  let a1 be AltCatStr;
To prove
     a1 is pseudo-discrete
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       <^b1,b1^> is trivial;

:: ALTCAT_1:def 21
theorem
for b1 being AltCatStr holds
      b1 is pseudo-discrete
   iff
      for b2 being Element of the carrier of b1 holds
         <^b2,b2^> is trivial;

:: ALTCAT_1:th 26
theorem
for b1 being non empty with_units AltCatStr holds
      b1 is pseudo-discrete
   iff
      for b2 being Element of the carrier of b1 holds
         <^b2,b2^> = {idm b2};

:: ALTCAT_1:condreg 4
registration
  cluster non empty trivial -> quasi-discrete (AltCatStr);
end;

:: ALTCAT_1:th 27
theorem
EnsCat 1 is pseudo-discrete & EnsCat 1 is trivial;

:: ALTCAT_1:exreg 7
registration
  cluster non empty trivial transitive strict associative with_units pseudo-discrete AltCatStr;
end;

:: ALTCAT_1:exreg 8
registration
  cluster non empty trivial transitive strict associative with_units quasi-discrete pseudo-discrete AltCatStr;
end;

:: ALTCAT_1:modenot 5
definition
  mode discrete_category is non empty transitive associative with_units quasi-discrete pseudo-discrete AltCatStr;
end;

:: ALTCAT_1:funcnot 9 => ALTCAT_1:func 9
definition
  let a1 be non empty set;
  func DiscrCat A1 -> non empty strict quasi-discrete AltCatStr means
    the carrier of it = a1 &
     (for b1 being Element of the carrier of it holds
        <^b1,b1^> = {id b1});
end;

:: ALTCAT_1:def 22
theorem
for b1 being non empty set
for b2 being non empty strict quasi-discrete AltCatStr holds
      b2 = DiscrCat b1
   iff
      the carrier of b2 = b1 &
       (for b3 being Element of the carrier of b2 holds
          <^b3,b3^> = {id b3});

:: ALTCAT_1:condreg 5
registration
  cluster quasi-discrete -> transitive (AltCatStr);
end;

:: ALTCAT_1:th 28
theorem
for b1 being non empty set
for b2, b3, b4 being Element of the carrier of DiscrCat b1
      st (b2 = b3 implies b3 <> b4)
   holds (the Comp of DiscrCat b1) .(b2,b3,b4) = {};

:: ALTCAT_1:th 29
theorem
for b1 being non empty set
for b2 being Element of the carrier of DiscrCat b1 holds
   (the Comp of DiscrCat b1) .(b2,b2,b2) = (id b2,id b2):-> id b2;

:: ALTCAT_1:funcreg 5
registration
  let a1 be non empty set;
  cluster DiscrCat a1 -> non empty strict pseudo-functional associative with_units quasi-discrete pseudo-discrete;
end;