Article IDEAL_1, MML version 4.99.1005

:: IDEAL_1:exreg 1
registration
  cluster non empty add-associative right_zeroed left_zeroed addLoopStr;
end;

:: IDEAL_1:exreg 2
registration
  cluster non empty non trivial add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr;
end;

:: IDEAL_1:th 1
theorem
for b1 being non empty add-associative right_zeroed left_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
Sum <*b2,b3*> = b2 + b3;

:: IDEAL_1:attrnot 1 => IDEAL_1:attr 1
definition
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is add-closed means
    for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds b1 + b2 in a2;
end;

:: IDEAL_1:dfs 1
definiens
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is add-closed
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds b1 + b2 in a2;

:: IDEAL_1:def 1
theorem
for b1 being non empty addLoopStr
for b2 being Element of bool the carrier of b1 holds
      b2 is add-closed(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds b3 + b4 in b2;

:: IDEAL_1:attrnot 2 => IDEAL_1:attr 2
definition
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
  attr a2 is left-ideal means
    for b1, b2 being Element of the carrier of a1
          st b2 in a2
       holds b1 * b2 in a2;
end;

:: IDEAL_1:dfs 2
definiens
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is left-ideal
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b2 in a2
       holds b1 * b2 in a2;

:: IDEAL_1:def 2
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1 holds
      b2 is left-ideal(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b4 in b2
         holds b3 * b4 in b2;

:: IDEAL_1:attrnot 3 => IDEAL_1:attr 3
definition
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
  attr a2 is right-ideal means
    for b1, b2 being Element of the carrier of a1
          st b2 in a2
       holds b2 * b1 in a2;
end;

:: IDEAL_1:dfs 3
definiens
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is right-ideal
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b2 in a2
       holds b2 * b1 in a2;

:: IDEAL_1:def 3
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1 holds
      b2 is right-ideal(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b4 in b2
         holds b4 * b3 in b2;

:: IDEAL_1:exreg 3
registration
  let a1 be non empty addLoopStr;
  cluster non empty add-closed Element of bool the carrier of a1;
end;

:: IDEAL_1:exreg 4
registration
  let a1 be non empty multMagma;
  cluster non empty left-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:exreg 5
registration
  let a1 be non empty multMagma;
  cluster non empty right-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:exreg 6
registration
  let a1 be non empty doubleLoopStr;
  cluster non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:exreg 7
registration
  let a1 be non empty doubleLoopStr;
  cluster non empty add-closed right-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:exreg 8
registration
  let a1 be non empty doubleLoopStr;
  cluster non empty add-closed left-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:condreg 1
registration
  let a1 be non empty commutative multMagma;
  cluster non empty left-ideal -> right-ideal (Element of bool the carrier of a1);
end;

:: IDEAL_1:condreg 2
registration
  let a1 be non empty commutative multMagma;
  cluster non empty right-ideal -> left-ideal (Element of bool the carrier of a1);
end;

:: IDEAL_1:modenot 1
definition
  let a1 be non empty doubleLoopStr;
  mode Ideal of a1 is non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:modenot 2
definition
  let a1 be non empty doubleLoopStr;
  mode RightIdeal of a1 is non empty add-closed right-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:modenot 3
definition
  let a1 be non empty doubleLoopStr;
  mode LeftIdeal of a1 is non empty add-closed left-ideal Element of bool the carrier of a1;
end;

:: IDEAL_1:th 2
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2 being non empty left-ideal Element of bool the carrier of b1 holds
   0. b1 in b2;

:: IDEAL_1:th 3
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1 holds
   0. b1 in b2;

:: IDEAL_1:th 4
theorem
for b1 being non empty right_zeroed addLoopStr holds
   {0. b1} is add-closed(b1);

:: IDEAL_1:th 5
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr holds
   {0. b1} is left-ideal(b1);

:: IDEAL_1:th 6
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr holds
   {0. b1} is right-ideal(b1);

:: IDEAL_1:funcreg 1
registration
  let a1 be non empty right_zeroed addLoopStr;
  cluster {0. a1} -> add-closed;
end;

:: IDEAL_1:funcreg 2
registration
  let a1 be non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr;
  cluster {0. a1} -> left-ideal;
end;

:: IDEAL_1:funcreg 3
registration
  let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
  cluster {0. a1} -> right-ideal;
end;

:: IDEAL_1:th 7
theorem
for b1 being non empty right_complementable add-associative right_zeroed distributive doubleLoopStr holds
   {0. b1} is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1;

:: IDEAL_1:th 8
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr holds
   {0. b1} is non empty add-closed left-ideal Element of bool the carrier of b1;

:: IDEAL_1:th 9
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive doubleLoopStr holds
   {0. b1} is non empty add-closed right-ideal Element of bool the carrier of b1;

:: IDEAL_1:th 10
theorem
for b1 being non empty doubleLoopStr holds
   the carrier of b1 is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1;

:: IDEAL_1:th 11
theorem
for b1 being non empty doubleLoopStr holds
   the carrier of b1 is non empty add-closed left-ideal Element of bool the carrier of b1;

:: IDEAL_1:th 12
theorem
for b1 being non empty doubleLoopStr holds
   the carrier of b1 is non empty add-closed right-ideal Element of bool the carrier of b1;

:: IDEAL_1:attrnot 4 => IDEAL_1:attr 4
definition
  let a1 be non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  redefine attr a2 is trivial means
    a2 = {0. a1};
end;

:: IDEAL_1:dfs 4
definiens
  let a1 be non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
To prove
     a1 is trivial
it is sufficient to prove
  thus a2 = {0. a1};

:: IDEAL_1:def 4
theorem
for b1 being non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is trivial
   iff
      b2 = {0. b1};

:: IDEAL_1:attrnot 5 => IDEAL_1:attr 5
definition
  let a1 be 1-sorted;
  let a2 be Element of bool the carrier of a1;
  attr a2 is proper means
    a2 <> the carrier of a1;
end;

:: IDEAL_1:dfs 5
definiens
  let a1 be 1-sorted;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is proper
it is sufficient to prove
  thus a2 <> the carrier of a1;

:: IDEAL_1:def 5
theorem
for b1 being 1-sorted
for b2 being Element of bool the carrier of b1 holds
      b2 is proper(b1)
   iff
      b2 <> the carrier of b1;

:: IDEAL_1:exreg 9
registration
  let a1 be non empty 1-sorted;
  cluster proper Element of bool the carrier of a1;
end;

:: IDEAL_1:exreg 10
registration
  let a1 be non empty non trivial add-cancelable right_zeroed distributive left_zeroed doubleLoopStr;
  cluster non empty add-closed left-ideal right-ideal proper Element of bool the carrier of a1;
end;

:: IDEAL_1:th 13
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive left_unital doubleLoopStr
for b2 being non empty left-ideal Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b3 in b2
   holds - b3 in b2;

:: IDEAL_1:th 14
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive right_unital doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b3 in b2
   holds - b3 in b2;

:: IDEAL_1:th 15
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive left_unital doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1
      st b3 in b2 & b4 in b2
   holds b3 - b4 in b2;

:: IDEAL_1:th 16
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive right_unital doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3, b4 being Element of the carrier of b1
      st b3 in b2 & b4 in b2
   holds b3 - b4 in b2;

:: IDEAL_1:th 17
theorem
for b1 being non empty add-cancelable add-associative right_zeroed distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being Element of b2
for b4 being Element of NAT holds
   b4 * b3 in b2;

:: IDEAL_1:th 18
theorem
for b1 being non empty add-cancelable right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1
for b3 being Element of b2
for b4 being Element of NAT
      st b4 <> 0
   holds b3 |^ b4 in b2;

:: IDEAL_1:funcnot 1 => IDEAL_1:func 1
definition
  let a1 be non empty addLoopStr;
  let a2 be non empty add-closed Element of bool the carrier of a1;
  func add|(A2,A1) -> Function-like quasi_total Relation of [:a2,a2:],a2 equals
    (the addF of a1) || a2;
end;

:: IDEAL_1:def 6
theorem
for b1 being non empty addLoopStr
for b2 being non empty add-closed Element of bool the carrier of b1 holds
   add|(b2,b1) = (the addF of b1) || b2;

:: IDEAL_1:funcnot 2 => IDEAL_1:func 2
definition
  let a1 be non empty multMagma;
  let a2 be non empty right-ideal Element of bool the carrier of a1;
  func mult|(A2,A1) -> Function-like quasi_total Relation of [:a2,a2:],a2 equals
    (the multF of a1) || a2;
end;

:: IDEAL_1:def 7
theorem
for b1 being non empty multMagma
for b2 being non empty right-ideal Element of bool the carrier of b1 holds
   mult|(b2,b1) = (the multF of b1) || b2;

:: IDEAL_1:funcnot 3 => IDEAL_1:func 3
definition
  let a1 be non empty addLoopStr;
  let a2 be non empty add-closed Element of bool the carrier of a1;
  func Gr(A2,A1) -> non empty addLoopStr equals
    addLoopStr(#a2,add|(a2,a1),In(0. a1,a2)#);
end;

:: IDEAL_1:def 8
theorem
for b1 being non empty addLoopStr
for b2 being non empty add-closed Element of bool the carrier of b1 holds
   Gr(b2,b1) = addLoopStr(#b2,add|(b2,b1),In(0. b1,b2)#);

:: IDEAL_1:funcreg 4
registration
  let a1 be non empty add-cancelable add-associative right_zeroed distributive left_zeroed doubleLoopStr;
  let a2 be non empty add-closed Element of bool the carrier of a1;
  cluster Gr(a2,a1) -> non empty add-associative;
end;

:: IDEAL_1:funcreg 5
registration
  let a1 be non empty add-cancelable add-associative right_zeroed distributive left_zeroed doubleLoopStr;
  let a2 be non empty add-closed right-ideal Element of bool the carrier of a1;
  cluster Gr(a2,a1) -> non empty right_zeroed;
end;

:: IDEAL_1:funcreg 6
registration
  let a1 be non empty Abelian doubleLoopStr;
  let a2 be non empty add-closed Element of bool the carrier of a1;
  cluster Gr(a2,a1) -> non empty Abelian;
end;

:: IDEAL_1:funcreg 7
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed right_unital distributive left_zeroed doubleLoopStr;
  let a2 be non empty add-closed right-ideal Element of bool the carrier of a1;
  cluster Gr(a2,a1) -> non empty right_complementable;
end;

:: IDEAL_1:th 19
theorem
for b1 being non empty right_unital doubleLoopStr
for b2 being non empty left-ideal Element of bool the carrier of b1 holds
      b2 is proper(b1)
   iff
      not 1. b1 in b2;

:: IDEAL_1:th 20
theorem
for b1 being non empty right_unital left_unital doubleLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1 holds
      b2 is proper(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 is unital(b1)
         holds not b3 in b2;

:: IDEAL_1:th 21
theorem
for b1 being non empty right_unital doubleLoopStr
for b2 being non empty left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is proper(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 is unital(b1)
         holds not b3 in b2;

:: IDEAL_1:th 22
theorem
for b1 being non empty non degenerated right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr holds
      b1 is non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
   iff
      for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
            st b2 <> {0. b1}
         holds b2 = the carrier of b1;

:: IDEAL_1:modenot 4 => IDEAL_1:mode 1
definition
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  mode LinearCombination of A2 -> FinSequence of the carrier of a1 means
    for b1 being set
          st b1 in dom it
       holds ex b2, b3 being Element of the carrier of a1 st
          ex b4 being Element of a2 st
             it /. b1 = (b2 * b4) * b3;
end;

:: IDEAL_1:dfs 9
definiens
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be FinSequence of the carrier of a1;
To prove
     a3 is LinearCombination of a2
it is sufficient to prove
  thus for b1 being set
          st b1 in dom a3
       holds ex b2, b3 being Element of the carrier of a1 st
          ex b4 being Element of a2 st
             a3 /. b1 = (b2 * b4) * b3;

:: IDEAL_1:def 9
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of the carrier of b1 holds
      b3 is LinearCombination of b2
   iff
      for b4 being set
            st b4 in dom b3
         holds ex b5, b6 being Element of the carrier of b1 st
            ex b7 being Element of b2 st
               b3 /. b4 = (b5 * b7) * b6;

:: IDEAL_1:modenot 5 => IDEAL_1:mode 2
definition
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  mode LeftLinearCombination of A2 -> FinSequence of the carrier of a1 means
    for b1 being set
          st b1 in dom it
       holds ex b2 being Element of the carrier of a1 st
          ex b3 being Element of a2 st
             it /. b1 = b2 * b3;
end;

:: IDEAL_1:dfs 10
definiens
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be FinSequence of the carrier of a1;
To prove
     a3 is LeftLinearCombination of a2
it is sufficient to prove
  thus for b1 being set
          st b1 in dom a3
       holds ex b2 being Element of the carrier of a1 st
          ex b3 being Element of a2 st
             a3 /. b1 = b2 * b3;

:: IDEAL_1:def 10
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of the carrier of b1 holds
      b3 is LeftLinearCombination of b2
   iff
      for b4 being set
            st b4 in dom b3
         holds ex b5 being Element of the carrier of b1 st
            ex b6 being Element of b2 st
               b3 /. b4 = b5 * b6;

:: IDEAL_1:modenot 6 => IDEAL_1:mode 3
definition
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  mode RightLinearCombination of A2 -> FinSequence of the carrier of a1 means
    for b1 being set
          st b1 in dom it
       holds ex b2 being Element of the carrier of a1 st
          ex b3 being Element of a2 st
             it /. b1 = b3 * b2;
end;

:: IDEAL_1:dfs 11
definiens
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be FinSequence of the carrier of a1;
To prove
     a3 is RightLinearCombination of a2
it is sufficient to prove
  thus for b1 being set
          st b1 in dom a3
       holds ex b2 being Element of the carrier of a1 st
          ex b3 being Element of a2 st
             a3 /. b1 = b3 * b2;

:: IDEAL_1:def 11
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being FinSequence of the carrier of b1 holds
      b3 is RightLinearCombination of b2
   iff
      for b4 being set
            st b4 in dom b3
         holds ex b5 being Element of the carrier of b1 st
            ex b6 being Element of b2 st
               b3 /. b4 = b6 * b5;

:: IDEAL_1:exreg 11
registration
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster non empty Relation-like Function-like finite FinSequence-like LinearCombination of a2;
end;

:: IDEAL_1:exreg 12
registration
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster non empty Relation-like Function-like finite FinSequence-like LeftLinearCombination of a2;
end;

:: IDEAL_1:exreg 13
registration
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster non empty Relation-like Function-like finite FinSequence-like RightLinearCombination of a2;
end;

:: IDEAL_1:funcnot 4 => IDEAL_1:func 4
definition
  let a1 be non empty multLoopStr;
  let a2, a3 be non empty Element of bool the carrier of a1;
  let a4 be LinearCombination of a2;
  let a5 be LinearCombination of a3;
  redefine func a4 ^ a5 -> LinearCombination of a2 \/ a3;
end;

:: IDEAL_1:th 23
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LinearCombination of b2 holds
   b3 * b4 is LinearCombination of b2;

:: IDEAL_1:th 24
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LinearCombination of b2 holds
   b4 * b3 is LinearCombination of b2;

:: IDEAL_1:th 25
theorem
for b1 being non empty right_unital multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2 holds
   b3 is LinearCombination of b2;

:: IDEAL_1:funcnot 5 => IDEAL_1:func 5
definition
  let a1 be non empty multLoopStr;
  let a2, a3 be non empty Element of bool the carrier of a1;
  let a4 be LeftLinearCombination of a2;
  let a5 be LeftLinearCombination of a3;
  redefine func a4 ^ a5 -> LeftLinearCombination of a2 \/ a3;
end;

:: IDEAL_1:th 26
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LeftLinearCombination of b2 holds
   b3 * b4 is LeftLinearCombination of b2;

:: IDEAL_1:th 27
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being LeftLinearCombination of b2 holds
   b4 * b3 is LinearCombination of b2;

:: IDEAL_1:th 28
theorem
for b1 being non empty left_unital multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2 holds
   b3 is LinearCombination of b2;

:: IDEAL_1:funcnot 6 => IDEAL_1:func 6
definition
  let a1 be non empty multLoopStr;
  let a2, a3 be non empty Element of bool the carrier of a1;
  let a4 be RightLinearCombination of a2;
  let a5 be RightLinearCombination of a3;
  redefine func a4 ^ a5 -> RightLinearCombination of a2 \/ a3;
end;

:: IDEAL_1:th 29
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being RightLinearCombination of b2 holds
   b4 * b3 is RightLinearCombination of b2;

:: IDEAL_1:th 30
theorem
for b1 being non empty associative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being RightLinearCombination of b2 holds
   b3 * b4 is LinearCombination of b2;

:: IDEAL_1:th 31
theorem
for b1 being non empty associative commutative multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2 holds
   b3 is LeftLinearCombination of b2 & b3 is RightLinearCombination of b2;

:: IDEAL_1:th 32
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty LinearCombination of b2 holds
   ex b4 being LinearCombination of b2 st
      ex b5 being Element of the carrier of b1 st
         b3 = b4 ^ <*b5*> & <*b5*> is LinearCombination of b2;

:: IDEAL_1:th 33
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty LeftLinearCombination of b2 holds
   ex b4 being LeftLinearCombination of b2 st
      ex b5 being Element of the carrier of b1 st
         b3 = b4 ^ <*b5*> & <*b5*> is LeftLinearCombination of b2;

:: IDEAL_1:th 34
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty RightLinearCombination of b2 holds
   ex b4 being RightLinearCombination of b2 st
      ex b5 being Element of the carrier of b1 st
         b3 = b4 ^ <*b5*> & <*b5*> is RightLinearCombination of b2;

:: IDEAL_1:prednot 1 => IDEAL_1:pred 1
definition
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be LinearCombination of a2;
  let a4 be FinSequence of [:the carrier of a1,the carrier of a1,the carrier of a1:];
  pred A4 represents A3 means
    len a4 = len a3 &
     (for b1 being set
           st b1 in dom a3
        holds a3 . b1 = ((a4 /. b1) `1 * ((a4 /. b1) `2)) * ((a4 /. b1) `3) &
         (a4 /. b1) `2 in a2);
end;

:: IDEAL_1:dfs 12
definiens
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be LinearCombination of a2;
  let a4 be FinSequence of [:the carrier of a1,the carrier of a1,the carrier of a1:];
To prove
     a4 represents a3
it is sufficient to prove
  thus len a4 = len a3 &
     (for b1 being set
           st b1 in dom a3
        holds a3 . b1 = ((a4 /. b1) `1 * ((a4 /. b1) `2)) * ((a4 /. b1) `3) &
         (a4 /. b1) `2 in a2);

:: IDEAL_1:def 12
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2
for b4 being FinSequence of [:the carrier of b1,the carrier of b1,the carrier of b1:] holds
      b4 represents b3
   iff
      len b4 = len b3 &
       (for b5 being set
             st b5 in dom b3
          holds b3 . b5 = ((b4 /. b5) `1 * ((b4 /. b5) `2)) * ((b4 /. b5) `3) &
           (b4 /. b5) `2 in b2);

:: IDEAL_1:th 35
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2 holds
   ex b4 being FinSequence of [:the carrier of b1,the carrier of b1,the carrier of b1:] st
      b4 represents b3;

:: IDEAL_1:th 36
theorem
for b1, b2 being non empty multLoopStr
for b3 being non empty Element of bool the carrier of b1
for b4 being LinearCombination of b3
for b5 being non empty Element of bool the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b7 being FinSequence of [:the carrier of b1,the carrier of b1,the carrier of b1:]
      st b6 .: b3 c= b5 & b7 represents b4
   holds ex b8 being LinearCombination of b5 st
      len b4 = len b8 &
       (for b9 being set
             st b9 in dom b8
          holds b8 . b9 = ((b6 . ((b7 /. b9) `1)) * (b6 . ((b7 /. b9) `2))) * (b6 . ((b7 /. b9) `3)));

:: IDEAL_1:prednot 2 => IDEAL_1:pred 2
definition
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be LeftLinearCombination of a2;
  let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
  pred A4 represents A3 means
    len a4 = len a3 &
     (for b1 being set
           st b1 in dom a3
        holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
         (a4 /. b1) `2 in a2);
end;

:: IDEAL_1:dfs 13
definiens
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be LeftLinearCombination of a2;
  let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
To prove
     a4 represents a3
it is sufficient to prove
  thus len a4 = len a3 &
     (for b1 being set
           st b1 in dom a3
        holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
         (a4 /. b1) `2 in a2);

:: IDEAL_1:def 13
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2
for b4 being FinSequence of [:the carrier of b1,the carrier of b1:] holds
      b4 represents b3
   iff
      len b4 = len b3 &
       (for b5 being set
             st b5 in dom b3
          holds b3 . b5 = (b4 /. b5) `1 * ((b4 /. b5) `2) &
           (b4 /. b5) `2 in b2);

:: IDEAL_1:th 37
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2 holds
   ex b4 being FinSequence of [:the carrier of b1,the carrier of b1:] st
      b4 represents b3;

:: IDEAL_1:th 38
theorem
for b1, b2 being non empty multLoopStr
for b3 being non empty Element of bool the carrier of b1
for b4 being LeftLinearCombination of b3
for b5 being non empty Element of bool the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b7 being FinSequence of [:the carrier of b1,the carrier of b1:]
      st b6 .: b3 c= b5 & b7 represents b4
   holds ex b8 being LeftLinearCombination of b5 st
      len b4 = len b8 &
       (for b9 being set
             st b9 in dom b8
          holds b8 . b9 = (b6 . ((b7 /. b9) `1)) * (b6 . ((b7 /. b9) `2)));

:: IDEAL_1:prednot 3 => IDEAL_1:pred 3
definition
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be RightLinearCombination of a2;
  let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
  pred A4 represents A3 means
    len a4 = len a3 &
     (for b1 being set
           st b1 in dom a3
        holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
         (a4 /. b1) `1 in a2);
end;

:: IDEAL_1:dfs 14
definiens
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be RightLinearCombination of a2;
  let a4 be FinSequence of [:the carrier of a1,the carrier of a1:];
To prove
     a4 represents a3
it is sufficient to prove
  thus len a4 = len a3 &
     (for b1 being set
           st b1 in dom a3
        holds a3 . b1 = (a4 /. b1) `1 * ((a4 /. b1) `2) &
         (a4 /. b1) `1 in a2);

:: IDEAL_1:def 14
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2
for b4 being FinSequence of [:the carrier of b1,the carrier of b1:] holds
      b4 represents b3
   iff
      len b4 = len b3 &
       (for b5 being set
             st b5 in dom b3
          holds b3 . b5 = (b4 /. b5) `1 * ((b4 /. b5) `2) &
           (b4 /. b5) `1 in b2);

:: IDEAL_1:th 39
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2 holds
   ex b4 being FinSequence of [:the carrier of b1,the carrier of b1:] st
      b4 represents b3;

:: IDEAL_1:th 40
theorem
for b1, b2 being non empty multLoopStr
for b3 being non empty Element of bool the carrier of b1
for b4 being RightLinearCombination of b3
for b5 being non empty Element of bool the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b7 being FinSequence of [:the carrier of b1,the carrier of b1:]
      st b6 .: b3 c= b5 & b7 represents b4
   holds ex b8 being RightLinearCombination of b5 st
      len b4 = len b8 &
       (for b9 being set
             st b9 in dom b8
          holds b8 . b9 = (b6 . ((b7 /. b9) `1)) * (b6 . ((b7 /. b9) `2)));

:: IDEAL_1:th 41
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LinearCombination of b2
for b4 being Element of NAT holds
   b3 | Seg b4 is LinearCombination of b2;

:: IDEAL_1:th 42
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being LeftLinearCombination of b2
for b4 being Element of NAT holds
   b3 | Seg b4 is LeftLinearCombination of b2;

:: IDEAL_1:th 43
theorem
for b1 being non empty multLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being RightLinearCombination of b2
for b4 being Element of NAT holds
   b3 | Seg b4 is RightLinearCombination of b2;

:: IDEAL_1:funcnot 7 => IDEAL_1:func 7
definition
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  assume a2 is not empty;
  func A2 -Ideal -> non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 means
    a2 c= it &
     (for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1
           st a2 c= b1
        holds it c= b1);
end;

:: IDEAL_1:def 15
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1
   st b2 is not empty
for b3 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b3 = b2 -Ideal
   iff
      b2 c= b3 &
       (for b4 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
             st b2 c= b4
          holds b3 c= b4);

:: IDEAL_1:funcnot 8 => IDEAL_1:func 8
definition
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  assume a2 is not empty;
  func A2 -LeftIdeal -> non empty add-closed left-ideal Element of bool the carrier of a1 means
    a2 c= it &
     (for b1 being non empty add-closed left-ideal Element of bool the carrier of a1
           st a2 c= b1
        holds it c= b1);
end;

:: IDEAL_1:def 16
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1
   st b2 is not empty
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
      b3 = b2 -LeftIdeal
   iff
      b2 c= b3 &
       (for b4 being non empty add-closed left-ideal Element of bool the carrier of b1
             st b2 c= b4
          holds b3 c= b4);

:: IDEAL_1:funcnot 9 => IDEAL_1:func 9
definition
  let a1 be non empty doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  assume a2 is not empty;
  func A2 -RightIdeal -> non empty add-closed right-ideal Element of bool the carrier of a1 means
    a2 c= it &
     (for b1 being non empty add-closed right-ideal Element of bool the carrier of a1
           st a2 c= b1
        holds it c= b1);
end;

:: IDEAL_1:def 17
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of bool the carrier of b1
   st b2 is not empty
for b3 being non empty add-closed right-ideal Element of bool the carrier of b1 holds
      b3 = b2 -RightIdeal
   iff
      b2 c= b3 &
       (for b4 being non empty add-closed right-ideal Element of bool the carrier of b1
             st b2 c= b4
          holds b3 c= b4);

:: IDEAL_1:th 44
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
   b2 -Ideal = b2;

:: IDEAL_1:th 45
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
   b2 -LeftIdeal = b2;

:: IDEAL_1:th 46
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1 holds
   b2 -RightIdeal = b2;

:: IDEAL_1:modenot 7 => IDEAL_1:mode 4
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  mode Basis of A2 -> non empty Element of bool the carrier of a1 means
    it -Ideal = a2;
end;

:: IDEAL_1:dfs 18
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  let a3 be non empty Element of bool the carrier of a1;
To prove
     a3 is Basis of a2
it is sufficient to prove
  thus a3 -Ideal = a2;

:: IDEAL_1:def 18
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being non empty Element of bool the carrier of b1 holds
      b3 is Basis of b2
   iff
      b3 -Ideal = b2;

:: IDEAL_1:th 47
theorem
for b1 being non empty right_complementable add-associative right_zeroed distributive doubleLoopStr holds
   {0. b1} -Ideal = {0. b1};

:: IDEAL_1:th 48
theorem
for b1 being non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr holds
   {0. b1} -Ideal = {0. b1};

:: IDEAL_1:th 49
theorem
for b1 being non empty right_add-cancelable right_zeroed right-distributive left_zeroed doubleLoopStr holds
   {0. b1} -LeftIdeal = {0. b1};

:: IDEAL_1:th 50
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr holds
   {0. b1} -RightIdeal = {0. b1};

:: IDEAL_1:th 51
theorem
for b1 being non empty well-unital doubleLoopStr holds
   {1. b1} -Ideal = the carrier of b1;

:: IDEAL_1:th 52
theorem
for b1 being non empty right_unital doubleLoopStr holds
   {1. b1} -LeftIdeal = the carrier of b1;

:: IDEAL_1:th 53
theorem
for b1 being non empty left_unital doubleLoopStr holds
   {1. b1} -RightIdeal = the carrier of b1;

:: IDEAL_1:th 54
theorem
for b1 being non empty doubleLoopStr holds
   ([#] b1) -Ideal = the carrier of b1;

:: IDEAL_1:th 55
theorem
for b1 being non empty doubleLoopStr holds
   ([#] b1) -LeftIdeal = the carrier of b1;

:: IDEAL_1:th 56
theorem
for b1 being non empty doubleLoopStr holds
   ([#] b1) -RightIdeal = the carrier of b1;

:: IDEAL_1:th 57
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
      st b2 c= b3
   holds b2 -Ideal c= b3 -Ideal;

:: IDEAL_1:th 58
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
      st b2 c= b3
   holds b2 -LeftIdeal c= b3 -LeftIdeal;

:: IDEAL_1:th 59
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
      st b2 c= b3
   holds b2 -RightIdeal c= b3 -RightIdeal;

:: IDEAL_1:th 60
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set holds
      b3 in b2 -Ideal
   iff
      ex b4 being LinearCombination of b2 st
         b3 = Sum b4;

:: IDEAL_1:th 61
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set holds
      b3 in b2 -LeftIdeal
   iff
      ex b4 being LeftLinearCombination of b2 st
         b3 = Sum b4;

:: IDEAL_1:th 62
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set holds
      b3 in b2 -RightIdeal
   iff
      ex b4 being RightLinearCombination of b2 st
         b3 = Sum b4;

:: IDEAL_1:th 63
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
   b2 -Ideal = b2 -LeftIdeal & b2 -Ideal = b2 -RightIdeal;

:: IDEAL_1:th 64
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2 being Element of the carrier of b1 holds
   {b2} -Ideal = {b2 * b3 where b3 is Element of the carrier of b1: TRUE};

:: IDEAL_1:th 65
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
{b2,b3} -Ideal = {(b2 * b4) + (b3 * b5) where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: TRUE};

:: IDEAL_1:th 66
theorem
for b1 being non empty doubleLoopStr
for b2 being Element of the carrier of b1 holds
   b2 in {b2} -Ideal;

:: IDEAL_1:th 67
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st b3 in b2 -Ideal
   holds {b3} -Ideal c= b2 -Ideal;

:: IDEAL_1:th 68
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 in {b2,b3} -Ideal & b3 in {b2,b3} -Ideal;

:: IDEAL_1:th 69
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
{b2} -Ideal c= {b2,b3} -Ideal &
 {b3} -Ideal c= {b2,b3} -Ideal;

:: IDEAL_1:funcnot 10 => IDEAL_1:func 10
definition
  let a1 be non empty multMagma;
  let a2 be Element of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
  func A3 * A2 -> Element of bool the carrier of a1 equals
    {a3 * b1 where b1 is Element of the carrier of a1: b1 in a2};
end;

:: IDEAL_1:def 19
theorem
for b1 being non empty multMagma
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
   b3 * b2 = {b3 * b4 where b4 is Element of the carrier of b1: b4 in b2};

:: IDEAL_1:funcreg 8
registration
  let a1 be non empty multLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
  cluster a3 * a2 -> non empty;
end;

:: IDEAL_1:funcreg 9
registration
  let a1 be non empty distributive doubleLoopStr;
  let a2 be add-closed Element of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
  cluster a3 * a2 -> add-closed;
end;

:: IDEAL_1:funcreg 10
registration
  let a1 be non empty associative doubleLoopStr;
  let a2 be right-ideal Element of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
  cluster a3 * a2 -> right-ideal;
end;

:: IDEAL_1:th 70
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
   (0. b1) * b2 = {0. b1};

:: IDEAL_1:th 71
theorem
for b1 being non empty left_unital doubleLoopStr
for b2 being Element of bool the carrier of b1 holds
   (1. b1) * b2 = b2;

:: IDEAL_1:funcnot 11 => IDEAL_1:func 11
definition
  let a1 be non empty addLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  func A2 + A3 -> Element of bool the carrier of a1 equals
    {b1 + b2 where b1 is Element of the carrier of a1, b2 is Element of the carrier of a1: b1 in a2 & b2 in a3};
end;

:: IDEAL_1:def 20
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of bool the carrier of b1 holds
b2 + b3 = {b4 + b5 where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: b4 in b2 & b5 in b3};

:: IDEAL_1:funcreg 11
registration
  let a1 be non empty addLoopStr;
  let a2, a3 be non empty Element of bool the carrier of a1;
  cluster a2 + a3 -> non empty;
end;

:: IDEAL_1:funcnot 12 => IDEAL_1:func 12
definition
  let a1 be non empty Abelian addLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  redefine func a2 + a3 -> Element of bool the carrier of a1;
  commutativity;
::  for a1 being non empty Abelian addLoopStr
::  for a2, a3 being Element of bool the carrier of a1 holds
::  a2 + a3 = a3 + a2;
end;

:: IDEAL_1:funcreg 12
registration
  let a1 be non empty Abelian add-associative addLoopStr;
  let a2, a3 be add-closed Element of bool the carrier of a1;
  cluster a2 + a3 -> add-closed;
end;

:: IDEAL_1:funcreg 13
registration
  let a1 be non empty left-distributive doubleLoopStr;
  let a2, a3 be right-ideal Element of bool the carrier of a1;
  cluster a2 + a3 -> right-ideal;
end;

:: IDEAL_1:funcreg 14
registration
  let a1 be non empty right-distributive doubleLoopStr;
  let a2, a3 be left-ideal Element of bool the carrier of a1;
  cluster a2 + a3 -> left-ideal;
end;

:: IDEAL_1:th 72
theorem
for b1 being non empty add-associative addLoopStr
for b2, b3, b4 being Element of bool the carrier of b1 holds
b2 + (b3 + b4) = (b2 + b3) + b4;

:: IDEAL_1:th 73
theorem
for b1 being non empty right_add-cancelable right_zeroed right-distributive left_zeroed doubleLoopStr
for b2, b3 being non empty right-ideal Element of bool the carrier of b1 holds
b2 c= b2 + b3;

:: IDEAL_1:th 74
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr
for b2, b3 being non empty right-ideal Element of bool the carrier of b1 holds
b3 c= b2 + b3;

:: IDEAL_1:th 75
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of bool the carrier of b1
for b4 being add-closed Element of bool the carrier of b1
      st b2 c= b4 & b3 c= b4
   holds b2 + b3 c= b4;

:: IDEAL_1:th 76
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
{b2,b3} -Ideal = {b2} -Ideal + ({b3} -Ideal);

:: IDEAL_1:funcnot 13 => IDEAL_1:func 13
definition
  let a1 be non empty 1-sorted;
  let a2, a3 be Element of bool the carrier of a1;
  redefine func A2 /\ A3 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 in a2 & b1 in a3};
  commutativity;
::  for a1 being non empty 1-sorted
::  for a2, a3 being Element of bool the carrier of a1 holds
::  a2 /\ a3 = a3 /\ a2;
  idempotence;
::  for a1 being non empty 1-sorted
::  for a2 being Element of bool the carrier of a1 holds
::     a2 /\ a2 = a2;
end;

:: IDEAL_1:def 21
theorem
for b1 being non empty 1-sorted
for b2, b3 being Element of bool the carrier of b1 holds
b2 /\ b3 = {b4 where b4 is Element of the carrier of b1: b4 in b2 & b4 in b3};

:: IDEAL_1:funcreg 15
registration
  let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
  let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
  cluster a2 /\ a3 -> non empty;
end;

:: IDEAL_1:funcreg 16
registration
  let a1 be non empty addLoopStr;
  let a2, a3 be add-closed Element of bool the carrier of a1;
  cluster a2 /\ a3 -> add-closed;
end;

:: IDEAL_1:funcreg 17
registration
  let a1 be non empty multLoopStr;
  let a2, a3 be left-ideal Element of bool the carrier of a1;
  cluster a2 /\ a3 -> left-ideal;
end;

:: IDEAL_1:funcreg 18
registration
  let a1 be non empty multLoopStr;
  let a2, a3 be right-ideal Element of bool the carrier of a1;
  cluster a2 /\ a3 -> right-ideal;
end;

:: IDEAL_1:th 80
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed left-distributive left_unital left_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1
for b4 being non empty Element of bool the carrier of b1
      st b3 c= b2
   holds b2 /\ (b3 + b4) = b3 + (b2 /\ b4);

:: IDEAL_1:funcnot 14 => IDEAL_1:func 14
definition
  let a1 be non empty doubleLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  func A2 *' A3 -> Element of bool the carrier of a1 equals
    {Sum b1 where b1 is FinSequence of the carrier of a1: for b2 being Element of NAT
          st 1 <= b2 & b2 <= len b1
       holds ex b3, b4 being Element of the carrier of a1 st
          b1 . b2 = b3 * b4 & b3 in a2 & b4 in a3};
end;

:: IDEAL_1:def 22
theorem
for b1 being non empty doubleLoopStr
for b2, b3 being Element of bool the carrier of b1 holds
b2 *' b3 = {Sum b4 where b4 is FinSequence of the carrier of b1: for b5 being Element of NAT
      st 1 <= b5 & b5 <= len b4
   holds ex b6, b7 being Element of the carrier of b1 st
      b4 . b5 = b6 * b7 & b6 in b2 & b7 in b3};

:: IDEAL_1:funcreg 19
registration
  let a1 be non empty doubleLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  cluster a2 *' a3 -> non empty;
end;

:: IDEAL_1:funcnot 15 => IDEAL_1:func 15
definition
  let a1 be non empty commutative doubleLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  redefine func a2 *' a3 -> Element of bool the carrier of a1;
  commutativity;
::  for a1 being non empty commutative doubleLoopStr
::  for a2, a3 being Element of bool the carrier of a1 holds
::  a2 *' a3 = a3 *' a2;
end;

:: IDEAL_1:funcreg 20
registration
  let a1 be non empty add-associative right_zeroed doubleLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  cluster a2 *' a3 -> add-closed;
end;

:: IDEAL_1:funcreg 21
registration
  let a1 be non empty left_add-cancelable right_zeroed associative left-distributive doubleLoopStr;
  let a2, a3 be right-ideal Element of bool the carrier of a1;
  cluster a2 *' a3 -> right-ideal;
end;

:: IDEAL_1:funcreg 22
registration
  let a1 be non empty right_add-cancelable associative right-distributive left_zeroed doubleLoopStr;
  let a2, a3 be left-ideal Element of bool the carrier of a1;
  cluster a2 *' a3 -> left-ideal;
end;

:: IDEAL_1:th 81
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive left_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
   {0. b1} *' b2 = {0. b1};

:: IDEAL_1:th 82
theorem
for b1 being non empty add-cancelable right_zeroed distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
   b2 *' b3 c= b2 /\ b3;

:: IDEAL_1:th 83
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative distributive left_zeroed doubleLoopStr
for b2, b3, b4 being non empty right-ideal Element of bool the carrier of b1 holds
b2 *' (b3 + b4) = (b2 *' b3) + (b2 *' b4);

:: IDEAL_1:th 84
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative distributive left_zeroed doubleLoopStr
for b2, b3 being non empty right-ideal Element of bool the carrier of b1 holds
(b2 + b3) *' (b2 /\ b3) c= b2 *' b3;

:: IDEAL_1:th 85
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2, b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
(b2 + b3) *' (b2 /\ b3) c= b2 /\ b3;

:: IDEAL_1:prednot 4 => IDEAL_1:pred 4
definition
  let a1 be non empty addLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2,A3 are_co-prime means
    a2 + a3 = the carrier of a1;
end;

:: IDEAL_1:dfs 23
definiens
  let a1 be non empty addLoopStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2,a3 are_co-prime
it is sufficient to prove
  thus a2 + a3 = the carrier of a1;

:: IDEAL_1:def 23
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2,b3 are_co-prime
iff
   b2 + b3 = the carrier of b1;

:: IDEAL_1:th 86
theorem
for b1 being non empty left_unital left_zeroed doubleLoopStr
for b2, b3 being non empty Element of bool the carrier of b1
      st b2,b3 are_co-prime
   holds b2 /\ b3 c= (b2 + b3) *' (b2 /\ b3);

:: IDEAL_1:th 87
theorem
for b1 being non empty add-cancelable Abelian add-associative right_zeroed associative commutative distributive left_unital left_zeroed doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1
      st b2,b3 are_co-prime
   holds b2 *' b3 = b2 /\ b3;

:: IDEAL_1:funcnot 16 => IDEAL_1:func 16
definition
  let a1 be non empty multMagma;
  let a2, a3 be Element of bool the carrier of a1;
  func A2 % A3 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 * a3 c= a2};
end;

:: IDEAL_1:def 24
theorem
for b1 being non empty multMagma
for b2, b3 being Element of bool the carrier of b1 holds
b2 % b3 = {b4 where b4 is Element of the carrier of b1: b4 * b3 c= b2};

:: IDEAL_1:funcreg 23
registration
  let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
  let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
  cluster a2 % a3 -> non empty;
end;

:: IDEAL_1:funcreg 24
registration
  let a1 be non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr;
  let a2, a3 be non empty add-closed left-ideal Element of bool the carrier of a1;
  cluster a2 % a3 -> add-closed;
end;

:: IDEAL_1:funcreg 25
registration
  let a1 be non empty left_add-cancelable right_zeroed associative commutative left-distributive doubleLoopStr;
  let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
  cluster a2 % a3 -> left-ideal;
end;

:: IDEAL_1:funcreg 26
registration
  let a1 be non empty left_add-cancelable right_zeroed associative commutative left-distributive doubleLoopStr;
  let a2, a3 be non empty left-ideal Element of bool the carrier of a1;
  cluster a2 % a3 -> right-ideal;
end;

:: IDEAL_1:th 88
theorem
for b1 being non empty multLoopStr
for b2 being non empty right-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1 holds
   b2 c= b2 % b3;

:: IDEAL_1:th 89
theorem
for b1 being non empty left_add-cancelable right_zeroed left-distributive doubleLoopStr
for b2 being non empty add-closed left-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1 holds
   (b2 % b3) *' b3 c= b2;

:: IDEAL_1:th 90
theorem
for b1 being non empty right_add-cancelable right-distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1 holds
   (b2 % b3) *' b3 c= b2;

:: IDEAL_1:th 91
theorem
for b1 being non empty right_add-cancelable associative commutative right-distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3, b4 being Element of bool the carrier of b1 holds
(b2 % b3) % b4 = b2 % (b3 *' b4);

:: IDEAL_1:th 92
theorem
for b1 being non empty multLoopStr
for b2, b3, b4 being Element of bool the carrier of b1 holds
(b3 /\ b4) % b2 = (b3 % b2) /\ (b4 % b2);

:: IDEAL_1:th 93
theorem
for b1 being non empty right_add-cancelable right_zeroed right-distributive left_zeroed doubleLoopStr
for b2 being add-closed Element of bool the carrier of b1
for b3, b4 being non empty right-ideal Element of bool the carrier of b1 holds
b2 % (b3 + b4) = (b2 % b3) /\ (b2 % b4);

:: IDEAL_1:funcnot 17 => IDEAL_1:func 17
definition
  let a1 be non empty well-unital doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  func sqrt A2 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: ex b2 being Element of NAT st
       b1 |^ b2 in a2};
end;

:: IDEAL_1:def 25
theorem
for b1 being non empty well-unital doubleLoopStr
for b2 being Element of bool the carrier of b1 holds
   sqrt b2 = {b3 where b3 is Element of the carrier of b1: ex b4 being Element of NAT st
      b3 |^ b4 in b2};

:: IDEAL_1:funcreg 27
registration
  let a1 be non empty well-unital doubleLoopStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster sqrt a2 -> non empty;
end;

:: IDEAL_1:funcreg 28
registration
  let a1 be non empty add-cancelable Abelian add-associative right_zeroed associative commutative well-unital distributive left_zeroed doubleLoopStr;
  let a2 be non empty add-closed right-ideal Element of bool the carrier of a1;
  cluster sqrt a2 -> add-closed;
end;

:: IDEAL_1:funcreg 29
registration
  let a1 be non empty associative commutative well-unital doubleLoopStr;
  let a2 be non empty left-ideal Element of bool the carrier of a1;
  cluster sqrt a2 -> left-ideal;
end;

:: IDEAL_1:funcreg 30
registration
  let a1 be non empty associative commutative well-unital doubleLoopStr;
  let a2 be non empty left-ideal Element of bool the carrier of a1;
  cluster sqrt a2 -> right-ideal;
end;

:: IDEAL_1:th 94
theorem
for b1 being non empty associative well-unital doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      b3 in sqrt b2
   iff
      ex b4 being Element of NAT st
         b3 |^ b4 in sqrt b2;

:: IDEAL_1:th 95
theorem
for b1 being non empty add-cancelable right_zeroed associative well-unital distributive left_zeroed doubleLoopStr
for b2 being non empty add-closed right-ideal Element of bool the carrier of b1
for b3 being non empty add-closed left-ideal Element of bool the carrier of b1 holds
   sqrt (b2 *' b3) = sqrt (b2 /\ b3);

:: IDEAL_1:attrnot 6 => IDEAL_1:attr 6
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  attr a2 is finitely_generated means
    ex b1 being non empty finite Element of bool the carrier of a1 st
       a2 = b1 -Ideal;
end;

:: IDEAL_1:dfs 26
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
To prove
     a2 is finitely_generated
it is sufficient to prove
  thus ex b1 being non empty finite Element of bool the carrier of a1 st
       a2 = b1 -Ideal;

:: IDEAL_1:def 26
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is finitely_generated(b1)
   iff
      ex b3 being non empty finite Element of bool the carrier of b1 st
         b2 = b3 -Ideal;

:: IDEAL_1:exreg 14
registration
  let a1 be non empty doubleLoopStr;
  cluster non empty add-closed left-ideal right-ideal finitely_generated Element of bool the carrier of a1;
end;

:: IDEAL_1:funcreg 31
registration
  let a1 be non empty doubleLoopStr;
  let a2 be non empty finite Element of bool the carrier of a1;
  cluster a2 -Ideal -> non empty add-closed left-ideal right-ideal finitely_generated;
end;

:: IDEAL_1:attrnot 7 => IDEAL_1:attr 7
definition
  let a1 be non empty doubleLoopStr;
  attr a1 is Noetherian means
    for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
       b1 is finitely_generated(a1);
end;

:: IDEAL_1:dfs 27
definiens
  let a1 be non empty doubleLoopStr;
To prove
     a1 is Noetherian
it is sufficient to prove
  thus for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
       b1 is finitely_generated(a1);

:: IDEAL_1:def 27
theorem
for b1 being non empty doubleLoopStr holds
      b1 is Noetherian
   iff
      for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
         b2 is finitely_generated(b1);

:: IDEAL_1:exreg 15
registration
  cluster non empty non degenerated right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive Euclidian doubleLoopStr;
end;

:: IDEAL_1:attrnot 8 => IDEAL_1:attr 8
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
  attr a2 is principal means
    ex b1 being Element of the carrier of a1 st
       a2 = {b1} -Ideal;
end;

:: IDEAL_1:dfs 28
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be non empty add-closed left-ideal right-ideal Element of bool the carrier of a1;
To prove
     a2 is principal
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       a2 = {b1} -Ideal;

:: IDEAL_1:def 28
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
      b2 is principal(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b2 = {b3} -Ideal;

:: IDEAL_1:attrnot 9 => IDEAL_1:attr 9
definition
  let a1 be non empty doubleLoopStr;
  attr a1 is PID means
    for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
       b1 is principal(a1);
end;

:: IDEAL_1:dfs 29
definiens
  let a1 be non empty doubleLoopStr;
To prove
     a1 is PID
it is sufficient to prove
  thus for b1 being non empty add-closed left-ideal right-ideal Element of bool the carrier of a1 holds
       b1 is principal(a1);

:: IDEAL_1:def 29
theorem
for b1 being non empty doubleLoopStr holds
      b1 is PID
   iff
      for b2 being non empty add-closed left-ideal right-ideal Element of bool the carrier of b1 holds
         b2 is principal(b1);

:: IDEAL_1:th 96
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty Element of bool the carrier of b1
      st b2 <> {0. b1}
   holds ex b3 being Element of the carrier of b1 st
      b3 <> 0. b1 & b3 in b2;

:: IDEAL_1:th 97
theorem
for b1 being non empty right_complementable add-associative right_zeroed well-unital distributive left_zeroed Euclidian doubleLoopStr holds
   b1 is PID;

:: IDEAL_1:th 98
theorem
for b1 being non empty doubleLoopStr
      st b1 is PID
   holds b1 is Noetherian;

:: IDEAL_1:funcreg 32
registration
  cluster INT.Ring -> Noetherian;
end;

:: IDEAL_1:exreg 16
registration
  cluster non empty non degenerated right_complementable Abelian add-associative right_zeroed associative commutative well-unital distributive Noetherian doubleLoopStr;
end;

:: IDEAL_1:th 99
theorem
for b1 being non empty add-cancelable add-associative right_zeroed associative well-unital distributive left_zeroed Noetherian doubleLoopStr
for b2 being non empty Element of bool the carrier of b1 holds
   ex b3 being non empty finite Element of bool the carrier of b1 st
      b3 c= b2 & b3 -Ideal = b2 -Ideal;

:: IDEAL_1:th 100
theorem
for b1 being non empty doubleLoopStr
   st for b2 being non empty Element of bool the carrier of b1 holds
        ex b3 being non empty finite Element of bool the carrier of b1 st
           b3 c= b2 & b3 -Ideal = b2 -Ideal
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   ex b3 being Element of NAT st
      b2 . (b3 + 1) in (rng (b2 | (b3 + 1))) -Ideal;

:: IDEAL_1:funcreg 33
registration
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be non empty Element of bool a1;
  cluster a3 | a4 -> non empty Relation-like;
end;

:: IDEAL_1:th 101
theorem
for b1 being non empty doubleLoopStr
   st for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
        ex b3 being Element of NAT st
           b2 . (b3 + 1) in (rng (b2 | (b3 + 1))) -Ideal
for b2 being Function-like quasi_total Relation of NAT,bool the carrier of b1
      st for b3 being Element of NAT holds
           b2 . b3 is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
   holds ex b3, b4 being Element of NAT st
      b3 < b4 & not b2 . b3 c< b2 . b4;

:: IDEAL_1:th 102
theorem
for b1 being non empty doubleLoopStr
      st for b2 being Function-like quasi_total Relation of NAT,bool the carrier of b1
              st for b3 being Element of NAT holds
                   b2 . b3 is non empty add-closed left-ideal right-ideal Element of bool the carrier of b1
           holds ex b3, b4 being Element of NAT st
              b3 < b4 & not b2 . b3 c< b2 . b4
   holds b1 is Noetherian;