Article QUATERNI, MML version 4.99.1005

:: QUATERNI:funcnot 1 => QUATERNI:func 1
definition
  func QUATERNION -> set equals
    ((Funcs(4,REAL)) \ {b1 where b1 is Element of Funcs(4,REAL): b1 . 2 = 0 & b1 . 3 = 0}) \/ COMPLEX;
end;

:: QUATERNI:def 1
theorem
QUATERNION = ((Funcs(4,REAL)) \ {b1 where b1 is Element of Funcs(4,REAL): b1 . 2 = 0 & b1 . 3 = 0}) \/ COMPLEX;

:: QUATERNI:attrnot 1 => QUATERNI:attr 1
definition
  let a1 be set;
  attr a1 is quaternion means
    a1 in QUATERNION;
end;

:: QUATERNI:dfs 2
definiens
  let a1 be set;
To prove
     a1 is quaternion
it is sufficient to prove
  thus a1 in QUATERNION;

:: QUATERNI:def 2
theorem
for b1 being set holds
      b1 is quaternion
   iff
      b1 in QUATERNION;

:: QUATERNI:funcreg 1
registration
  cluster QUATERNION -> non empty;
end;

:: QUATERNI:funcnot 2 => QUATERNI:func 2
definition
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  func (A1,A2,A3,A4)-->(A5,A6,A7,A8) -> set equals
    ((a1,a2)-->(a5,a6)) +* ((a3,a4)-->(a7,a8));
end;

:: QUATERNI:def 3
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
(b1,b2,b3,b4)-->(b5,b6,b7,b8) = ((b1,b2)-->(b5,b6)) +* ((b3,b4)-->(b7,b8));

:: QUATERNI:funcreg 2
registration
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  cluster (a1,a2,a3,a4)-->(a5,a6,a7,a8) -> Relation-like Function-like;
end;

:: QUATERNI:th 1
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
proj1 ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) = {b1,b2,b3,b4};

:: QUATERNI:th 2
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
proj2 ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) c= {b5,b6,b7,b8};

:: QUATERNI:th 3
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set
      st b1,b2,b3,b4 are_mutually_different
   holds ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) . b1 = b5 & ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) . b2 = b6 & ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) . b3 = b7 & ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) . b4 = b8;

:: QUATERNI:th 4
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set
      st b1,b2,b3,b4 are_mutually_different
   holds proj2 ((b1,b2,b3,b4)-->(b5,b6,b7,b8)) = {b5,b6,b7,b8};

:: QUATERNI:th 5
theorem
for b1, b2, b3, b4, b5 being set holds
   {b1,b2,b3,b4} c= b5
iff
   b1 in b5 & b2 in b5 & b3 in b5 & b4 in b5;

:: QUATERNI:funcnot 3 => QUATERNI:func 3
definition
  let a1 be non empty set;
  let a2, a3, a4, a5 be set;
  let a6, a7, a8, a9 be Element of a1;
  redefine func (a2,a3,a4,a5)-->(a6,a7,a8,a9) -> Function-like quasi_total Relation of {a2,a3,a4,a5},a1;
end;

:: QUATERNI:funcnot 4 => QUATERNI:func 4
definition
  func <j> -> set equals
    (0,1,2,3)-->(0,0,1,0);
end;

:: QUATERNI:def 4
theorem
<j> = (0,1,2,3)-->(0,0,1,0);

:: QUATERNI:funcnot 5 => QUATERNI:func 5
definition
  func <k> -> set equals
    (0,1,2,3)-->(0,0,0,1);
end;

:: QUATERNI:def 5
theorem
<k> = (0,1,2,3)-->(0,0,0,1);

:: QUATERNI:funcreg 3
registration
  cluster <i> -> quaternion;
end;

:: QUATERNI:funcreg 4
registration
  cluster <j> -> quaternion;
end;

:: QUATERNI:funcreg 5
registration
  cluster <k> -> quaternion;
end;

:: QUATERNI:exreg 1
registration
  cluster quaternion set;
end;

:: QUATERNI:condreg 1
registration
  cluster -> quaternion (Element of QUATERNION);
end;

:: QUATERNI:funcnot 6 => QUATERNI:func 6
definition
  let a1, a2, a3, a4 be Element of REAL;
  func [*A1,A2,A3,A4*] -> Element of QUATERNION equals
    [*a1,a2*]
    if a3 = 0 & a4 = 0
    otherwise (0,1,2,3)-->(a1,a2,a3,a4);
end;

:: QUATERNI:def 6
theorem
for b1, b2, b3, b4 being Element of REAL holds
(b3 = 0 & b4 = 0 implies [*b1,b2,b3,b4*] = [*b1,b2*]) &
 (b3 = 0 & b4 = 0 or [*b1,b2,b3,b4*] = (0,1,2,3)-->(b1,b2,b3,b4));

:: QUATERNI:th 6
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set
for b9 being Relation-like Function-like set
      st b1 <> b2 & b3 <> b4 & proj1 b9 = {b1,b2,b3,b4} & b9 . b1 = b5 & b9 . b2 = b6 & b9 . b3 = b7 & b9 . b4 = b8
   holds b9 = (b1,b2,b3,b4)-->(b5,b6,b7,b8);

:: QUATERNI:th 7
theorem
for b1 being Element of QUATERNION holds
   ex b2, b3, b4, b5 being Element of REAL st
      b1 = [*b2,b3,b4,b5*];

:: QUATERNI:th 8
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set
      st b1,b2,b3,b4 are_mutually_different
   holds (b1,b2,b3,b4)-->(b5,b6,b7,b8) = {[b1,b5],[b2,b6],[b3,b7],[b4,b8]};

:: QUATERNI:th 9
theorem
for b1 being Element of bool RAT+
      st (ex b2 being Element of RAT+ st
            b2 in b1 & b2 <> {}) &
         (for b2, b3 being Element of RAT+
               st b2 in b1 & b3 <=' b2
            holds b3 in b1)
   holds ex b2, b3, b4, b5, b6 being Element of RAT+ st
      b2 in b1 & b3 in b1 & b4 in b1 & b5 in b1 & b6 in b1 & b2 <> b3 & b2 <> b4 & b2 <> b5 & b2 <> b6 & b3 <> b4 & b3 <> b5 & b3 <> b6 & b4 <> b5 & b4 <> b6 & b5 <> b6;

:: QUATERNI:th 10
theorem
for b1, b2, b3, b4 being Element of REAL holds
not (0,1,2,3)-->(b1,b2,b3,b4) in COMPLEX;

:: QUATERNI:th 11
theorem
for b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12 being set
      st b1,b2,b3,b4 are_mutually_different &
         (b1,b2,b3,b4)-->(b5,b6,b7,b8) = (b1,b2,b3,b4)-->(b9,b10,b11,b12)
   holds b5 = b9 & b6 = b10 & b7 = b11 & b8 = b12;

:: QUATERNI:th 12
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being Element of REAL
      st [*b1,b2,b3,b4*] = [*b5,b6,b7,b8*]
   holds b1 = b5 & b2 = b6 & b3 = b7 & b4 = b8;

:: QUATERNI:funcnot 7 => QUATERNI:func 7
definition
  let a1, a2 be quaternion set;
  func A1 + A2 -> set means
    ex b1, b2, b3, b4, b5, b6, b7, b8 being Element of REAL st
       a1 = [*b1,b2,b3,b4*] &
        a2 = [*b5,b6,b7,b8*] &
        it = [*b1 + b5,b2 + b6,b3 + b7,b4 + b8*];
  commutativity;
::  for a1, a2 being quaternion set holds
::  a1 + a2 = a2 + a1;
end;

:: QUATERNI:def 7
theorem
for b1, b2 being quaternion set
for b3 being set holds
      b3 = b1 + b2
   iff
      ex b4, b5, b6, b7, b8, b9, b10, b11 being Element of REAL st
         b1 = [*b4,b5,b6,b7*] &
          b2 = [*b8,b9,b10,b11*] &
          b3 = [*b4 + b8,b5 + b9,b6 + b10,b7 + b11*];

:: QUATERNI:funcnot 8 => QUATERNI:func 8
definition
  let a1 be quaternion set;
  func - A1 -> quaternion set means
    a1 + it = 0;
  involutiveness;
::  for a1 being quaternion set holds
::     - - a1 = a1;
end;

:: QUATERNI:def 8
theorem
for b1, b2 being quaternion set holds
   b2 = - b1
iff
   b1 + b2 = 0;

:: QUATERNI:funcnot 9 => QUATERNI:func 9
definition
  let a1, a2 be quaternion set;
  func A1 - A2 -> set equals
    a1 + - a2;
end;

:: QUATERNI:def 9
theorem
for b1, b2 being quaternion set holds
b1 - b2 = b1 + - b2;

:: QUATERNI:funcnot 10 => QUATERNI:func 10
definition
  let a1, a2 be quaternion set;
  func A1 * A2 -> set means
    ex b1, b2, b3, b4, b5, b6, b7, b8 being Element of REAL st
       a1 = [*b1,b2,b3,b4*] &
        a2 = [*b5,b6,b7,b8*] &
        it = [*(((b1 * b5) - (b2 * b6)) - (b3 * b7)) - (b4 * b8),(((b1 * b6) + (b2 * b5)) + (b3 * b8)) - (b4 * b7),(((b1 * b7) + (b5 * b3)) + (b6 * b4)) - (b8 * b2),(((b1 * b8) + (b4 * b5)) + (b2 * b7)) - (b3 * b6)*];
end;

:: QUATERNI:def 10
theorem
for b1, b2 being quaternion set
for b3 being set holds
      b3 = b1 * b2
   iff
      ex b4, b5, b6, b7, b8, b9, b10, b11 being Element of REAL st
         b1 = [*b4,b5,b6,b7*] &
          b2 = [*b8,b9,b10,b11*] &
          b3 = [*(((b4 * b8) - (b5 * b9)) - (b6 * b10)) - (b7 * b11),(((b4 * b9) + (b5 * b8)) + (b6 * b11)) - (b7 * b10),(((b4 * b10) + (b8 * b6)) + (b9 * b7)) - (b11 * b5),(((b4 * b11) + (b7 * b8)) + (b5 * b10)) - (b6 * b9)*];

:: QUATERNI:funcreg 6
registration
  let a1, a2 be quaternion set;
  cluster a1 + a2 -> quaternion;
end;

:: QUATERNI:funcreg 7
registration
  let a1, a2 be quaternion set;
  cluster a1 * a2 -> quaternion;
end;

:: QUATERNI:funcreg 8
registration
  let a1, a2 be quaternion set;
  cluster a1 - a2 -> quaternion;
end;

:: QUATERNI:funcnot 11 => QUATERNI:func 11
definition
  redefine func <j> -> Element of QUATERNION equals
    [*0,0,1,0*];
end;

:: QUATERNI:def 11
theorem
<j> = [*0,0,1,0*];

:: QUATERNI:funcnot 12 => QUATERNI:func 12
definition
  redefine func <k> -> Element of QUATERNION equals
    [*0,0,0,1*];
end;

:: QUATERNI:def 12
theorem
<k> = [*0,0,0,1*];

:: QUATERNI:th 13
theorem
<i> * <i> = - 1;

:: QUATERNI:th 14
theorem
<j> * <j> = - 1;

:: QUATERNI:th 15
theorem
<k> * <k> = - 1;

:: QUATERNI:th 16
theorem
<i> * <j> = <k>;

:: QUATERNI:th 17
theorem
<j> * <k> = <i>;

:: QUATERNI:th 18
theorem
<k> * <i> = <j>;

:: QUATERNI:th 19
theorem
<i> * <j> = - (<j> * <i>);

:: QUATERNI:th 20
theorem
<j> * <k> = - (<k> * <j>);

:: QUATERNI:th 21
theorem
<k> * <i> = - (<i> * <k>);

:: QUATERNI:funcnot 13 => QUATERNI:func 13
definition
  let a1 be quaternion set;
  func Rea A1 -> set means
    ex b1 being complex set st
       a1 = b1 & it = Re b1
    if a1 in COMPLEX
    otherwise ex b1 being Function-like quasi_total Relation of 4,REAL st
       a1 = b1 & it = b1 . 0;
end;

:: QUATERNI:def 13
theorem
for b1 being quaternion set
for b2 being set holds
   (b1 in COMPLEX implies    (b2 = Rea b1
    iff
       ex b3 being complex set st
          b1 = b3 & b2 = Re b3)) &
    (b1 in COMPLEX or    (b2 = Rea b1
    iff
       ex b3 being Function-like quasi_total Relation of 4,REAL st
          b1 = b3 & b2 = b3 . 0));

:: QUATERNI:funcnot 14 => QUATERNI:func 14
definition
  let a1 be quaternion set;
  func Im1 A1 -> set means
    ex b1 being complex set st
       a1 = b1 & it = Im b1
    if a1 in COMPLEX
    otherwise ex b1 being Function-like quasi_total Relation of 4,REAL st
       a1 = b1 & it = b1 . 1;
end;

:: QUATERNI:def 14
theorem
for b1 being quaternion set
for b2 being set holds
   (b1 in COMPLEX implies    (b2 = Im1 b1
    iff
       ex b3 being complex set st
          b1 = b3 & b2 = Im b3)) &
    (b1 in COMPLEX or    (b2 = Im1 b1
    iff
       ex b3 being Function-like quasi_total Relation of 4,REAL st
          b1 = b3 & b2 = b3 . 1));

:: QUATERNI:funcnot 15 => QUATERNI:func 15
definition
  let a1 be quaternion set;
  func Im2 A1 -> set means
    it = 0
    if a1 in COMPLEX
    otherwise ex b1 being Function-like quasi_total Relation of 4,REAL st
       a1 = b1 & it = b1 . 2;
end;

:: QUATERNI:def 15
theorem
for b1 being quaternion set
for b2 being set holds
   (b1 in COMPLEX implies    (b2 = Im2 b1
    iff
       b2 = 0)) &
    (b1 in COMPLEX or    (b2 = Im2 b1
    iff
       ex b3 being Function-like quasi_total Relation of 4,REAL st
          b1 = b3 & b2 = b3 . 2));

:: QUATERNI:funcnot 16 => QUATERNI:func 16
definition
  let a1 be quaternion set;
  func Im3 A1 -> set means
    it = 0
    if a1 in COMPLEX
    otherwise ex b1 being Function-like quasi_total Relation of 4,REAL st
       a1 = b1 & it = b1 . 3;
end;

:: QUATERNI:def 16
theorem
for b1 being quaternion set
for b2 being set holds
   (b1 in COMPLEX implies    (b2 = Im3 b1
    iff
       b2 = 0)) &
    (b1 in COMPLEX or    (b2 = Im3 b1
    iff
       ex b3 being Function-like quasi_total Relation of 4,REAL st
          b1 = b3 & b2 = b3 . 3));

:: QUATERNI:funcreg 9
registration
  let a1 be quaternion set;
  cluster Rea a1 -> real;
end;

:: QUATERNI:funcreg 10
registration
  let a1 be quaternion set;
  cluster Im1 a1 -> real;
end;

:: QUATERNI:funcreg 11
registration
  let a1 be quaternion set;
  cluster Im2 a1 -> real;
end;

:: QUATERNI:funcreg 12
registration
  let a1 be quaternion set;
  cluster Im3 a1 -> real;
end;

:: QUATERNI:funcnot 17 => QUATERNI:func 17
definition
  let a1 be quaternion set;
  redefine func Rea a1 -> Element of REAL;
end;

:: QUATERNI:funcnot 18 => QUATERNI:func 18
definition
  let a1 be quaternion set;
  redefine func Im1 a1 -> Element of REAL;
end;

:: QUATERNI:funcnot 19 => QUATERNI:func 19
definition
  let a1 be quaternion set;
  redefine func Im2 a1 -> Element of REAL;
end;

:: QUATERNI:funcnot 20 => QUATERNI:func 20
definition
  let a1 be quaternion set;
  redefine func Im3 a1 -> Element of REAL;
end;

:: QUATERNI:th 22
theorem
for b1 being Function-like quasi_total Relation of 4,REAL holds
   ex b2, b3, b4, b5 being Element of REAL st
      b1 = (0,1,2,3)-->(b2,b3,b4,b5);

:: QUATERNI:th 23
theorem
for b1, b2, b3, b4 being Element of REAL holds
Rea [*b1,b2,b3,b4*] = b1 & Im1 [*b1,b2,b3,b4*] = b2 & Im2 [*b1,b2,b3,b4*] = b3 & Im3 [*b1,b2,b3,b4*] = b4;

:: QUATERNI:th 24
theorem
for b1 being quaternion set holds
   b1 = [*Rea b1,Im1 b1,Im2 b1,Im3 b1*];

:: QUATERNI:th 25
theorem
for b1, b2 being quaternion set
      st Rea b1 = Rea b2 & Im1 b1 = Im1 b2 & Im2 b1 = Im2 b2 & Im3 b1 = Im3 b2
   holds b1 = b2;

:: QUATERNI:funcnot 21 => QUATERNI:func 21
definition
  func 0q -> quaternion set equals
    0;
end;

:: QUATERNI:def 17
theorem
0q = 0;

:: QUATERNI:funcnot 22 => QUATERNI:func 22
definition
  func 1q -> quaternion set equals
    1;
end;

:: QUATERNI:def 18
theorem
1q = 1;

:: QUATERNI:th 26
theorem
for b1 being quaternion set
      st Rea b1 = 0 & Im1 b1 = 0 & Im2 b1 = 0 & Im3 b1 = 0
   holds b1 = 0q;

:: QUATERNI:th 27
theorem
for b1 being quaternion set
      st b1 = 0
   holds (((Rea b1) ^2 + ((Im1 b1) ^2)) + ((Im2 b1) ^2)) + ((Im3 b1) ^2) = 0;

:: QUATERNI:th 28
theorem
for b1 being quaternion set
      st (((Rea b1) ^2 + ((Im1 b1) ^2)) + ((Im2 b1) ^2)) + ((Im3 b1) ^2) = 0
   holds b1 = 0q;

:: QUATERNI:th 29
theorem
Rea 1q = 1 & Im1 1q = 0 & Im2 1q = 0 & Im3 1q = 0;

:: QUATERNI:th 30
theorem
Rea <i> = 0 & Im1 <i> = 1 & Im2 <i> = 0 & Im3 <i> = 0;

:: QUATERNI:th 31
theorem
Rea <j> = 0 & Im1 <j> = 0 & Im2 <j> = 1 & Im3 <j> = 0 & Rea <k> = 0 & Im1 <k> = 0 & Im2 <k> = 0 & Im3 <k> = 1;

:: QUATERNI:th 32
theorem
for b1, b2, b3, b4 being quaternion set holds
Rea (((b1 + b2) + b3) + b4) = (((Rea b1) + Rea b2) + Rea b3) + Rea b4 &
 Im1 (((b1 + b2) + b3) + b4) = (((Im1 b1) + Im1 b2) + Im1 b3) + Im1 b4 &
 Im2 (((b1 + b2) + b3) + b4) = (((Im2 b1) + Im2 b2) + Im2 b3) + Im2 b4 &
 Im3 (((b1 + b2) + b3) + b4) = (((Im3 b1) + Im3 b2) + Im3 b3) + Im3 b4;

:: QUATERNI:th 33
theorem
for b1 being quaternion set
for b2 being Element of REAL
      st b1 = b2
   holds Rea (b1 * <i>) = 0 & Im1 (b1 * <i>) = b2 & Im2 (b1 * <i>) = 0 & Im3 (b1 * <i>) = 0;

:: QUATERNI:th 34
theorem
for b1 being quaternion set
for b2 being Element of REAL
      st b1 = b2
   holds Rea (b1 * <j>) = 0 & Im1 (b1 * <j>) = 0 & Im2 (b1 * <j>) = b2 & Im3 (b1 * <j>) = 0;

:: QUATERNI:th 35
theorem
for b1 being quaternion set
for b2 being Element of REAL
      st b1 = b2
   holds Rea (b1 * <k>) = 0 & Im1 (b1 * <k>) = 0 & Im2 (b1 * <k>) = 0 & Im3 (b1 * <k>) = b2;

:: QUATERNI:funcnot 23 => QUATERNI:func 23
definition
  let a1 be Element of REAL;
  let a2 be quaternion set;
  func A1 + A2 -> set means
    ex b1, b2, b3, b4 being Element of REAL st
       a2 = [*b1,b2,b3,b4*] & it = [*a1 + b1,b2,b3,b4*];
end;

:: QUATERNI:def 19
theorem
for b1 being Element of REAL
for b2 being quaternion set
for b3 being set holds
      b3 = b1 + b2
   iff
      ex b4, b5, b6, b7 being Element of REAL st
         b2 = [*b4,b5,b6,b7*] & b3 = [*b1 + b4,b5,b6,b7*];

:: QUATERNI:funcnot 24 => QUATERNI:func 24
definition
  let a1 be Element of REAL;
  let a2 be quaternion set;
  func A1 - A2 -> set equals
    a1 + - a2;
end;

:: QUATERNI:def 20
theorem
for b1 being Element of REAL
for b2 being quaternion set holds
   b1 - b2 = b1 + - b2;

:: QUATERNI:funcnot 25 => QUATERNI:func 25
definition
  let a1 be Element of REAL;
  let a2 be quaternion set;
  func A1 * A2 -> set means
    ex b1, b2, b3, b4 being Element of REAL st
       a2 = [*b1,b2,b3,b4*] &
        it = [*a1 * b1,a1 * b2,a1 * b3,a1 * b4*];
end;

:: QUATERNI:def 21
theorem
for b1 being Element of REAL
for b2 being quaternion set
for b3 being set holds
      b3 = b1 * b2
   iff
      ex b4, b5, b6, b7 being Element of REAL st
         b2 = [*b4,b5,b6,b7*] &
          b3 = [*b1 * b4,b1 * b5,b1 * b6,b1 * b7*];

:: QUATERNI:funcreg 13
registration
  let a1 be Element of REAL;
  let a2 be quaternion set;
  cluster a1 + a2 -> quaternion;
end;

:: QUATERNI:funcreg 14
registration
  let a1 be Element of REAL;
  let a2 be quaternion set;
  cluster a1 * a2 -> quaternion;
end;

:: QUATERNI:funcreg 15
registration
  let a1 be Element of REAL;
  let a2 be quaternion set;
  cluster a1 - a2 -> quaternion;
end;

:: QUATERNI:funcnot 26 => QUATERNI:func 26
definition
  let a1, a2 be quaternion set;
  redefine func A1 + A2 -> Element of QUATERNION equals
    ((((Rea a1) + Rea a2) + (((Im1 a1) + Im1 a2) * <i>)) + (((Im2 a1) + Im2 a2) * <j>)) + (((Im3 a1) + Im3 a2) * <k>);
  commutativity;
::  for a1, a2 being quaternion set holds
::  a1 + a2 = a2 + a1;
end;

:: QUATERNI:def 22
theorem
for b1, b2 being quaternion set holds
b1 + b2 = ((((Rea b1) + Rea b2) + (((Im1 b1) + Im1 b2) * <i>)) + (((Im2 b1) + Im2 b2) * <j>)) + (((Im3 b1) + Im3 b2) * <k>);

:: QUATERNI:th 36
theorem
for b1, b2 being quaternion set holds
Rea (b1 + b2) = (Rea b1) + Rea b2 &
 Im1 (b1 + b2) = (Im1 b1) + Im1 b2 &
 Im2 (b1 + b2) = (Im2 b1) + Im2 b2 &
 Im3 (b1 + b2) = (Im3 b1) + Im3 b2;

:: QUATERNI:funcnot 27 => QUATERNI:func 27
definition
  let a1, a2 be Element of QUATERNION;
  redefine func A1 * A2 -> Element of QUATERNION equals
    (((((((Rea a1) * Rea a2) - ((Im1 a1) * Im1 a2)) - ((Im2 a1) * Im2 a2)) - ((Im3 a1) * Im3 a2)) + ((((((Rea a1) * Im1 a2) + ((Im1 a1) * Rea a2)) + ((Im2 a1) * Im3 a2)) - ((Im3 a1) * Im2 a2)) * <i>)) + ((((((Rea a1) * Im2 a2) + ((Im2 a1) * Rea a2)) + ((Im3 a1) * Im1 a2)) - ((Im1 a1) * Im3 a2)) * <j>)) + ((((((Rea a1) * Im3 a2) + ((Im3 a1) * Rea a2)) + ((Im1 a1) * Im2 a2)) - ((Im2 a1) * Im1 a2)) * <k>);
end;

:: QUATERNI:def 23
theorem
for b1, b2 being Element of QUATERNION holds
b1 * b2 = (((((((Rea b1) * Rea b2) - ((Im1 b1) * Im1 b2)) - ((Im2 b1) * Im2 b2)) - ((Im3 b1) * Im3 b2)) + ((((((Rea b1) * Im1 b2) + ((Im1 b1) * Rea b2)) + ((Im2 b1) * Im3 b2)) - ((Im3 b1) * Im2 b2)) * <i>)) + ((((((Rea b1) * Im2 b2) + ((Im2 b1) * Rea b2)) + ((Im3 b1) * Im1 b2)) - ((Im1 b1) * Im3 b2)) * <j>)) + ((((((Rea b1) * Im3 b2) + ((Im3 b1) * Rea b2)) + ((Im1 b1) * Im2 b2)) - ((Im2 b1) * Im1 b2)) * <k>);

:: QUATERNI:th 37
theorem
for b1 being quaternion set holds
   b1 = (((Rea b1) + ((Im1 b1) * <i>)) + ((Im2 b1) * <j>)) + ((Im3 b1) * <k>);

:: QUATERNI:th 38
theorem
for b1, b2 being quaternion set
      st Im1 b1 = 0 & Im1 b2 = 0 & Im2 b1 = 0 & Im2 b2 = 0 & Im3 b1 = 0 & Im3 b2 = 0
   holds Rea (b1 * b2) = (Rea b1) * Rea b2 &
    Im1 (b1 * b2) = ((Im2 b1) * Im3 b2) - ((Im3 b1) * Im2 b2) &
    Im2 (b1 * b2) = ((Im3 b1) * Im1 b2) - ((Im1 b1) * Im3 b2) &
    Im3 (b1 * b2) = ((Im1 b1) * Im2 b2) - ((Im2 b1) * Im1 b2);

:: QUATERNI:th 39
theorem
for b1, b2 being quaternion set
      st Rea b1 = 0 & Rea b2 = 0
   holds Rea (b1 * b2) = ((- ((Im1 b1) * Im1 b2)) - ((Im2 b1) * Im2 b2)) - ((Im3 b1) * Im3 b2) &
    Im1 (b1 * b2) = ((Im2 b1) * Im3 b2) - ((Im3 b1) * Im2 b2) &
    Im2 (b1 * b2) = ((Im3 b1) * Im1 b2) - ((Im1 b1) * Im3 b2) &
    Im3 (b1 * b2) = ((Im1 b1) * Im2 b2) - ((Im2 b1) * Im1 b2);

:: QUATERNI:th 40
theorem
for b1 being quaternion set holds
   Rea (b1 * b1) = (((Rea b1) ^2 - ((Im1 b1) ^2)) - ((Im2 b1) ^2)) - ((Im3 b1) ^2) &
    Im1 (b1 * b1) = 2 * ((Rea b1) * Im1 b1) &
    Im2 (b1 * b1) = 2 * ((Rea b1) * Im2 b1) &
    Im3 (b1 * b1) = 2 * ((Rea b1) * Im3 b1);

:: QUATERNI:funcnot 28 => QUATERNI:func 28
definition
  let a1 be quaternion set;
  redefine func - A1 -> Element of QUATERNION equals
    (((- Rea a1) + ((- Im1 a1) * <i>)) + ((- Im2 a1) * <j>)) + ((- Im3 a1) * <k>);
  involutiveness;
::  for a1 being quaternion set holds
::     - - a1 = a1;
end;

:: QUATERNI:def 24
theorem
for b1 being quaternion set holds
   - b1 = (((- Rea b1) + ((- Im1 b1) * <i>)) + ((- Im2 b1) * <j>)) + ((- Im3 b1) * <k>);

:: QUATERNI:th 41
theorem
for b1 being quaternion set holds
   Rea - b1 = - Rea b1 & Im1 - b1 = - Im1 b1 & Im2 - b1 = - Im2 b1 & Im3 - b1 = - Im3 b1;

:: QUATERNI:funcnot 29 => QUATERNI:func 29
definition
  let a1, a2 be quaternion set;
  redefine func A1 - A2 -> Element of QUATERNION equals
    ((((Rea a1) - Rea a2) + (((Im1 a1) - Im1 a2) * <i>)) + (((Im2 a1) - Im2 a2) * <j>)) + (((Im3 a1) - Im3 a2) * <k>);
end;

:: QUATERNI:def 25
theorem
for b1, b2 being quaternion set holds
b1 - b2 = ((((Rea b1) - Rea b2) + (((Im1 b1) - Im1 b2) * <i>)) + (((Im2 b1) - Im2 b2) * <j>)) + (((Im3 b1) - Im3 b2) * <k>);

:: QUATERNI:th 42
theorem
for b1, b2 being quaternion set holds
Rea (b1 - b2) = (Rea b1) - Rea b2 &
 Im1 (b1 - b2) = (Im1 b1) - Im1 b2 &
 Im2 (b1 - b2) = (Im2 b1) - Im2 b2 &
 Im3 (b1 - b2) = (Im3 b1) - Im3 b2;

:: QUATERNI:funcnot 30 => QUATERNI:func 30
definition
  let a1 be quaternion set;
  func A1 *' -> quaternion set equals
    (((Rea a1) + ((- Im1 a1) * <i>)) + ((- Im2 a1) * <j>)) + ((- Im3 a1) * <k>);
end;

:: QUATERNI:def 26
theorem
for b1 being quaternion set holds
   b1 *' = (((Rea b1) + ((- Im1 b1) * <i>)) + ((- Im2 b1) * <j>)) + ((- Im3 b1) * <k>);

:: QUATERNI:funcnot 31 => QUATERNI:func 31
definition
  let a1 be quaternion set;
  redefine func a1 *' -> Element of QUATERNION;
end;

:: QUATERNI:th 43
theorem
for b1 being quaternion set holds
   b1 *' = [*Rea b1,- Im1 b1,- Im2 b1,- Im3 b1*];

:: QUATERNI:th 44
theorem
for b1 being quaternion set holds
   Rea (b1 *') = Rea b1 & Im1 (b1 *') = - Im1 b1 & Im2 (b1 *') = - Im2 b1 & Im3 (b1 *') = - Im3 b1;

:: QUATERNI:th 45
theorem
for b1 being quaternion set
      st b1 = 0
   holds b1 *' = 0;

:: QUATERNI:th 46
theorem
for b1 being quaternion set
      st b1 *' = 0
   holds b1 = 0;

:: QUATERNI:th 47
theorem
1q *' = 1q;

:: QUATERNI:th 48
theorem
Rea (<i> *') = 0 & Im1 (<i> *') = - 1 & Im2 (<i> *') = 0 & Im3 (<i> *') = 0;

:: QUATERNI:th 49
theorem
Rea (<j> *') = 0 & Im1 (<j> *') = 0 & Im2 (<j> *') = - 1 & Im3 (<j> *') = 0;

:: QUATERNI:th 50
theorem
Rea (<k> *') = 0 & Im1 (<k> *') = 0 & Im2 (<k> *') = 0 & Im3 (<k> *') = - 1;

:: QUATERNI:th 51
theorem
<i> *' = - <i>;

:: QUATERNI:th 52
theorem
<j> *' = - <j>;

:: QUATERNI:th 53
theorem
<k> *' = - <k>;

:: QUATERNI:th 54
theorem
for b1, b2 being quaternion set holds
(b1 + b2) *' = b1 *' + (b2 *');

:: QUATERNI:th 55
theorem
for b1 being quaternion set holds
   (- b1) *' = - (b1 *');

:: QUATERNI:th 56
theorem
for b1, b2 being quaternion set holds
(b1 - b2) *' = b1 *' - (b2 *');

:: QUATERNI:th 57
theorem
for b1, b2 being quaternion set
      st (Im2 b1) * Im3 b2 <> (Im3 b1) * Im2 b2
   holds (b1 * b2) *' <> b1 *' * (b2 *');

:: QUATERNI:th 58
theorem
for b1 being quaternion set
      st Im1 b1 = 0 & Im2 b1 = 0 & Im3 b1 = 0
   holds b1 *' = b1;

:: QUATERNI:th 59
theorem
for b1 being quaternion set
      st Rea b1 = 0
   holds b1 *' = - b1;

:: QUATERNI:th 60
theorem
for b1 being quaternion set holds
   Rea (b1 * (b1 *')) = (((Rea b1) ^2 + ((Im1 b1) ^2)) + ((Im2 b1) ^2)) + ((Im3 b1) ^2) &
    Im1 (b1 * (b1 *')) = 0 &
    Im2 (b1 * (b1 *')) = 0 &
    Im3 (b1 * (b1 *')) = 0;

:: QUATERNI:th 61
theorem
for b1 being quaternion set holds
   Rea (b1 + (b1 *')) = 2 * Rea b1 &
    Im1 (b1 + (b1 *')) = 0 &
    Im2 (b1 + (b1 *')) = 0 &
    Im3 (b1 + (b1 *')) = 0;

:: QUATERNI:th 62
theorem
for b1 being quaternion set holds
   - b1 = [*- Rea b1,- Im1 b1,- Im2 b1,- Im3 b1*];

:: QUATERNI:th 63
theorem
for b1, b2 being quaternion set holds
b1 - b2 = [*(Rea b1) - Rea b2,(Im1 b1) - Im1 b2,(Im2 b1) - Im2 b2,(Im3 b1) - Im3 b2*];

:: QUATERNI:th 64
theorem
for b1 being quaternion set holds
   Rea (b1 - (b1 *')) = 0 &
    Im1 (b1 - (b1 *')) = 2 * Im1 b1 &
    Im2 (b1 - (b1 *')) = 2 * Im2 b1 &
    Im3 (b1 - (b1 *')) = 2 * Im3 b1;

:: QUATERNI:funcnot 32 => QUATERNI:func 32
definition
  let a1 be quaternion set;
  func |.A1.| -> real set equals
    sqrt ((((Rea a1) ^2 + ((Im1 a1) ^2)) + ((Im2 a1) ^2)) + ((Im3 a1) ^2));
end;

:: QUATERNI:def 27
theorem
for b1 being quaternion set holds
   |.b1.| = sqrt ((((Rea b1) ^2 + ((Im1 b1) ^2)) + ((Im2 b1) ^2)) + ((Im3 b1) ^2));

:: QUATERNI:th 65
theorem
|.0q.| = 0;

:: QUATERNI:th 66
theorem
for b1 being quaternion set
      st |.b1.| = 0
   holds b1 = 0;

:: QUATERNI:th 67
theorem
for b1 being quaternion set holds
   0 <= |.b1.|;

:: QUATERNI:th 68
theorem
|.1q.| = 1;

:: QUATERNI:th 69
theorem
|.<i>.| = 1;

:: QUATERNI:th 70
theorem
|.<j>.| = 1;

:: QUATERNI:th 71
theorem
|.<k>.| = 1;

:: QUATERNI:th 72
theorem
for b1 being quaternion set holds
   |.- b1.| = |.b1.|;

:: QUATERNI:th 73
theorem
for b1 being quaternion set holds
   |.b1 *'.| = |.b1.|;

:: QUATERNI:th 74
theorem
for b1 being quaternion set holds
   0 <= (((Rea b1) ^2 + ((Im1 b1) ^2)) + ((Im2 b1) ^2)) + ((Im3 b1) ^2);

:: QUATERNI:th 75
theorem
for b1 being quaternion set holds
   Rea b1 <= |.b1.|;

:: QUATERNI:th 76
theorem
for b1 being quaternion set holds
   Im1 b1 <= |.b1.|;

:: QUATERNI:th 77
theorem
for b1 being quaternion set holds
   Im2 b1 <= |.b1.|;

:: QUATERNI:th 78
theorem
for b1 being quaternion set holds
   Im3 b1 <= |.b1.|;

:: QUATERNI:th 79
theorem
for b1, b2 being quaternion set holds
|.b1 + b2.| <= |.b1.| + |.b2.|;

:: QUATERNI:th 80
theorem
for b1, b2 being quaternion set holds
|.b1 - b2.| <= |.b1.| + |.b2.|;

:: QUATERNI:th 81
theorem
for b1, b2 being quaternion set holds
|.b1.| - |.b2.| <= |.b1 + b2.|;

:: QUATERNI:th 82
theorem
for b1, b2 being quaternion set holds
|.b1.| - |.b2.| <= |.b1 - b2.|;

:: QUATERNI:th 83
theorem
for b1, b2 being quaternion set holds
|.b1 - b2.| = |.b2 - b1.|;

:: QUATERNI:th 84
theorem
for b1, b2 being quaternion set holds
   |.b1 - b2.| = 0
iff
   b1 = b2;

:: QUATERNI:th 85
theorem
for b1, b2, b3 being quaternion set holds
|.b1 - b2.| <= |.b1 - b3.| + |.b3 - b2.|;

:: QUATERNI:th 86
theorem
for b1, b2 being quaternion set holds
|.|.b1.| - |.b2.|.| <= |.b1 - b2.|;

:: QUATERNI:th 87
theorem
for b1, b2 being quaternion set holds
|.b1 * b2.| = |.b1.| * |.b2.|;

:: QUATERNI:th 88
theorem
for b1 being quaternion set holds
   |.b1 * b1.| = (((Rea b1) ^2 + ((Im1 b1) ^2)) + ((Im2 b1) ^2)) + ((Im3 b1) ^2);

:: QUATERNI:th 89
theorem
for b1 being quaternion set holds
   |.b1 * b1.| = |.b1 * (b1 *').|;