Article RING_1, MML version 4.99.1005

:: RING_1:funcreg 1
registration
  let a1 be non empty 1-sorted;
  cluster [#] a1 -> non proper;
end;

:: RING_1:th 1
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
(b2 - b3) + b3 = b2;

:: RING_1:th 2
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
b3 = b2 - (b2 - b3);

:: RING_1:th 3
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 - b3) - (b4 - b3) = b2 - b4;

:: RING_1:attrnot 1 => RING_1:attr 1
definition
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
  attr a2 is quasi-prime means
    for b1, b2 being Element of the carrier of a1
          st b1 * b2 in a2 & not b1 in a2
       holds b2 in a2;
end;

:: RING_1:dfs 1
definiens
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is quasi-prime
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 * b2 in a2 & not b1 in a2
       holds b2 in a2;

:: RING_1:def 1
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1 holds
      b2 is quasi-prime(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 * b4 in b2 & not b3 in b2
         holds b4 in b2;

:: RING_1:attrnot 2 => RING_1:attr 2
definition
  let a1 be non empty multLoopStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is prime means
    a2 is proper(a1) & a2 is quasi-prime(a1);
end;

:: RING_1:dfs 2
definiens
  let a1 be non empty multLoopStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is prime
it is sufficient to prove
  thus a2 is proper(a1) & a2 is quasi-prime(a1);

:: RING_1:def 2
theorem
for b1 being non empty multLoopStr
for b2 being Element of bool the carrier of b1 holds
      b2 is prime(b1)
   iff
      b2 is proper(b1) & b2 is quasi-prime(b1);

:: RING_1:attrnot 3 => RING_1:attr 3
definition
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is quasi-maximal means
    for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1
          st a2 c= b1 & b1 <> a2
       holds b1 is not proper(a1);
end;

:: RING_1:dfs 3
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is quasi-maximal
it is sufficient to prove
  thus for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1
          st a2 c= b1 & b1 <> a2
       holds b1 is not proper(a1);

:: RING_1:def 3
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1 holds
      b2 is quasi-maximal(b1)
   iff
      for b3 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
            st b2 c= b3 & b3 <> b2
         holds b3 is not proper(b1);

:: RING_1:attrnot 4 => RING_1:attr 4
definition
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is maximal means
    a2 is proper(a1) & a2 is quasi-maximal(a1);
end;

:: RING_1:dfs 4
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is maximal
it is sufficient to prove
  thus a2 is proper(a1) & a2 is quasi-maximal(a1);

:: RING_1:def 4
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1 holds
      b2 is maximal(b1)
   iff
      b2 is proper(b1) & b2 is quasi-maximal(b1);

:: RING_1:condreg 1
registration
  let a1 be non empty multLoopStr;
  cluster prime -> proper quasi-prime (Element of bool the carrier of a1);
end;

:: RING_1:condreg 2
registration
  let a1 be non empty multLoopStr;
  cluster proper quasi-prime -> prime (Element of bool the carrier of a1);
end;

:: RING_1:condreg 3
registration
  let a1 be non empty doubleLoopStr;
  cluster maximal -> proper quasi-maximal (Element of bool the carrier of a1);
end;

:: RING_1:condreg 4
registration
  let a1 be non empty doubleLoopStr;
  cluster proper quasi-maximal -> maximal (Element of bool the carrier of a1);
end;

:: RING_1:funcreg 2
registration
  let a1 be non empty addLoopStr;
  cluster [#] a1 -> add-closed;
end;

:: RING_1:funcreg 3
registration
  let a1 be non empty multMagma;
  cluster [#] a1 -> left-ideal right-ideal;
end;

:: RING_1:th 4
theorem
for b1 being non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed domRing-like doubleLoopStr holds
   {0. b1} is prime(b1);

:: RING_1:funcnot 1 => RING_1:func 1
definition
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  func EqRel(A1,A2) -> Relation of the carrier of a1,the carrier of a1 means
    for b1, b2 being Element of the carrier of a1 holds
       [b1,b2] in it
    iff
       b1 - b2 in a2;
end;

:: RING_1:def 5
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being Relation of the carrier of b1,the carrier of b1 holds
      b3 = EqRel(b1,b2)
   iff
      for b4, b5 being Element of the carrier of b1 holds
         [b4,b5] in b3
      iff
         b4 - b5 in b2;

:: RING_1:funcreg 4
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  cluster EqRel(a1,a2) -> non empty symmetric transitive total;
end;

:: RING_1:th 5
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1 holds
   b3 in Class(EqRel(b1,b2),b4)
iff
   b3 - b4 in b2;

:: RING_1:th 6
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1 holds
   Class(EqRel(b1,b2),b3) = Class(EqRel(b1,b2),b4)
iff
   b3 - b4 in b2;

:: RING_1:th 7
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1 holds
   Class(EqRel(b1,[#] b1),b2) = the carrier of b1;

:: RING_1:th 8
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   Class EqRel(b1,[#] b1) = {the carrier of b1};

:: RING_1:th 9
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1 holds
   Class(EqRel(b1,{0. b1}),b2) = {b2};

:: RING_1:th 10
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   Class EqRel(b1,{0. b1}) = proj2 singleton the carrier of b1;

:: RING_1:funcnot 2 => RING_1:func 2
definition
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  func QuotientRing(A1,A2) -> strict doubleLoopStr means
    the carrier of it = Class EqRel(a1,a2) &
     1. it = Class(EqRel(a1,a2),1. a1) &
     0. it = Class(EqRel(a1,a2),0. a1) &
     (for b1, b2 being Element of the carrier of it holds
     ex b3, b4 being Element of the carrier of a1 st
        b1 = Class(EqRel(a1,a2),b3) &
         b2 = Class(EqRel(a1,a2),b4) &
         (the addF of it) .(b1,b2) = Class(EqRel(a1,a2),b3 + b4)) &
     (for b1, b2 being Element of the carrier of it holds
     ex b3, b4 being Element of the carrier of a1 st
        b1 = Class(EqRel(a1,a2),b3) &
         b2 = Class(EqRel(a1,a2),b4) &
         (the multF of it) .(b1,b2) = Class(EqRel(a1,a2),b3 * b4));
end;

:: RING_1:def 6
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being strict doubleLoopStr holds
      b3 = QuotientRing(b1,b2)
   iff
      the carrier of b3 = Class EqRel(b1,b2) &
       1. b3 = Class(EqRel(b1,b2),1. b1) &
       0. b3 = Class(EqRel(b1,b2),0. b1) &
       (for b4, b5 being Element of the carrier of b3 holds
       ex b6, b7 being Element of the carrier of b1 st
          b4 = Class(EqRel(b1,b2),b6) &
           b5 = Class(EqRel(b1,b2),b7) &
           (the addF of b3) .(b4,b5) = Class(EqRel(b1,b2),b6 + b7)) &
       (for b4, b5 being Element of the carrier of b3 holds
       ex b6, b7 being Element of the carrier of b1 st
          b4 = Class(EqRel(b1,b2),b6) &
           b5 = Class(EqRel(b1,b2),b7) &
           (the multF of b3) .(b4,b5) = Class(EqRel(b1,b2),b6 * b7));

:: RING_1:funcnot 3 => RING_1:func 2
notation
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  synonym a1 / a2 for QuotientRing(a1,a2);
end;

:: RING_1:funcreg 5
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  cluster QuotientRing(a1,a2) -> non empty strict;
end;

:: RING_1:th 11
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being Element of the carrier of QuotientRing(b1,b2) holds
   ex b4 being Element of the carrier of b1 st
      b3 = Class(EqRel(b1,b2),b4);

:: RING_1:th 12
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
   Class(EqRel(b1,b2),b3) is Element of the carrier of QuotientRing(b1,b2);

:: RING_1:th 13
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of QuotientRing(b1,b2)
      st b5 = Class(EqRel(b1,b2),b3) & b6 = Class(EqRel(b1,b2),b4)
   holds b5 + b6 = Class(EqRel(b1,b2),b3 + b4);

:: RING_1:th 14
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of QuotientRing(b1,b2)
      st b5 = Class(EqRel(b1,b2),b3) & b6 = Class(EqRel(b1,b2),b4)
   holds b5 * b6 = Class(EqRel(b1,b2),b3 * b4);

:: RING_1:th 15
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
   Class(EqRel(b1,b2),1. b1) = 1. QuotientRing(b1,b2);

:: RING_1:funcreg 6
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  cluster QuotientRing(a1,a2) -> right_complementable strict associative well-unital distributive Abelian add-associative right_zeroed;
end;

:: RING_1:funcreg 7
registration
  let a1 be non empty right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  cluster QuotientRing(a1,a2) -> strict commutative;
end;

:: RING_1:th 16
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is proper(b1)
   iff
      QuotientRing(b1,b2) is not degenerated;

:: RING_1:th 17
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is quasi-prime(b1)
   iff
      QuotientRing(b1,b2) is domRing-like;

:: RING_1:th 18
theorem
for b1 being non empty right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is prime(b1)
   iff
      QuotientRing(b1,b2) is non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed domRing-like doubleLoopStr;

:: RING_1:th 19
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
      st b1 is commutative & b2 is quasi-maximal(b1)
   holds QuotientRing(b1,b2) is almost_left_invertible;

:: RING_1:th 20
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
      st QuotientRing(b1,b2) is almost_left_invertible
   holds b2 is quasi-maximal(b1);

:: RING_1:th 21
theorem
for b1 being non empty right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is maximal(b1)
   iff
      QuotientRing(b1,b2) is non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;

:: RING_1:condreg 5
registration
  let a1 be non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty add-closed left-ideal right-ideal maximal -> prime (Element of bool the carrier of a1);
end;

:: RING_1:exreg 1
registration
  let a1 be non empty non degenerated right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty add-closed left-ideal right-ideal maximal Element of bool the carrier of a1;
end;

:: RING_1:exreg 2
registration
  let a1 be non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty add-closed left-ideal right-ideal maximal Element of bool the carrier of a1;
end;

:: RING_1:funcreg 8
registration
  let a1 be non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal quasi-prime Element of bool the carrier of a1;
  cluster QuotientRing(a1,a2) -> strict domRing-like;
end;

:: RING_1:funcreg 9
registration
  let a1 be non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal quasi-maximal Element of bool the carrier of a1;
  cluster QuotientRing(a1,a2) -> almost_left_invertible strict;
end;