Article RINGCAT1, MML version 4.99.1005

:: RINGCAT1:attrnot 1 => RINGCAT1:attr 1
definition
  let a1, a2 be non empty doubleLoopStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is linear means
    a3 is additive(a1, a2) & a3 is multiplicative(a1, a2) & a3 is unity-preserving(a1, a2);
end;

:: RINGCAT1:dfs 1
definiens
  let a1, a2 be non empty doubleLoopStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is linear
it is sufficient to prove
  thus a3 is additive(a1, a2) & a3 is multiplicative(a1, a2) & a3 is unity-preserving(a1, a2);

:: RINGCAT1:def 2
theorem
for b1, b2 being non empty doubleLoopStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
      b3 is linear(b1, b2)
   iff
      b3 is additive(b1, b2) & b3 is multiplicative(b1, b2) & b3 is unity-preserving(b1, b2);

:: RINGCAT1:condreg 1
registration
  let a1, a2 be non empty doubleLoopStr;
  cluster Function-like quasi_total linear -> additive unity-preserving multiplicative (Relation of the carrier of a1,the carrier of a2);
end;

:: RINGCAT1:condreg 2
registration
  let a1, a2 be non empty doubleLoopStr;
  cluster Function-like quasi_total additive unity-preserving multiplicative -> linear (Relation of the carrier of a1,the carrier of a2);
end;

:: RINGCAT1:th 3
theorem
for b1, b2, b3 being non empty doubleLoopStr
for b4 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3
      st b4 is linear(b1, b2) & b5 is linear(b2, b3)
   holds b5 * b4 is linear(b1, b3);

:: RINGCAT1:structnot 1 => RINGCAT1:struct 1
definition
  struct() RingMorphismStr(#
    Dom -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr,
    Cod -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr,
    Fun -> Function-like quasi_total Relation of the carrier of the Dom of it,the carrier of the Cod of it
  #);
end;

:: RINGCAT1:attrnot 2 => RINGCAT1:attr 2
definition
  let a1 be RingMorphismStr;
  attr a1 is strict;
end;

:: RINGCAT1:exreg 1
registration
  cluster strict RingMorphismStr;
end;

:: RINGCAT1:aggrnot 1 => RINGCAT1:aggr 1
definition
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  aggr RingMorphismStr(#a1,a2,a3#) -> strict RingMorphismStr;
end;

:: RINGCAT1:selnot 1 => RINGCAT1:sel 1
definition
  let a1 be RingMorphismStr;
  sel the Dom of a1 -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
end;

:: RINGCAT1:selnot 2 => RINGCAT1:sel 2
definition
  let a1 be RingMorphismStr;
  sel the Cod of a1 -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
end;

:: RINGCAT1:selnot 3 => RINGCAT1:sel 3
definition
  let a1 be RingMorphismStr;
  sel the Fun of a1 -> Function-like quasi_total Relation of the carrier of the Dom of a1,the carrier of the Cod of a1;
end;

:: RINGCAT1:funcnot 1 => RINGCAT1:func 1
definition
  let a1 be RingMorphismStr;
  func dom A1 -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr equals
    the Dom of a1;
end;

:: RINGCAT1:def 3
theorem
for b1 being RingMorphismStr holds
   dom b1 = the Dom of b1;

:: RINGCAT1:funcnot 2 => RINGCAT1:func 2
definition
  let a1 be RingMorphismStr;
  func cod A1 -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr equals
    the Cod of a1;
end;

:: RINGCAT1:def 4
theorem
for b1 being RingMorphismStr holds
   cod b1 = the Cod of b1;

:: RINGCAT1:funcnot 3 => RINGCAT1:func 3
definition
  let a1 be RingMorphismStr;
  func fun A1 -> Function-like quasi_total Relation of the carrier of the Dom of a1,the carrier of the Cod of a1 equals
    the Fun of a1;
end;

:: RINGCAT1:def 5
theorem
for b1 being RingMorphismStr holds
   fun b1 = the Fun of b1;

:: RINGCAT1:funcreg 1
registration
  let a1 be non empty doubleLoopStr;
  cluster id a1 -> Function-like quasi_total linear;
end;

:: RINGCAT1:attrnot 3 => RINGCAT1:attr 3
definition
  let a1 be RingMorphismStr;
  attr a1 is RingMorphism-like means
    fun a1 is linear(the Dom of a1, the Cod of a1);
end;

:: RINGCAT1:dfs 5
definiens
  let a1 be RingMorphismStr;
To prove
     a1 is RingMorphism-like
it is sufficient to prove
  thus fun a1 is linear(the Dom of a1, the Cod of a1);

:: RINGCAT1:def 6
theorem
for b1 being RingMorphismStr holds
      b1 is RingMorphism-like
   iff
      fun b1 is linear(the Dom of b1, the Cod of b1);

:: RINGCAT1:exreg 2
registration
  cluster strict RingMorphism-like RingMorphismStr;
end;

:: RINGCAT1:modenot 1
definition
  mode RingMorphism is RingMorphism-like RingMorphismStr;
end;

:: RINGCAT1:funcnot 4 => RINGCAT1:func 4
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  func ID A1 -> RingMorphism-like RingMorphismStr equals
    RingMorphismStr(#a1,a1,id a1#);
end;

:: RINGCAT1:def 7
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr holds
   ID b1 = RingMorphismStr(#b1,b1,id b1#);

:: RINGCAT1:funcreg 2
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  cluster ID a1 -> strict RingMorphism-like;
end;

:: RINGCAT1:prednot 1 => RINGCAT1:pred 1
definition
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  pred A1 <= A2 means
    ex b1 being RingMorphism-like RingMorphismStr st
       dom b1 = a1 & cod b1 = a2;
  reflexivity;
::  for a1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr holds
::     a1 <= a1;
end;

:: RINGCAT1:dfs 7
definiens
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
To prove
     a1 <= a2
it is sufficient to prove
  thus ex b1 being RingMorphism-like RingMorphismStr st
       dom b1 = a1 & cod b1 = a2;

:: RINGCAT1:def 8
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr holds
   b1 <= b2
iff
   ex b3 being RingMorphism-like RingMorphismStr st
      dom b3 = b1 & cod b3 = b2;

:: RINGCAT1:modenot 2 => RINGCAT1:mode 1
definition
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  assume a1 <= a2;
  mode Morphism of A1,A2 -> strict RingMorphism-like RingMorphismStr means
    dom it = a1 & cod it = a2;
end;

:: RINGCAT1:dfs 8
definiens
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a3 be strict RingMorphism-like RingMorphismStr;
To prove
     a3 is Morphism of a1,a2
it is sufficient to prove
thus a1 <= a2;
  thus dom a3 = a1 & cod a3 = a2;

:: RINGCAT1:def 9
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
   st b1 <= b2
for b3 being strict RingMorphism-like RingMorphismStr holds
      b3 is Morphism of b1,b2
   iff
      dom b3 = b1 & cod b3 = b2;

:: RINGCAT1:exreg 3
registration
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  cluster strict RingMorphism-like Morphism of a1,a2;
end;

:: RINGCAT1:funcnot 5 => RINGCAT1:func 5
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  redefine func ID a1 -> strict Morphism of a1,a1;
end;

:: RINGCAT1:th 5
theorem
for b1, b2 being RingMorphism-like RingMorphismStr
      st dom b1 = cod b2
   holds ex b3, b4, b5 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr st
      b3 <= b4 &
       b4 <= b5 &
       RingMorphismStr(#the Dom of b1,the Cod of b1,the Fun of b1#) is Morphism of b4,b5 &
       RingMorphismStr(#the Dom of b2,the Cod of b2,the Fun of b2#) is Morphism of b3,b4;

:: RINGCAT1:th 6
theorem
for b1 being strict RingMorphism-like RingMorphismStr holds
   b1 is Morphism of dom b1,cod b1 & dom b1 <= cod b1;

:: RINGCAT1:th 7
theorem
for b1 being strict RingMorphism-like RingMorphismStr holds
   ex b2, b3 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr st
      ex b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3 st
         b1 is Morphism of b2,b3 & b1 = RingMorphismStr(#b2,b3,b4#) & b4 is linear(b2, b3);

:: RINGCAT1:funcnot 6 => RINGCAT1:func 6
definition
  let a1, a2 be RingMorphism-like RingMorphismStr;
  assume dom a1 = cod a2;
  func A1 * A2 -> strict RingMorphism-like RingMorphismStr means
    for b1, b2, b3 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
    for b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3
    for b5 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
          st RingMorphismStr(#the Dom of a1,the Cod of a1,the Fun of a1#) = RingMorphismStr(#b2,b3,b4#) &
             RingMorphismStr(#the Dom of a2,the Cod of a2,the Fun of a2#) = RingMorphismStr(#b1,b2,b5#)
       holds it = RingMorphismStr(#b1,b3,b4 * b5#);
end;

:: RINGCAT1:def 10
theorem
for b1, b2 being RingMorphism-like RingMorphismStr
   st dom b1 = cod b2
for b3 being strict RingMorphism-like RingMorphismStr holds
      b3 = b1 * b2
   iff
      for b4, b5, b6 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
      for b7 being Function-like quasi_total Relation of the carrier of b5,the carrier of b6
      for b8 being Function-like quasi_total Relation of the carrier of b4,the carrier of b5
            st RingMorphismStr(#the Dom of b1,the Cod of b1,the Fun of b1#) = RingMorphismStr(#b5,b6,b7#) &
               RingMorphismStr(#the Dom of b2,the Cod of b2,the Fun of b2#) = RingMorphismStr(#b4,b5,b8#)
         holds b3 = RingMorphismStr(#b4,b6,b7 * b8#);

:: RINGCAT1:th 8
theorem
for b1, b2, b3 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
      st b1 <= b2 & b2 <= b3
   holds b1 <= b3;

:: RINGCAT1:th 9
theorem
for b1, b2, b3 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b4 being Morphism of b1,b2
for b5 being Morphism of b3,b1
      st b3 <= b1 & b1 <= b2
   holds b4 * b5 is Morphism of b3,b2;

:: RINGCAT1:funcnot 7 => RINGCAT1:func 7
definition
  let a1, a2, a3 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a4 be Morphism of a2,a3;
  let a5 be Morphism of a1,a2;
  assume a1 <= a2 & a2 <= a3;
  func A4 *' A5 -> strict Morphism of a1,a3 equals
    a4 * a5;
end;

:: RINGCAT1:def 11
theorem
for b1, b2, b3 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b4 being Morphism of b2,b3
for b5 being Morphism of b1,b2
      st b1 <= b2 & b2 <= b3
   holds b4 *' b5 = b4 * b5;

:: RINGCAT1:th 10
theorem
for b1, b2 being strict RingMorphism-like RingMorphismStr
      st dom b2 = cod b1
   holds ex b3, b4, b5 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr st
      ex b6 being Function-like quasi_total Relation of the carrier of b3,the carrier of b4 st
         ex b7 being Function-like quasi_total Relation of the carrier of b4,the carrier of b5 st
            b1 = RingMorphismStr(#b3,b4,b6#) & b2 = RingMorphismStr(#b4,b5,b7#) & b2 * b1 = RingMorphismStr(#b3,b5,b7 * b6#);

:: RINGCAT1:th 11
theorem
for b1, b2 being strict RingMorphism-like RingMorphismStr
      st dom b2 = cod b1
   holds dom (b2 * b1) = dom b1 & cod (b2 * b1) = cod b2;

:: RINGCAT1:th 12
theorem
for b1, b2, b3, b4 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b5 being Morphism of b1,b2
for b6 being Morphism of b2,b3
for b7 being Morphism of b3,b4
      st b1 <= b2 & b2 <= b3 & b3 <= b4
   holds b7 * (b6 * b5) = (b7 * b6) * b5;

:: RINGCAT1:th 13
theorem
for b1, b2, b3 being strict RingMorphism-like RingMorphismStr
      st dom b3 = cod b2 & dom b2 = cod b1
   holds b3 * (b2 * b1) = (b3 * b2) * b1;

:: RINGCAT1:th 14
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr holds
   dom ID b1 = b1 &
    cod ID b1 = b1 &
    (for b2 being strict RingMorphism-like RingMorphismStr
          st cod b2 = b1
       holds (ID b1) * b2 = b2) &
    (for b2 being strict RingMorphism-like RingMorphismStr
          st dom b2 = b1
       holds b2 * ID b1 = b2);

:: RINGCAT1:attrnot 4 => RINGCAT1:attr 4
definition
  let a1 be set;
  attr a1 is Ring_DOMAIN-like means
    for b1 being Element of a1 holds
       b1 is non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
end;

:: RINGCAT1:dfs 11
definiens
  let a1 be set;
To prove
     a1 is Ring_DOMAIN-like
it is sufficient to prove
  thus for b1 being Element of a1 holds
       b1 is non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;

:: RINGCAT1:def 12
theorem
for b1 being set holds
      b1 is Ring_DOMAIN-like
   iff
      for b2 being Element of b1 holds
         b2 is non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;

:: RINGCAT1:exreg 4
registration
  cluster non empty Ring_DOMAIN-like set;
end;

:: RINGCAT1:modenot 3
definition
  mode Ring_DOMAIN is non empty Ring_DOMAIN-like set;
end;

:: RINGCAT1:modenot 4 => RINGCAT1:mode 2
definition
  let a1 be non empty Ring_DOMAIN-like set;
  redefine mode Element of a1 -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
end;

:: RINGCAT1:exreg 5
registration
  let a1 be non empty Ring_DOMAIN-like set;
  cluster non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive Element of a1;
end;

:: RINGCAT1:attrnot 5 => RINGCAT1:attr 5
definition
  let a1 be set;
  attr a1 is RingMorphism_DOMAIN-like means
    for b1 being set
          st b1 in a1
       holds b1 is strict RingMorphism-like RingMorphismStr;
end;

:: RINGCAT1:dfs 12
definiens
  let a1 be set;
To prove
     a1 is RingMorphism_DOMAIN-like
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is strict RingMorphism-like RingMorphismStr;

:: RINGCAT1:def 13
theorem
for b1 being set holds
      b1 is RingMorphism_DOMAIN-like
   iff
      for b2 being set
            st b2 in b1
         holds b2 is strict RingMorphism-like RingMorphismStr;

:: RINGCAT1:exreg 6
registration
  cluster non empty RingMorphism_DOMAIN-like set;
end;

:: RINGCAT1:modenot 5
definition
  mode RingMorphism_DOMAIN is non empty RingMorphism_DOMAIN-like set;
end;

:: RINGCAT1:modenot 6 => RINGCAT1:mode 3
definition
  let a1 be non empty RingMorphism_DOMAIN-like set;
  redefine mode Element of a1 -> RingMorphism-like RingMorphismStr;
end;

:: RINGCAT1:exreg 7
registration
  let a1 be non empty RingMorphism_DOMAIN-like set;
  cluster strict RingMorphism-like Element of a1;
end;

:: RINGCAT1:th 17
theorem
for b1 being strict RingMorphism-like RingMorphismStr holds
   {b1} is non empty RingMorphism_DOMAIN-like set;

:: RINGCAT1:modenot 7 => RINGCAT1:mode 4
definition
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  mode RingMorphism_DOMAIN of A1,A2 -> non empty RingMorphism_DOMAIN-like set means
    for b1 being Element of it holds
       b1 is Morphism of a1,a2;
end;

:: RINGCAT1:dfs 13
definiens
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a3 be non empty RingMorphism_DOMAIN-like set;
To prove
     a3 is RingMorphism_DOMAIN of a1,a2
it is sufficient to prove
  thus for b1 being Element of a3 holds
       b1 is Morphism of a1,a2;

:: RINGCAT1:def 14
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b3 being non empty RingMorphism_DOMAIN-like set holds
      b3 is RingMorphism_DOMAIN of b1,b2
   iff
      for b4 being Element of b3 holds
         b4 is Morphism of b1,b2;

:: RINGCAT1:th 18
theorem
for b1 being non empty set
for b2, b3 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr holds
   b1 is RingMorphism_DOMAIN of b2,b3
iff
   for b4 being Element of b1 holds
      b4 is Morphism of b2,b3;

:: RINGCAT1:th 19
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b3 being Morphism of b1,b2 holds
   {b3} is RingMorphism_DOMAIN of b1,b2;

:: RINGCAT1:funcnot 8 => RINGCAT1:func 8
definition
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  assume a1 <= a2;
  func Morphs(A1,A2) -> RingMorphism_DOMAIN of a1,a2 means
    for b1 being set holds
          b1 in it
       iff
          b1 is Morphism of a1,a2;
end;

:: RINGCAT1:def 15
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
   st b1 <= b2
for b3 being RingMorphism_DOMAIN of b1,b2 holds
      b3 = Morphs(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is Morphism of b1,b2;

:: RINGCAT1:modenot 8 => RINGCAT1:mode 5
definition
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a3 be RingMorphism_DOMAIN of a1,a2;
  redefine mode Element of a3 -> Morphism of a1,a2;
end;

:: RINGCAT1:exreg 8
registration
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a3 be RingMorphism_DOMAIN of a1,a2;
  cluster strict RingMorphism-like Element of a3;
end;

:: RINGCAT1:prednot 2 => RINGCAT1:pred 2
definition
  let a1, a2 be set;
  pred GO A1,A2 means
    ex b1, b2, b3, b4, b5, b6 being set st
       a1 = [[b1,b2,b3,b4],b5,b6] &
        (ex b7 being non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr st
           a2 = b7 & b1 = the carrier of b7 & b2 = the addF of b7 & b3 = comp b7 & b4 = 0. b7 & b5 = the multF of b7 & b6 = 1. b7);
end;

:: RINGCAT1:dfs 15
definiens
  let a1, a2 be set;
To prove
     GO a1,a2
it is sufficient to prove
  thus ex b1, b2, b3, b4, b5, b6 being set st
       a1 = [[b1,b2,b3,b4],b5,b6] &
        (ex b7 being non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr st
           a2 = b7 & b1 = the carrier of b7 & b2 = the addF of b7 & b3 = comp b7 & b4 = 0. b7 & b5 = the multF of b7 & b6 = 1. b7);

:: RINGCAT1:def 16
theorem
for b1, b2 being set holds
   GO b1,b2
iff
   ex b3, b4, b5, b6, b7, b8 being set st
      b1 = [[b3,b4,b5,b6],b7,b8] &
       (ex b9 being non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr st
          b2 = b9 & b3 = the carrier of b9 & b4 = the addF of b9 & b5 = comp b9 & b6 = 0. b9 & b7 = the multF of b9 & b8 = 1. b9);

:: RINGCAT1:th 20
theorem
for b1, b2, b3 being set
      st GO b1,b2 & GO b1,b3
   holds b2 = b3;

:: RINGCAT1:th 21
theorem
for b1 being non empty universal set holds
   ex b2 being set st
      b2 in b1 & GO b2,Z3;

:: RINGCAT1:funcnot 9 => RINGCAT1:func 9
definition
  let a1 be non empty universal set;
  func RingObjects A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being set st
             b2 in a1 & GO b2,b1;
end;

:: RINGCAT1:def 17
theorem
for b1 being non empty universal set
for b2 being set holds
      b2 = RingObjects b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being set st
               b4 in b1 & GO b4,b3;

:: RINGCAT1:th 22
theorem
for b1 being non empty universal set holds
   Z3 in RingObjects b1;

:: RINGCAT1:funcreg 3
registration
  let a1 be non empty universal set;
  cluster RingObjects a1 -> non empty;
end;

:: RINGCAT1:th 23
theorem
for b1 being non empty universal set
for b2 being Element of RingObjects b1 holds
   b2 is non empty right_complementable strict Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;

:: RINGCAT1:funcreg 4
registration
  let a1 be non empty universal set;
  cluster RingObjects a1 -> Ring_DOMAIN-like;
end;

:: RINGCAT1:funcnot 10 => RINGCAT1:func 10
definition
  let a1 be non empty Ring_DOMAIN-like set;
  func Morphs A1 -> non empty RingMorphism_DOMAIN-like set means
    for b1 being set holds
          b1 in it
       iff
          ex b2, b3 being Element of a1 st
             b2 <= b3 & b1 is Morphism of b2,b3;
end;

:: RINGCAT1:def 18
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2 being non empty RingMorphism_DOMAIN-like set holds
      b2 = Morphs b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4, b5 being Element of b1 st
               b4 <= b5 & b3 is Morphism of b4,b5;

:: RINGCAT1:funcnot 11 => RINGCAT1:func 11
definition
  let a1 be non empty Ring_DOMAIN-like set;
  let a2 be Element of Morphs a1;
  redefine func dom a2 -> Element of a1;
end;

:: RINGCAT1:funcnot 12 => RINGCAT1:func 12
definition
  let a1 be non empty Ring_DOMAIN-like set;
  let a2 be Element of Morphs a1;
  redefine func cod a2 -> Element of a1;
end;

:: RINGCAT1:funcnot 13 => RINGCAT1:func 13
definition
  let a1 be non empty Ring_DOMAIN-like set;
  let a2 be Element of a1;
  func ID A2 -> strict Element of Morphs a1 equals
    ID a2;
end;

:: RINGCAT1:def 19
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2 being Element of b1 holds
   ID b2 = ID b2;

:: RINGCAT1:funcnot 14 => RINGCAT1:func 14
definition
  let a1 be non empty Ring_DOMAIN-like set;
  func dom A1 -> Function-like quasi_total Relation of Morphs a1,a1 means
    for b1 being Element of Morphs a1 holds
       it . b1 = dom b1;
end;

:: RINGCAT1:def 20
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2 being Function-like quasi_total Relation of Morphs b1,b1 holds
      b2 = dom b1
   iff
      for b3 being Element of Morphs b1 holds
         b2 . b3 = dom b3;

:: RINGCAT1:funcnot 15 => RINGCAT1:func 15
definition
  let a1 be non empty Ring_DOMAIN-like set;
  func cod A1 -> Function-like quasi_total Relation of Morphs a1,a1 means
    for b1 being Element of Morphs a1 holds
       it . b1 = cod b1;
end;

:: RINGCAT1:def 21
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2 being Function-like quasi_total Relation of Morphs b1,b1 holds
      b2 = cod b1
   iff
      for b3 being Element of Morphs b1 holds
         b2 . b3 = cod b3;

:: RINGCAT1:funcnot 16 => RINGCAT1:func 16
definition
  let a1 be non empty Ring_DOMAIN-like set;
  func ID A1 -> Function-like quasi_total Relation of a1,Morphs a1 means
    for b1 being Element of a1 holds
       it . b1 = ID b1;
end;

:: RINGCAT1:def 22
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2 being Function-like quasi_total Relation of b1,Morphs b1 holds
      b2 = ID b1
   iff
      for b3 being Element of b1 holds
         b2 . b3 = ID b3;

:: RINGCAT1:th 24
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2, b3 being Element of Morphs b1
      st dom b2 = cod b3
   holds ex b4, b5, b6 being Element of b1 st
      b4 <= b5 & b5 <= b6 & b2 is Morphism of b5,b6 & b3 is Morphism of b4,b5;

:: RINGCAT1:th 25
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2, b3 being Element of Morphs b1
      st dom b2 = cod b3
   holds b2 * b3 in Morphs b1;

:: RINGCAT1:funcnot 17 => RINGCAT1:func 17
definition
  let a1 be non empty Ring_DOMAIN-like set;
  func comp A1 -> Function-like Relation of [:Morphs a1,Morphs a1:],Morphs a1 means
    (for b1, b2 being Element of Morphs a1 holds
        [b1,b2] in dom it
     iff
        dom b1 = cod b2) &
     (for b1, b2 being Element of Morphs a1
           st [b1,b2] in dom it
        holds it .(b1,b2) = b1 * b2);
end;

:: RINGCAT1:def 23
theorem
for b1 being non empty Ring_DOMAIN-like set
for b2 being Function-like Relation of [:Morphs b1,Morphs b1:],Morphs b1 holds
      b2 = comp b1
   iff
      (for b3, b4 being Element of Morphs b1 holds
          [b3,b4] in dom b2
       iff
          dom b3 = cod b4) &
       (for b3, b4 being Element of Morphs b1
             st [b3,b4] in dom b2
          holds b2 .(b3,b4) = b3 * b4);

:: RINGCAT1:funcnot 18 => RINGCAT1:func 18
definition
  let a1 be non empty universal set;
  func RingCat A1 -> CatStr equals
    CatStr(#RingObjects a1,Morphs RingObjects a1,dom RingObjects a1,cod RingObjects a1,comp RingObjects a1,ID RingObjects a1#);
end;

:: RINGCAT1:def 24
theorem
for b1 being non empty universal set holds
   RingCat b1 = CatStr(#RingObjects b1,Morphs RingObjects b1,dom RingObjects b1,cod RingObjects b1,comp RingObjects b1,ID RingObjects b1#);

:: RINGCAT1:funcreg 5
registration
  let a1 be non empty universal set;
  cluster RingCat a1 -> strict non void;
end;

:: RINGCAT1:th 26
theorem
for b1 being non empty universal set
for b2, b3 being Element of the Edges of RingCat b1 holds
   [b3,b2] in dom the Comp of RingCat b1
iff
   dom b3 = cod b2;

:: RINGCAT1:th 27
theorem
for b1 being non empty universal set
for b2 being Element of the Edges of RingCat b1
for b3 being Element of Morphs RingObjects b1
for b4 being Element of the Vertices of RingCat b1
for b5 being Element of RingObjects b1 holds
   b2 is strict Element of Morphs RingObjects b1 & b3 is Element of the Edges of RingCat b1 & b4 is strict Element of RingObjects b1 & b5 is Element of the Vertices of RingCat b1;

:: RINGCAT1:th 28
theorem
for b1 being non empty universal set
for b2 being Element of the Vertices of RingCat b1
for b3 being Element of RingObjects b1
      st b2 = b3
   holds id b2 = ID b3;

:: RINGCAT1:th 29
theorem
for b1 being non empty universal set
for b2 being Element of the Edges of RingCat b1
for b3 being Element of Morphs RingObjects b1
      st b2 = b3
   holds dom b2 = dom b3 & cod b2 = cod b3;

:: RINGCAT1:th 30
theorem
for b1 being non empty universal set
for b2, b3 being Element of the Edges of RingCat b1
for b4, b5 being Element of Morphs RingObjects b1
      st b2 = b4 & b3 = b5
   holds (dom b3 = cod b2 implies dom b5 = cod b4) &
    (dom b5 = cod b4 implies dom b3 = cod b2) &
    (dom b3 = cod b2 implies [b5,b4] in dom comp RingObjects b1) &
    ([b5,b4] in dom comp RingObjects b1 implies dom b3 = cod b2) &
    (dom b3 = cod b2 implies b3 * b2 = b5 * b4) &
    (dom b2 = dom b3 implies dom b4 = dom b5) &
    (dom b4 = dom b5 implies dom b2 = dom b3) &
    (cod b2 = cod b3 implies cod b4 = cod b5) &
    (cod b4 = cod b5 implies cod b2 = cod b3);

:: RINGCAT1:funcreg 6
registration
  let a1 be non empty universal set;
  cluster RingCat a1 -> Category-like;
end;