Article ALGSTR_0, MML version 4.99.1005

:: ALGSTR_0:structnot 1 => ALGSTR_0:struct 1
definition
  struct(1-sorted) addMagma(#
    carrier -> set,
    addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: ALGSTR_0:attrnot 1 => ALGSTR_0:attr 1
definition
  let a1 be addMagma;
  attr a1 is strict;
end;

:: ALGSTR_0:exreg 1
registration
  cluster strict addMagma;
end;

:: ALGSTR_0:aggrnot 1 => ALGSTR_0:aggr 1
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr addMagma(#a1,a2#) -> strict addMagma;
end;

:: ALGSTR_0:selnot 1 => ALGSTR_0:sel 1
definition
  let a1 be addMagma;
  sel the addF of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: ALGSTR_0:funcreg 1
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster addMagma(#a1,a2#) -> non empty strict;
end;

:: ALGSTR_0:funcreg 2
registration
  let a1 be trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster addMagma(#a1,a2#) -> trivial strict;
end;

:: ALGSTR_0:funcreg 3
registration
  let a1 be non trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster addMagma(#a1,a2#) -> non trivial strict;
end;

:: ALGSTR_0:funcnot 1 => ALGSTR_0:func 1
definition
  let a1 be addMagma;
  let a2, a3 be Element of the carrier of a1;
  func A2 + A3 -> Element of the carrier of a1 equals
    (the addF of a1) .(a2,a3);
end;

:: ALGSTR_0:def 1
theorem
for b1 being addMagma
for b2, b3 being Element of the carrier of b1 holds
b2 + b3 = (the addF of b1) .(b2,b3);

:: ALGSTR_0:funcnot 2 => ALGSTR_0:func 2
definition
  func Trivial-addMagma -> addMagma equals
    addMagma(#1,op2#);
end;

:: ALGSTR_0:def 2
theorem
Trivial-addMagma = addMagma(#1,op2#);

:: ALGSTR_0:funcreg 4
registration
  cluster Trivial-addMagma -> non empty trivial strict;
end;

:: ALGSTR_0:exreg 2
registration
  cluster non empty trivial strict addMagma;
end;

:: ALGSTR_0:attrnot 2 => ALGSTR_0:attr 2
definition
  let a1 be addMagma;
  let a2 be Element of the carrier of a1;
  attr a2 is left_add-cancelable means
    for b1, b2 being Element of the carrier of a1
          st a2 + b1 = a2 + b2
       holds b1 = b2;
end;

:: ALGSTR_0:dfs 3
definiens
  let a1 be addMagma;
  let a2 be Element of the carrier of a1;
To prove
     a2 is left_add-cancelable
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st a2 + b1 = a2 + b2
       holds b1 = b2;

:: ALGSTR_0:def 3
theorem
for b1 being addMagma
for b2 being Element of the carrier of b1 holds
      b2 is left_add-cancelable(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b2 + b3 = b2 + b4
         holds b3 = b4;

:: ALGSTR_0:attrnot 3 => ALGSTR_0:attr 3
definition
  let a1 be addMagma;
  let a2 be Element of the carrier of a1;
  attr a2 is right_add-cancelable means
    for b1, b2 being Element of the carrier of a1
          st b1 + a2 = b2 + a2
       holds b1 = b2;
end;

:: ALGSTR_0:dfs 4
definiens
  let a1 be addMagma;
  let a2 be Element of the carrier of a1;
To prove
     a2 is right_add-cancelable
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 + a2 = b2 + a2
       holds b1 = b2;

:: ALGSTR_0:def 4
theorem
for b1 being addMagma
for b2 being Element of the carrier of b1 holds
      b2 is right_add-cancelable(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 + b2 = b4 + b2
         holds b3 = b4;

:: ALGSTR_0:attrnot 4 => ALGSTR_0:attr 4
definition
  let a1 be addMagma;
  let a2 be Element of the carrier of a1;
  attr a2 is add-cancelable means
    a2 is right_add-cancelable(a1) & a2 is left_add-cancelable(a1);
end;

:: ALGSTR_0:dfs 5
definiens
  let a1 be addMagma;
  let a2 be Element of the carrier of a1;
To prove
     a2 is add-cancelable
it is sufficient to prove
  thus a2 is right_add-cancelable(a1) & a2 is left_add-cancelable(a1);

:: ALGSTR_0:def 5
theorem
for b1 being addMagma
for b2 being Element of the carrier of b1 holds
      b2 is add-cancelable(b1)
   iff
      b2 is right_add-cancelable(b1) & b2 is left_add-cancelable(b1);

:: ALGSTR_0:condreg 1
registration
  let a1 be addMagma;
  cluster left_add-cancelable right_add-cancelable -> add-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 2
registration
  let a1 be addMagma;
  cluster add-cancelable -> left_add-cancelable right_add-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:attrnot 5 => ALGSTR_0:attr 5
definition
  let a1 be addMagma;
  attr a1 is left_add-cancelable means
    for b1 being Element of the carrier of a1 holds
       b1 is left_add-cancelable(a1);
end;

:: ALGSTR_0:dfs 6
definiens
  let a1 be addMagma;
To prove
     a1 is left_add-cancelable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is left_add-cancelable(a1);

:: ALGSTR_0:def 6
theorem
for b1 being addMagma holds
      b1 is left_add-cancelable
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is left_add-cancelable(b1);

:: ALGSTR_0:attrnot 6 => ALGSTR_0:attr 6
definition
  let a1 be addMagma;
  attr a1 is right_add-cancelable means
    for b1 being Element of the carrier of a1 holds
       b1 is right_add-cancelable(a1);
end;

:: ALGSTR_0:dfs 7
definiens
  let a1 be addMagma;
To prove
     a1 is right_add-cancelable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is right_add-cancelable(a1);

:: ALGSTR_0:def 7
theorem
for b1 being addMagma holds
      b1 is right_add-cancelable
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is right_add-cancelable(b1);

:: ALGSTR_0:attrnot 7 => ALGSTR_0:attr 7
definition
  let a1 be addMagma;
  attr a1 is add-cancelable means
    a1 is right_add-cancelable & a1 is left_add-cancelable;
end;

:: ALGSTR_0:dfs 8
definiens
  let a1 be addMagma;
To prove
     a1 is add-cancelable
it is sufficient to prove
  thus a1 is right_add-cancelable & a1 is left_add-cancelable;

:: ALGSTR_0:def 8
theorem
for b1 being addMagma holds
      b1 is add-cancelable
   iff
      b1 is right_add-cancelable & b1 is left_add-cancelable;

:: ALGSTR_0:condreg 3
registration
  cluster left_add-cancelable right_add-cancelable -> add-cancelable (addMagma);
end;

:: ALGSTR_0:condreg 4
registration
  cluster add-cancelable -> left_add-cancelable right_add-cancelable (addMagma);
end;

:: ALGSTR_0:funcreg 5
registration
  cluster Trivial-addMagma -> add-cancelable;
end;

:: ALGSTR_0:exreg 3
registration
  cluster non empty trivial strict add-cancelable addMagma;
end;

:: ALGSTR_0:condreg 5
registration
  let a1 be left_add-cancelable addMagma;
  cluster -> left_add-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 6
registration
  let a1 be right_add-cancelable addMagma;
  cluster -> right_add-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:structnot 2 => ALGSTR_0:struct 2
definition
  struct(ZeroStraddMagma) addLoopStr(#
    carrier -> set,
    addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    ZeroF -> Element of the carrier of it
  #);
end;

:: ALGSTR_0:attrnot 8 => ALGSTR_0:attr 8
definition
  let a1 be addLoopStr;
  attr a1 is strict;
end;

:: ALGSTR_0:exreg 4
registration
  cluster strict addLoopStr;
end;

:: ALGSTR_0:aggrnot 2 => ALGSTR_0:aggr 2
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  aggr addLoopStr(#a1,a2,a3#) -> strict addLoopStr;
end;

:: ALGSTR_0:funcreg 6
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  cluster addLoopStr(#a1,a2,a3#) -> non empty strict;
end;

:: ALGSTR_0:funcreg 7
registration
  let a1 be trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  cluster addLoopStr(#a1,a2,a3#) -> trivial strict;
end;

:: ALGSTR_0:funcreg 8
registration
  let a1 be non trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  cluster addLoopStr(#a1,a2,a3#) -> non trivial strict;
end;

:: ALGSTR_0:funcnot 3 => ALGSTR_0:func 3
definition
  func Trivial-addLoopStr -> addLoopStr equals
    addLoopStr(#1,op2,op0#);
end;

:: ALGSTR_0:def 9
theorem
Trivial-addLoopStr = addLoopStr(#1,op2,op0#);

:: ALGSTR_0:funcreg 9
registration
  cluster Trivial-addLoopStr -> non empty trivial strict;
end;

:: ALGSTR_0:exreg 5
registration
  cluster non empty trivial strict addLoopStr;
end;

:: ALGSTR_0:attrnot 9 => ALGSTR_0:attr 9
definition
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
  attr a2 is left_complementable means
    ex b1 being Element of the carrier of a1 st
       b1 + a2 = 0. a1;
end;

:: ALGSTR_0:dfs 10
definiens
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is left_complementable
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 + a2 = 0. a1;

:: ALGSTR_0:def 10
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1 holds
      b2 is left_complementable(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b3 + b2 = 0. b1;

:: ALGSTR_0:attrnot 10 => ALGSTR_0:attr 10
definition
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
  attr a2 is right_complementable means
    ex b1 being Element of the carrier of a1 st
       a2 + b1 = 0. a1;
end;

:: ALGSTR_0:dfs 11
definiens
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is right_complementable
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       a2 + b1 = 0. a1;

:: ALGSTR_0:def 11
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1 holds
      b2 is right_complementable(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b2 + b3 = 0. b1;

:: ALGSTR_0:attrnot 11 => ALGSTR_0:attr 11
definition
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
  attr a2 is complementable means
    a2 is right_complementable(a1) & a2 is left_complementable(a1);
end;

:: ALGSTR_0:dfs 12
definiens
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is complementable
it is sufficient to prove
  thus a2 is right_complementable(a1) & a2 is left_complementable(a1);

:: ALGSTR_0:def 12
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1 holds
      b2 is complementable(b1)
   iff
      b2 is right_complementable(b1) & b2 is left_complementable(b1);

:: ALGSTR_0:condreg 7
registration
  let a1 be addLoopStr;
  cluster left_complementable right_complementable -> complementable (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 8
registration
  let a1 be addLoopStr;
  cluster complementable -> left_complementable right_complementable (Element of the carrier of a1);
end;

:: ALGSTR_0:funcnot 4 => ALGSTR_0:func 4
definition
  let a1 be addLoopStr;
  let a2 be Element of the carrier of a1;
  assume a2 is left_complementable(a1) & a2 is right_add-cancelable(a1);
  func - A2 -> Element of the carrier of a1 means
    it + a2 = 0. a1;
end;

:: ALGSTR_0:def 13
theorem
for b1 being addLoopStr
for b2 being Element of the carrier of b1
   st b2 is left_complementable(b1) & b2 is right_add-cancelable(b1)
for b3 being Element of the carrier of b1 holds
      b3 = - b2
   iff
      b3 + b2 = 0. b1;

:: ALGSTR_0:funcnot 5 => ALGSTR_0:func 5
definition
  let a1 be addLoopStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 - A3 -> Element of the carrier of a1 equals
    a2 + - a3;
end;

:: ALGSTR_0:def 14
theorem
for b1 being addLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 - b3 = b2 + - b3;

:: ALGSTR_0:funcreg 10
registration
  cluster Trivial-addLoopStr -> add-cancelable;
end;

:: ALGSTR_0:attrnot 12 => ALGSTR_0:attr 12
definition
  let a1 be addLoopStr;
  attr a1 is left_complementable means
    for b1 being Element of the carrier of a1 holds
       b1 is left_complementable(a1);
end;

:: ALGSTR_0:dfs 15
definiens
  let a1 be addLoopStr;
To prove
     a1 is left_complementable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is left_complementable(a1);

:: ALGSTR_0:def 15
theorem
for b1 being addLoopStr holds
      b1 is left_complementable
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is left_complementable(b1);

:: ALGSTR_0:attrnot 13 => ALGSTR_0:attr 13
definition
  let a1 be addLoopStr;
  attr a1 is right_complementable means
    for b1 being Element of the carrier of a1 holds
       b1 is right_complementable(a1);
end;

:: ALGSTR_0:dfs 16
definiens
  let a1 be addLoopStr;
To prove
     a1 is right_complementable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is right_complementable(a1);

:: ALGSTR_0:def 16
theorem
for b1 being addLoopStr holds
      b1 is right_complementable
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is right_complementable(b1);

:: ALGSTR_0:attrnot 14 => ALGSTR_0:attr 14
definition
  let a1 be addLoopStr;
  attr a1 is complementable means
    a1 is right_complementable & a1 is left_complementable;
end;

:: ALGSTR_0:dfs 17
definiens
  let a1 be addLoopStr;
To prove
     a1 is complementable
it is sufficient to prove
  thus a1 is right_complementable & a1 is left_complementable;

:: ALGSTR_0:def 17
theorem
for b1 being addLoopStr holds
      b1 is complementable
   iff
      b1 is right_complementable & b1 is left_complementable;

:: ALGSTR_0:condreg 9
registration
  cluster left_complementable right_complementable -> complementable (addLoopStr);
end;

:: ALGSTR_0:condreg 10
registration
  cluster complementable -> left_complementable right_complementable (addLoopStr);
end;

:: ALGSTR_0:funcreg 11
registration
  cluster Trivial-addLoopStr -> complementable;
end;

:: ALGSTR_0:exreg 6
registration
  cluster non empty trivial add-cancelable strict complementable addLoopStr;
end;

:: ALGSTR_0:condreg 11
registration
  let a1 be left_complementable addLoopStr;
  cluster -> left_complementable (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 12
registration
  let a1 be right_complementable addLoopStr;
  cluster -> right_complementable (Element of the carrier of a1);
end;

:: ALGSTR_0:structnot 3 => ALGSTR_0:struct 3
definition
  struct(1-sorted) multMagma(#
    carrier -> set,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: ALGSTR_0:attrnot 15 => ALGSTR_0:attr 15
definition
  let a1 be multMagma;
  attr a1 is strict;
end;

:: ALGSTR_0:exreg 7
registration
  cluster strict multMagma;
end;

:: ALGSTR_0:aggrnot 3 => ALGSTR_0:aggr 3
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr multMagma(#a1,a2#) -> strict multMagma;
end;

:: ALGSTR_0:selnot 2 => ALGSTR_0:sel 2
definition
  let a1 be multMagma;
  sel the multF of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: ALGSTR_0:funcreg 12
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster multMagma(#a1,a2#) -> non empty strict;
end;

:: ALGSTR_0:funcreg 13
registration
  let a1 be trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster multMagma(#a1,a2#) -> trivial strict;
end;

:: ALGSTR_0:funcreg 14
registration
  let a1 be non trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster multMagma(#a1,a2#) -> non trivial strict;
end;

:: ALGSTR_0:funcnot 6 => ALGSTR_0:func 6
definition
  let a1 be multMagma;
  let a2, a3 be Element of the carrier of a1;
  func A2 * A3 -> Element of the carrier of a1 equals
    (the multF of a1) .(a2,a3);
end;

:: ALGSTR_0:def 18
theorem
for b1 being multMagma
for b2, b3 being Element of the carrier of b1 holds
b2 * b3 = (the multF of b1) .(b2,b3);

:: ALGSTR_0:funcnot 7 => ALGSTR_0:func 7
definition
  func Trivial-multMagma -> multMagma equals
    multMagma(#1,op2#);
end;

:: ALGSTR_0:def 19
theorem
Trivial-multMagma = multMagma(#1,op2#);

:: ALGSTR_0:funcreg 15
registration
  cluster Trivial-multMagma -> non empty trivial strict;
end;

:: ALGSTR_0:exreg 8
registration
  cluster non empty trivial strict multMagma;
end;

:: ALGSTR_0:attrnot 16 => ALGSTR_0:attr 16
definition
  let a1 be multMagma;
  let a2 be Element of the carrier of a1;
  attr a2 is left_mult-cancelable means
    for b1, b2 being Element of the carrier of a1
          st a2 * b1 = a2 * b2
       holds b1 = b2;
end;

:: ALGSTR_0:dfs 20
definiens
  let a1 be multMagma;
  let a2 be Element of the carrier of a1;
To prove
     a2 is left_mult-cancelable
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st a2 * b1 = a2 * b2
       holds b1 = b2;

:: ALGSTR_0:def 20
theorem
for b1 being multMagma
for b2 being Element of the carrier of b1 holds
      b2 is left_mult-cancelable(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b2 * b3 = b2 * b4
         holds b3 = b4;

:: ALGSTR_0:attrnot 17 => ALGSTR_0:attr 17
definition
  let a1 be multMagma;
  let a2 be Element of the carrier of a1;
  attr a2 is right_mult-cancelable means
    for b1, b2 being Element of the carrier of a1
          st b1 * a2 = b2 * a2
       holds b1 = b2;
end;

:: ALGSTR_0:dfs 21
definiens
  let a1 be multMagma;
  let a2 be Element of the carrier of a1;
To prove
     a2 is right_mult-cancelable
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 * a2 = b2 * a2
       holds b1 = b2;

:: ALGSTR_0:def 21
theorem
for b1 being multMagma
for b2 being Element of the carrier of b1 holds
      b2 is right_mult-cancelable(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 * b2 = b4 * b2
         holds b3 = b4;

:: ALGSTR_0:attrnot 18 => ALGSTR_0:attr 18
definition
  let a1 be multMagma;
  let a2 be Element of the carrier of a1;
  attr a2 is mult-cancelable means
    a2 is right_mult-cancelable(a1) & a2 is left_mult-cancelable(a1);
end;

:: ALGSTR_0:dfs 22
definiens
  let a1 be multMagma;
  let a2 be Element of the carrier of a1;
To prove
     a2 is mult-cancelable
it is sufficient to prove
  thus a2 is right_mult-cancelable(a1) & a2 is left_mult-cancelable(a1);

:: ALGSTR_0:def 22
theorem
for b1 being multMagma
for b2 being Element of the carrier of b1 holds
      b2 is mult-cancelable(b1)
   iff
      b2 is right_mult-cancelable(b1) & b2 is left_mult-cancelable(b1);

:: ALGSTR_0:condreg 13
registration
  let a1 be multMagma;
  cluster left_mult-cancelable right_mult-cancelable -> mult-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 14
registration
  let a1 be multMagma;
  cluster mult-cancelable -> left_mult-cancelable right_mult-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:attrnot 19 => ALGSTR_0:attr 19
definition
  let a1 be multMagma;
  attr a1 is left_mult-cancelable means
    for b1 being Element of the carrier of a1 holds
       b1 is left_mult-cancelable(a1);
end;

:: ALGSTR_0:dfs 23
definiens
  let a1 be multMagma;
To prove
     a1 is left_mult-cancelable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is left_mult-cancelable(a1);

:: ALGSTR_0:def 23
theorem
for b1 being multMagma holds
      b1 is left_mult-cancelable
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is left_mult-cancelable(b1);

:: ALGSTR_0:attrnot 20 => ALGSTR_0:attr 20
definition
  let a1 be multMagma;
  attr a1 is right_mult-cancelable means
    for b1 being Element of the carrier of a1 holds
       b1 is right_mult-cancelable(a1);
end;

:: ALGSTR_0:dfs 24
definiens
  let a1 be multMagma;
To prove
     a1 is right_mult-cancelable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is right_mult-cancelable(a1);

:: ALGSTR_0:def 24
theorem
for b1 being multMagma holds
      b1 is right_mult-cancelable
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is right_mult-cancelable(b1);

:: ALGSTR_0:attrnot 21 => ALGSTR_0:attr 21
definition
  let a1 be multMagma;
  attr a1 is mult-cancelable means
    a1 is left_mult-cancelable & a1 is right_mult-cancelable;
end;

:: ALGSTR_0:dfs 25
definiens
  let a1 be multMagma;
To prove
     a1 is mult-cancelable
it is sufficient to prove
  thus a1 is left_mult-cancelable & a1 is right_mult-cancelable;

:: ALGSTR_0:def 25
theorem
for b1 being multMagma holds
      b1 is mult-cancelable
   iff
      b1 is left_mult-cancelable & b1 is right_mult-cancelable;

:: ALGSTR_0:condreg 15
registration
  cluster left_mult-cancelable right_mult-cancelable -> mult-cancelable (multMagma);
end;

:: ALGSTR_0:condreg 16
registration
  cluster mult-cancelable -> left_mult-cancelable right_mult-cancelable (multMagma);
end;

:: ALGSTR_0:funcreg 16
registration
  cluster Trivial-multMagma -> mult-cancelable;
end;

:: ALGSTR_0:exreg 9
registration
  cluster non empty trivial strict mult-cancelable multMagma;
end;

:: ALGSTR_0:condreg 17
registration
  let a1 be left_mult-cancelable multMagma;
  cluster -> left_mult-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 18
registration
  let a1 be right_mult-cancelable multMagma;
  cluster -> right_mult-cancelable (Element of the carrier of a1);
end;

:: ALGSTR_0:structnot 4 => ALGSTR_0:struct 4
definition
  struct(OneStrmultMagma) multLoopStr(#
    carrier -> set,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    OneF -> Element of the carrier of it
  #);
end;

:: ALGSTR_0:attrnot 22 => ALGSTR_0:attr 22
definition
  let a1 be multLoopStr;
  attr a1 is strict;
end;

:: ALGSTR_0:exreg 10
registration
  cluster strict multLoopStr;
end;

:: ALGSTR_0:aggrnot 4 => ALGSTR_0:aggr 4
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  aggr multLoopStr(#a1,a2,a3#) -> strict multLoopStr;
end;

:: ALGSTR_0:funcreg 17
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  cluster multLoopStr(#a1,a2,a3#) -> non empty strict;
end;

:: ALGSTR_0:funcreg 18
registration
  let a1 be trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  cluster multLoopStr(#a1,a2,a3#) -> trivial strict;
end;

:: ALGSTR_0:funcreg 19
registration
  let a1 be non trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be Element of a1;
  cluster multLoopStr(#a1,a2,a3#) -> non trivial strict;
end;

:: ALGSTR_0:funcnot 8 => ALGSTR_0:func 8
definition
  func Trivial-multLoopStr -> multLoopStr equals
    multLoopStr(#1,op2,op0#);
end;

:: ALGSTR_0:def 26
theorem
Trivial-multLoopStr = multLoopStr(#1,op2,op0#);

:: ALGSTR_0:funcreg 20
registration
  cluster Trivial-multLoopStr -> non empty trivial strict;
end;

:: ALGSTR_0:exreg 11
registration
  cluster non empty trivial strict multLoopStr;
end;

:: ALGSTR_0:funcreg 21
registration
  cluster Trivial-multLoopStr -> mult-cancelable;
end;

:: ALGSTR_0:attrnot 23 => ALGSTR_0:attr 23
definition
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
  attr a2 is left_invertible means
    ex b1 being Element of the carrier of a1 st
       b1 * a2 = 1. a1;
end;

:: ALGSTR_0:dfs 27
definiens
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is left_invertible
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 * a2 = 1. a1;

:: ALGSTR_0:def 27
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1 holds
      b2 is left_invertible(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b3 * b2 = 1. b1;

:: ALGSTR_0:attrnot 24 => ALGSTR_0:attr 24
definition
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
  attr a2 is right_invertible means
    ex b1 being Element of the carrier of a1 st
       a2 * b1 = 1. a1;
end;

:: ALGSTR_0:dfs 28
definiens
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is right_invertible
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       a2 * b1 = 1. a1;

:: ALGSTR_0:def 28
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1 holds
      b2 is right_invertible(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b2 * b3 = 1. b1;

:: ALGSTR_0:attrnot 25 => ALGSTR_0:attr 25
definition
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
  attr a2 is invertible means
    a2 is right_invertible(a1) & a2 is left_invertible(a1);
end;

:: ALGSTR_0:dfs 29
definiens
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is invertible
it is sufficient to prove
  thus a2 is right_invertible(a1) & a2 is left_invertible(a1);

:: ALGSTR_0:def 29
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1 holds
      b2 is invertible(b1)
   iff
      b2 is right_invertible(b1) & b2 is left_invertible(b1);

:: ALGSTR_0:condreg 19
registration
  let a1 be multLoopStr;
  cluster left_invertible right_invertible -> invertible (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 20
registration
  let a1 be multLoopStr;
  cluster invertible -> left_invertible right_invertible (Element of the carrier of a1);
end;

:: ALGSTR_0:funcnot 9 => ALGSTR_0:func 9
definition
  let a1 be multLoopStr;
  let a2 be Element of the carrier of a1;
  assume a2 is left_invertible(a1) & a2 is right_mult-cancelable(a1);
  func / A2 -> Element of the carrier of a1 means
    it * a2 = 1. a1;
end;

:: ALGSTR_0:def 30
theorem
for b1 being multLoopStr
for b2 being Element of the carrier of b1
   st b2 is left_invertible(b1) & b2 is right_mult-cancelable(b1)
for b3 being Element of the carrier of b1 holds
      b3 = / b2
   iff
      b3 * b2 = 1. b1;

:: ALGSTR_0:attrnot 26 => ALGSTR_0:attr 26
definition
  let a1 be multLoopStr;
  attr a1 is left_invertible means
    for b1 being Element of the carrier of a1 holds
       b1 is left_invertible(a1);
end;

:: ALGSTR_0:dfs 31
definiens
  let a1 be multLoopStr;
To prove
     a1 is left_invertible
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is left_invertible(a1);

:: ALGSTR_0:def 31
theorem
for b1 being multLoopStr holds
      b1 is left_invertible
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is left_invertible(b1);

:: ALGSTR_0:attrnot 27 => ALGSTR_0:attr 27
definition
  let a1 be multLoopStr;
  attr a1 is right_invertible means
    for b1 being Element of the carrier of a1 holds
       b1 is right_invertible(a1);
end;

:: ALGSTR_0:dfs 32
definiens
  let a1 be multLoopStr;
To prove
     a1 is right_invertible
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 is right_invertible(a1);

:: ALGSTR_0:def 32
theorem
for b1 being multLoopStr holds
      b1 is right_invertible
   iff
      for b2 being Element of the carrier of b1 holds
         b2 is right_invertible(b1);

:: ALGSTR_0:attrnot 28 => ALGSTR_0:attr 28
definition
  let a1 be multLoopStr;
  attr a1 is invertible means
    a1 is right_invertible & a1 is left_invertible;
end;

:: ALGSTR_0:dfs 33
definiens
  let a1 be multLoopStr;
To prove
     a1 is invertible
it is sufficient to prove
  thus a1 is right_invertible & a1 is left_invertible;

:: ALGSTR_0:def 33
theorem
for b1 being multLoopStr holds
      b1 is invertible
   iff
      b1 is right_invertible & b1 is left_invertible;

:: ALGSTR_0:condreg 21
registration
  cluster left_invertible right_invertible -> invertible (multLoopStr);
end;

:: ALGSTR_0:condreg 22
registration
  cluster invertible -> left_invertible right_invertible (multLoopStr);
end;

:: ALGSTR_0:funcreg 22
registration
  cluster Trivial-multLoopStr -> invertible;
end;

:: ALGSTR_0:exreg 12
registration
  cluster non empty trivial mult-cancelable strict invertible multLoopStr;
end;

:: ALGSTR_0:condreg 23
registration
  let a1 be left_invertible multLoopStr;
  cluster -> left_invertible (Element of the carrier of a1);
end;

:: ALGSTR_0:condreg 24
registration
  let a1 be right_invertible multLoopStr;
  cluster -> right_invertible (Element of the carrier of a1);
end;

:: ALGSTR_0:structnot 5 => ALGSTR_0:struct 5
definition
  struct(multLoopStrZeroOneStr) multLoopStr_0(#
    carrier -> set,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    ZeroF -> Element of the carrier of it,
    OneF -> Element of the carrier of it
  #);
end;

:: ALGSTR_0:attrnot 29 => ALGSTR_0:attr 29
definition
  let a1 be multLoopStr_0;
  attr a1 is strict;
end;

:: ALGSTR_0:exreg 13
registration
  cluster strict multLoopStr_0;
end;

:: ALGSTR_0:aggrnot 5 => ALGSTR_0:aggr 5
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3, a4 be Element of a1;
  aggr multLoopStr_0(#a1,a2,a3,a4#) -> strict multLoopStr_0;
end;

:: ALGSTR_0:funcreg 23
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3, a4 be Element of a1;
  cluster multLoopStr_0(#a1,a2,a3,a4#) -> non empty strict;
end;

:: ALGSTR_0:funcreg 24
registration
  let a1 be trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3, a4 be Element of a1;
  cluster multLoopStr_0(#a1,a2,a3,a4#) -> trivial strict;
end;

:: ALGSTR_0:funcreg 25
registration
  let a1 be non trivial set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3, a4 be Element of a1;
  cluster multLoopStr_0(#a1,a2,a3,a4#) -> non trivial strict;
end;

:: ALGSTR_0:funcnot 10 => ALGSTR_0:func 10
definition
  func Trivial-multLoopStr_0 -> multLoopStr_0 equals
    multLoopStr_0(#1,op2,op0,op0#);
end;

:: ALGSTR_0:def 34
theorem
Trivial-multLoopStr_0 = multLoopStr_0(#1,op2,op0,op0#);

:: ALGSTR_0:funcreg 26
registration
  cluster Trivial-multLoopStr_0 -> non empty trivial strict;
end;

:: ALGSTR_0:exreg 14
registration
  cluster non empty trivial strict multLoopStr_0;
end;

:: ALGSTR_0:funcnot 11 => ALGSTR_0:func 11
definition
  let a1 be multLoopStr_0;
  let a2 be Element of the carrier of a1;
  func A2 " -> Element of the carrier of a1 means
    it * a2 = 1. a1
    if a2 is left_invertible(a1) & a2 is right_mult-cancelable(a1)
    otherwise it = 0. a1;
end;

:: ALGSTR_0:def 35
theorem
for b1 being multLoopStr_0
for b2, b3 being Element of the carrier of b1 holds
(b2 is left_invertible(b1) & b2 is right_mult-cancelable(b1) implies    (b3 = b2 "
 iff
    b3 * b2 = 1. b1)) &
 (b2 is left_invertible(b1) & b2 is right_mult-cancelable(b1) or    (b3 = b2 "
 iff
    b3 = 0. b1));

:: ALGSTR_0:attrnot 30 => ALGSTR_0:attr 30
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_left_cancelable means
    for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is left_mult-cancelable(a1);
end;

:: ALGSTR_0:dfs 36
definiens
  let a1 be multLoopStr_0;
To prove
     a1 is almost_left_cancelable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is left_mult-cancelable(a1);

:: ALGSTR_0:def 36
theorem
for b1 being multLoopStr_0 holds
      b1 is almost_left_cancelable
   iff
      for b2 being Element of the carrier of b1
            st b2 <> 0. b1
         holds b2 is left_mult-cancelable(b1);

:: ALGSTR_0:attrnot 31 => ALGSTR_0:attr 31
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_right_cancelable means
    for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is right_mult-cancelable(a1);
end;

:: ALGSTR_0:dfs 37
definiens
  let a1 be multLoopStr_0;
To prove
     a1 is almost_right_cancelable
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is right_mult-cancelable(a1);

:: ALGSTR_0:def 37
theorem
for b1 being multLoopStr_0 holds
      b1 is almost_right_cancelable
   iff
      for b2 being Element of the carrier of b1
            st b2 <> 0. b1
         holds b2 is right_mult-cancelable(b1);

:: ALGSTR_0:attrnot 32 => ALGSTR_0:attr 32
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_cancelable means
    a1 is almost_left_cancelable & a1 is almost_right_cancelable;
end;

:: ALGSTR_0:dfs 38
definiens
  let a1 be multLoopStr_0;
To prove
     a1 is almost_cancelable
it is sufficient to prove
  thus a1 is almost_left_cancelable & a1 is almost_right_cancelable;

:: ALGSTR_0:def 38
theorem
for b1 being multLoopStr_0 holds
      b1 is almost_cancelable
   iff
      b1 is almost_left_cancelable & b1 is almost_right_cancelable;

:: ALGSTR_0:condreg 25
registration
  cluster almost_left_cancelable almost_right_cancelable -> almost_cancelable (multLoopStr_0);
end;

:: ALGSTR_0:condreg 26
registration
  cluster almost_cancelable -> almost_left_cancelable almost_right_cancelable (multLoopStr_0);
end;

:: ALGSTR_0:funcreg 27
registration
  cluster Trivial-multLoopStr_0 -> almost_cancelable;
end;

:: ALGSTR_0:exreg 15
registration
  cluster non empty trivial strict almost_cancelable multLoopStr_0;
end;

:: ALGSTR_0:attrnot 33 => ALGSTR_0:attr 33
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_left_invertible means
    for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is left_invertible(a1);
end;

:: ALGSTR_0:dfs 39
definiens
  let a1 be multLoopStr_0;
To prove
     a1 is almost_left_invertible
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is left_invertible(a1);

:: ALGSTR_0:def 39
theorem
for b1 being multLoopStr_0 holds
      b1 is almost_left_invertible
   iff
      for b2 being Element of the carrier of b1
            st b2 <> 0. b1
         holds b2 is left_invertible(b1);

:: ALGSTR_0:attrnot 34 => ALGSTR_0:attr 34
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_right_invertible means
    for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is right_invertible(a1);
end;

:: ALGSTR_0:dfs 40
definiens
  let a1 be multLoopStr_0;
To prove
     a1 is almost_right_invertible
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds b1 is right_invertible(a1);

:: ALGSTR_0:def 40
theorem
for b1 being multLoopStr_0 holds
      b1 is almost_right_invertible
   iff
      for b2 being Element of the carrier of b1
            st b2 <> 0. b1
         holds b2 is right_invertible(b1);

:: ALGSTR_0:attrnot 35 => ALGSTR_0:attr 35
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_invertible means
    a1 is almost_right_invertible & a1 is almost_left_invertible;
end;

:: ALGSTR_0:dfs 41
definiens
  let a1 be multLoopStr_0;
To prove
     a1 is almost_invertible
it is sufficient to prove
  thus a1 is almost_right_invertible & a1 is almost_left_invertible;

:: ALGSTR_0:def 41
theorem
for b1 being multLoopStr_0 holds
      b1 is almost_invertible
   iff
      b1 is almost_right_invertible & b1 is almost_left_invertible;

:: ALGSTR_0:condreg 27
registration
  cluster almost_left_invertible almost_right_invertible -> almost_invertible (multLoopStr_0);
end;

:: ALGSTR_0:condreg 28
registration
  cluster almost_invertible -> almost_left_invertible almost_right_invertible (multLoopStr_0);
end;

:: ALGSTR_0:funcreg 28
registration
  cluster Trivial-multLoopStr_0 -> almost_invertible;
end;

:: ALGSTR_0:exreg 16
registration
  cluster non empty trivial strict almost_cancelable almost_invertible multLoopStr_0;
end;

:: ALGSTR_0:structnot 6 => ALGSTR_0:struct 6
definition
  struct(addLoopStrmultLoopStr_0) doubleLoopStr(#
    carrier -> set,
    addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    OneF -> Element of the carrier of it,
    ZeroF -> Element of the carrier of it
  #);
end;

:: ALGSTR_0:attrnot 36 => ALGSTR_0:attr 36
definition
  let a1 be doubleLoopStr;
  attr a1 is strict;
end;

:: ALGSTR_0:exreg 17
registration
  cluster strict doubleLoopStr;
end;

:: ALGSTR_0:aggrnot 6 => ALGSTR_0:aggr 6
definition
  let a1 be set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5 be Element of a1;
  aggr doubleLoopStr(#a1,a2,a3,a4,a5#) -> strict doubleLoopStr;
end;

:: ALGSTR_0:funcreg 29
registration
  let a1 be non empty set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5 be Element of a1;
  cluster doubleLoopStr(#a1,a2,a3,a4,a5#) -> non empty strict;
end;

:: ALGSTR_0:funcreg 30
registration
  let a1 be trivial set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5 be Element of a1;
  cluster doubleLoopStr(#a1,a2,a3,a4,a5#) -> trivial strict;
end;

:: ALGSTR_0:funcreg 31
registration
  let a1 be non trivial set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5 be Element of a1;
  cluster doubleLoopStr(#a1,a2,a3,a4,a5#) -> non trivial strict;
end;

:: ALGSTR_0:funcnot 12 => ALGSTR_0:func 12
definition
  func Trivial-doubleLoopStr -> doubleLoopStr equals
    doubleLoopStr(#1,op2,op2,op0,op0#);
end;

:: ALGSTR_0:def 42
theorem
Trivial-doubleLoopStr = doubleLoopStr(#1,op2,op2,op0,op0#);

:: ALGSTR_0:funcreg 32
registration
  cluster Trivial-doubleLoopStr -> non empty trivial strict;
end;

:: ALGSTR_0:exreg 18
registration
  cluster non empty trivial strict doubleLoopStr;
end;