Article ALGSTR_1, MML version 4.99.1005

:: ALGSTR_1:th 1
theorem
for b1 being non empty addLoopStr
for b2, b3 being Element of the carrier of b1
      st (for b4 being Element of the carrier of b1 holds
            b4 + 0. b1 = b4) &
         (for b4 being Element of the carrier of b1 holds
            ex b5 being Element of the carrier of b1 st
               b4 + b5 = 0. b1) &
         (for b4, b5, b6 being Element of the carrier of b1 holds
         (b4 + b5) + b6 = b4 + (b5 + b6)) &
         b2 + b3 = 0. b1
   holds b3 + b2 = 0. b1;

:: ALGSTR_1:th 2
theorem
for b1 being non empty addLoopStr
for b2 being Element of the carrier of b1
      st (for b3 being Element of the carrier of b1 holds
            b3 + 0. b1 = b3) &
         (for b3 being Element of the carrier of b1 holds
            ex b4 being Element of the carrier of b1 st
               b3 + b4 = 0. b1) &
         (for b3, b4, b5 being Element of the carrier of b1 holds
         (b3 + b4) + b5 = b3 + (b4 + b5))
   holds (0. b1) + b2 = b2 + 0. b1;

:: ALGSTR_1:th 3
theorem
for b1 being non empty addLoopStr
   st (for b2 being Element of the carrier of b1 holds
         b2 + 0. b1 = b2) &
      (for b2 being Element of the carrier of b1 holds
         ex b3 being Element of the carrier of b1 st
            b2 + b3 = 0. b1) &
      (for b2, b3, b4 being Element of the carrier of b1 holds
      (b2 + b3) + b4 = b2 + (b3 + b4))
for b2 being Element of the carrier of b1 holds
   ex b3 being Element of the carrier of b1 st
      b3 + b2 = 0. b1;

:: ALGSTR_1:funcnot 1 => ALGSTR_1:func 1
definition
  let a1 be set;
  func Extract A1 -> Element of {a1} equals
    a1;
end;

:: ALGSTR_1:def 3
theorem
for b1 being set holds
   Extract b1 = b1;

:: ALGSTR_1:th 5
theorem
for b1, b2 being Element of the carrier of Trivial-addLoopStr holds
b1 = b2;

:: ALGSTR_1:th 6
theorem
for b1, b2 being Element of the carrier of Trivial-addLoopStr holds
b1 + b2 = 0. Trivial-addLoopStr;

:: ALGSTR_1:attrnot 1 => ALGSTR_1:attr 1
definition
  let a1 be non empty addLoopStr;
  attr a1 is left_zeroed means
    for b1 being Element of the carrier of a1 holds
       (0. a1) + b1 = b1;
end;

:: ALGSTR_1:dfs 2
definiens
  let a1 be non empty addLoopStr;
To prove
     a1 is left_zeroed
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (0. a1) + b1 = b1;

:: ALGSTR_1:def 5
theorem
for b1 being non empty addLoopStr holds
      b1 is left_zeroed
   iff
      for b2 being Element of the carrier of b1 holds
         (0. b1) + b2 = b2;

:: ALGSTR_1:attrnot 2 => ALGSTR_1:attr 2
definition
  let a1 be non empty addLoopStr;
  attr a1 is add-left-invertible means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b3 + b1 = b2;
end;

:: ALGSTR_1:dfs 3
definiens
  let a1 be non empty addLoopStr;
To prove
     a1 is add-left-invertible
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b3 + b1 = b2;

:: ALGSTR_1:def 8
theorem
for b1 being non empty addLoopStr holds
      b1 is add-left-invertible
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being Element of the carrier of b1 st
         b4 + b2 = b3;

:: ALGSTR_1:attrnot 3 => ALGSTR_1:attr 3
definition
  let a1 be non empty addLoopStr;
  attr a1 is add-right-invertible means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 + b3 = b2;
end;

:: ALGSTR_1:dfs 4
definiens
  let a1 be non empty addLoopStr;
To prove
     a1 is add-right-invertible
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 + b3 = b2;

:: ALGSTR_1:def 9
theorem
for b1 being non empty addLoopStr holds
      b1 is add-right-invertible
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being Element of the carrier of b1 st
         b2 + b4 = b3;

:: ALGSTR_1:attrnot 4 => ALGSTR_1:attr 4
definition
  let a1 be non empty addLoopStr;
  attr a1 is Loop-like means
    a1 is left_add-cancelable & a1 is right_add-cancelable & a1 is add-left-invertible & a1 is add-right-invertible;
end;

:: ALGSTR_1:dfs 5
definiens
  let a1 be non empty addLoopStr;
To prove
     a1 is Loop-like
it is sufficient to prove
  thus a1 is left_add-cancelable & a1 is right_add-cancelable & a1 is add-left-invertible & a1 is add-right-invertible;

:: ALGSTR_1:def 12
theorem
for b1 being non empty addLoopStr holds
      b1 is Loop-like
   iff
      b1 is left_add-cancelable & b1 is right_add-cancelable & b1 is add-left-invertible & b1 is add-right-invertible;

:: ALGSTR_1:condreg 1
registration
  cluster non empty Loop-like -> left_add-cancelable right_add-cancelable add-left-invertible add-right-invertible (addLoopStr);
end;

:: ALGSTR_1:condreg 2
registration
  cluster non empty left_add-cancelable right_add-cancelable add-left-invertible add-right-invertible -> Loop-like (addLoopStr);
end;

:: ALGSTR_1:th 7
theorem
for b1 being non empty addLoopStr holds
      b1 is Loop-like
   iff
      (for b2, b3 being Element of the carrier of b1 holds
       ex b4 being Element of the carrier of b1 st
          b2 + b4 = b3) &
       (for b2, b3 being Element of the carrier of b1 holds
       ex b4 being Element of the carrier of b1 st
          b4 + b2 = b3) &
       (for b2, b3, b4 being Element of the carrier of b1
             st b2 + b3 = b2 + b4
          holds b3 = b4) &
       (for b2, b3, b4 being Element of the carrier of b1
             st b3 + b2 = b4 + b2
          holds b3 = b4);

:: ALGSTR_1:funcreg 1
registration
  cluster Trivial-addLoopStr -> add-associative right_zeroed left_zeroed Loop-like;
end;

:: ALGSTR_1:exreg 1
registration
  cluster non empty strict right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: ALGSTR_1:modenot 1
definition
  mode Loop is non empty right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: ALGSTR_1:exreg 2
registration
  cluster non empty left_add-cancelable right_add-cancelable add-cancelable strict add-associative right_zeroed left_zeroed add-left-invertible add-right-invertible Loop-like addLoopStr;
end;

:: ALGSTR_1:modenot 2
definition
  mode AddGroup is non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: ALGSTR_1:condreg 3
registration
  cluster non empty Loop-like -> add-left-invertible (addLoopStr);
end;

:: ALGSTR_1:condreg 4
registration
  cluster non empty right_complementable add-associative right_zeroed -> left_zeroed Loop-like (addLoopStr);
end;

:: ALGSTR_1:th 9
theorem
for b1 being non empty addLoopStr holds
      b1 is non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
   iff
      (for b2 being Element of the carrier of b1 holds
          b2 + 0. b1 = b2) &
       (for b2 being Element of the carrier of b1 holds
          ex b3 being Element of the carrier of b1 st
             b2 + b3 = 0. b1) &
       (for b2, b3, b4 being Element of the carrier of b1 holds
       (b2 + b3) + b4 = b2 + (b3 + b4));

:: ALGSTR_1:funcreg 2
registration
  cluster Trivial-addLoopStr -> Abelian;
end;

:: ALGSTR_1:exreg 3
registration
  cluster non empty left_add-cancelable right_add-cancelable add-cancelable strict Abelian add-associative right_zeroed left_zeroed add-left-invertible add-right-invertible Loop-like addLoopStr;
end;

:: ALGSTR_1:th 11
theorem
for b1 being non empty addLoopStr holds
      b1 is non empty Abelian add-associative right_zeroed left_zeroed Loop-like addLoopStr
   iff
      (for b2 being Element of the carrier of b1 holds
          b2 + 0. b1 = b2) &
       (for b2 being Element of the carrier of b1 holds
          ex b3 being Element of the carrier of b1 st
             b2 + b3 = 0. b1) &
       (for b2, b3, b4 being Element of the carrier of b1 holds
       (b2 + b3) + b4 = b2 + (b3 + b4)) &
       (for b2, b3 being Element of the carrier of b1 holds
       b2 + b3 = b3 + b2);

:: ALGSTR_1:funcreg 3
registration
  cluster Trivial-multLoopStr -> non empty;
end;

:: ALGSTR_1:th 18
theorem
for b1, b2 being Element of the carrier of Trivial-multLoopStr holds
b1 = b2;

:: ALGSTR_1:th 19
theorem
for b1, b2 being Element of the carrier of Trivial-multLoopStr holds
b1 * b2 = 1. Trivial-multLoopStr;

:: ALGSTR_1:attrnot 5 => ALGSTR_1:attr 5
definition
  let a1 be non empty multLoopStr;
  attr a1 is invertible means
    (for b1, b2 being Element of the carrier of a1 holds
     ex b3 being Element of the carrier of a1 st
        b1 * b3 = b2) &
     (for b1, b2 being Element of the carrier of a1 holds
     ex b3 being Element of the carrier of a1 st
        b3 * b1 = b2);
end;

:: ALGSTR_1:dfs 6
definiens
  let a1 be non empty multLoopStr;
To prove
     a1 is invertible
it is sufficient to prove
  thus (for b1, b2 being Element of the carrier of a1 holds
     ex b3 being Element of the carrier of a1 st
        b1 * b3 = b2) &
     (for b1, b2 being Element of the carrier of a1 holds
     ex b3 being Element of the carrier of a1 st
        b3 * b1 = b2);

:: ALGSTR_1:def 14
theorem
for b1 being non empty multLoopStr holds
      b1 is invertible
   iff
      (for b2, b3 being Element of the carrier of b1 holds
       ex b4 being Element of the carrier of b1 st
          b2 * b4 = b3) &
       (for b2, b3 being Element of the carrier of b1 holds
       ex b4 being Element of the carrier of b1 st
          b4 * b2 = b3);

:: ALGSTR_1:attrnot 6 => ALGSTR_0:attr 21
notation
  let a1 be non empty multLoopStr;
  synonym cancelable for mult-cancelable;
end;

:: ALGSTR_1:exreg 4
registration
  cluster non empty mult-cancelable strict well-unital invertible multLoopStr;
end;

:: ALGSTR_1:modenot 3
definition
  mode multLoop is non empty mult-cancelable well-unital invertible multLoopStr;
end;

:: ALGSTR_1:funcreg 4
registration
  cluster Trivial-multLoopStr -> mult-cancelable well-unital invertible;
end;

:: ALGSTR_1:exreg 5
registration
  cluster non empty left_mult-cancelable right_mult-cancelable mult-cancelable strict unital associative right_unital well-unital left_unital invertible multLoopStr;
end;

:: ALGSTR_1:modenot 4
definition
  mode multGroup is non empty mult-cancelable associative well-unital invertible multLoopStr;
end;

:: ALGSTR_1:th 22
theorem
for b1 being non empty multLoopStr holds
      b1 is non empty mult-cancelable associative well-unital invertible multLoopStr
   iff
      (for b2 being Element of the carrier of b1 holds
          b2 * 1. b1 = b2) &
       (for b2 being Element of the carrier of b1 holds
          ex b3 being Element of the carrier of b1 st
             b2 * b3 = 1. b1) &
       (for b2, b3, b4 being Element of the carrier of b1 holds
       (b2 * b3) * b4 = b2 * (b3 * b4));

:: ALGSTR_1:funcreg 5
registration
  cluster Trivial-multLoopStr -> associative;
end;

:: ALGSTR_1:exreg 6
registration
  cluster non empty left_mult-cancelable right_mult-cancelable mult-cancelable strict unital associative commutative right_unital well-unital left_unital invertible multLoopStr;
end;

:: ALGSTR_1:th 24
theorem
for b1 being non empty multLoopStr holds
      b1 is non empty mult-cancelable associative commutative well-unital invertible multLoopStr
   iff
      (for b2 being Element of the carrier of b1 holds
          b2 * 1. b1 = b2) &
       (for b2 being Element of the carrier of b1 holds
          ex b3 being Element of the carrier of b1 st
             b2 * b3 = 1. b1) &
       (for b2, b3, b4 being Element of the carrier of b1 holds
       (b2 * b3) * b4 = b2 * (b3 * b4)) &
       (for b2, b3 being Element of the carrier of b1 holds
       b2 * b3 = b3 * b2);

:: ALGSTR_1:funcnot 2 => ALGSTR_0:func 9
notation
  let a1 be non empty mult-cancelable invertible multLoopStr;
  let a2 be Element of the carrier of a1;
  synonym a2 " for / a2;
end;

:: ALGSTR_1:condreg 5
registration
  let a1 be non empty mult-cancelable invertible multLoopStr;
  cluster -> left_invertible (Element of the carrier of a1);
end;

:: ALGSTR_1:th 26
theorem
for b1 being non empty mult-cancelable associative well-unital invertible multLoopStr
for b2 being Element of the carrier of b1 holds
   (/ b2) * b2 = 1. b1 & b2 * / b2 = 1. b1;

:: ALGSTR_1:funcnot 3 => ALGSTR_1:func 2
definition
  let a1 be non empty mult-cancelable invertible multLoopStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 / A3 -> Element of the carrier of a1 equals
    a2 * / a3;
end;

:: ALGSTR_1:def 19
theorem
for b1 being non empty mult-cancelable invertible multLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 / b3 = b2 * / b3;

:: ALGSTR_1:funcnot 4 => ALGSTR_1:func 3
definition
  func multEX_0 -> strict multLoopStr_0 equals
    multLoopStr_0(#REAL,multreal,0,1#);
end;

:: ALGSTR_1:def 23
theorem
multEX_0 = multLoopStr_0(#REAL,multreal,0,1#);

:: ALGSTR_1:funcreg 6
registration
  cluster multEX_0 -> non empty strict;
end;

:: ALGSTR_1:funcreg 7
registration
  cluster multEX_0 -> strict well-unital;
end;

:: ALGSTR_1:th 32
theorem
for b1, b2 being Element of REAL
      st b1 <> 0
   holds ex b3 being Element of REAL st
      b2 = b1 * b3;

:: ALGSTR_1:th 33
theorem
for b1, b2 being Element of REAL
      st b1 <> 0
   holds ex b3 being Element of REAL st
      b2 = b3 * b1;

:: ALGSTR_1:attrnot 7 => ALGSTR_1:attr 6
definition
  let a1 be non empty multLoopStr_0;
  attr a1 is almost_invertible means
    (for b1, b2 being Element of the carrier of a1
           st b1 <> 0. a1
        holds ex b3 being Element of the carrier of a1 st
           b1 * b3 = b2) &
     (for b1, b2 being Element of the carrier of a1
           st b1 <> 0. a1
        holds ex b3 being Element of the carrier of a1 st
           b3 * b1 = b2);
end;

:: ALGSTR_1:dfs 9
definiens
  let a1 be non empty multLoopStr_0;
To prove
     a1 is almost_invertible
it is sufficient to prove
  thus (for b1, b2 being Element of the carrier of a1
           st b1 <> 0. a1
        holds ex b3 being Element of the carrier of a1 st
           b1 * b3 = b2) &
     (for b1, b2 being Element of the carrier of a1
           st b1 <> 0. a1
        holds ex b3 being Element of the carrier of a1 st
           b3 * b1 = b2);

:: ALGSTR_1:def 24
theorem
for b1 being non empty multLoopStr_0 holds
      b1 is almost_invertible
   iff
      (for b2, b3 being Element of the carrier of b1
             st b2 <> 0. b1
          holds ex b4 being Element of the carrier of b1 st
             b2 * b4 = b3) &
       (for b2, b3 being Element of the carrier of b1
             st b2 <> 0. b1
          holds ex b4 being Element of the carrier of b1 st
             b4 * b2 = b3);

:: ALGSTR_1:attrnot 8 => ALGSTR_1:attr 7
definition
  let a1 be non empty multLoopStr_0;
  attr a1 is multLoop_0-like means
    a1 is almost_invertible &
     a1 is almost_cancelable &
     (for b1 being Element of the carrier of a1 holds
        b1 * 0. a1 = 0. a1) &
     (for b1 being Element of the carrier of a1 holds
        (0. a1) * b1 = 0. a1);
end;

:: ALGSTR_1:dfs 10
definiens
  let a1 be non empty multLoopStr_0;
To prove
     a1 is multLoop_0-like
it is sufficient to prove
  thus a1 is almost_invertible &
     a1 is almost_cancelable &
     (for b1 being Element of the carrier of a1 holds
        b1 * 0. a1 = 0. a1) &
     (for b1 being Element of the carrier of a1 holds
        (0. a1) * b1 = 0. a1);

:: ALGSTR_1:def 26
theorem
for b1 being non empty multLoopStr_0 holds
      b1 is multLoop_0-like
   iff
      b1 is almost_invertible &
       b1 is almost_cancelable &
       (for b2 being Element of the carrier of b1 holds
          b2 * 0. b1 = 0. b1) &
       (for b2 being Element of the carrier of b1 holds
          (0. b1) * b2 = 0. b1);

:: ALGSTR_1:th 34
theorem
for b1 being non empty multLoopStr_0 holds
      b1 is multLoop_0-like
   iff
      (for b2, b3 being Element of the carrier of b1
             st b2 <> 0. b1
          holds ex b4 being Element of the carrier of b1 st
             b2 * b4 = b3) &
       (for b2, b3 being Element of the carrier of b1
             st b2 <> 0. b1
          holds ex b4 being Element of the carrier of b1 st
             b4 * b2 = b3) &
       (for b2, b3, b4 being Element of the carrier of b1
             st b2 <> 0. b1 & b2 * b3 = b2 * b4
          holds b3 = b4) &
       (for b2, b3, b4 being Element of the carrier of b1
             st b2 <> 0. b1 & b3 * b2 = b4 * b2
          holds b3 = b4) &
       (for b2 being Element of the carrier of b1 holds
          b2 * 0. b1 = 0. b1) &
       (for b2 being Element of the carrier of b1 holds
          (0. b1) * b2 = 0. b1);

:: ALGSTR_1:condreg 6
registration
  cluster non empty multLoop_0-like -> almost_cancelable almost_invertible (multLoopStr_0);
end;

:: ALGSTR_1:exreg 7
registration
  cluster non empty non degenerated strict well-unital multLoop_0-like multLoopStr_0;
end;

:: ALGSTR_1:modenot 5
definition
  mode multLoop_0 is non empty non degenerated well-unital multLoop_0-like multLoopStr_0;
end;

:: ALGSTR_1:funcreg 8
registration
  cluster multEX_0 -> strict well-unital multLoop_0-like;
end;

:: ALGSTR_1:exreg 8
registration
  cluster non empty non degenerated strict almost_left_cancelable almost_right_cancelable almost_cancelable unital associative right_unital well-unital left_unital almost_invertible multLoop_0-like multLoopStr_0;
end;

:: ALGSTR_1:modenot 6
definition
  mode multGroup_0 is non empty non degenerated associative well-unital multLoop_0-like multLoopStr_0;
end;

:: ALGSTR_1:funcreg 9
registration
  cluster multEX_0 -> strict associative;
end;

:: ALGSTR_1:exreg 9
registration
  cluster non empty non degenerated strict almost_left_cancelable almost_right_cancelable almost_cancelable unital associative commutative right_unital well-unital left_unital almost_invertible multLoop_0-like multLoopStr_0;
end;

:: ALGSTR_1:funcnot 5 => ALGSTR_0:func 11
definition
  let a1 be multLoopStr_0;
  let a2 be Element of the carrier of a1;
  assume a2 <> 0. a1;
  func A2 " -> Element of the carrier of a1 means
    it * a2 = 1. a1;
end;

:: ALGSTR_1:def 27
theorem
for b1 being non empty almost_cancelable almost_invertible multLoopStr_0
for b2 being Element of the carrier of b1
   st b2 <> 0. b1
for b3 being Element of the carrier of b1 holds
      b3 = b2 "
   iff
      b3 * b2 = 1. b1;

:: ALGSTR_1:th 40
theorem
for b1 being non empty almost_cancelable associative well-unital almost_invertible multLoopStr_0
for b2 being Element of the carrier of b1
      st b2 <> 0. b1
   holds b2 " * b2 = 1. b1 & b2 * (b2 ") = 1. b1;

:: ALGSTR_1:funcnot 6 => ALGSTR_1:func 4
definition
  let a1 be non empty almost_cancelable almost_invertible multLoopStr_0;
  let a2, a3 be Element of the carrier of a1;
  func A2 / A3 -> Element of the carrier of a1 equals
    a2 * (a3 ");
end;

:: ALGSTR_1:def 28
theorem
for b1 being non empty almost_cancelable almost_invertible multLoopStr_0
for b2, b3 being Element of the carrier of b1 holds
b2 / b3 = b2 * (b3 ");