Article MATRIXC1, MML version 4.99.1005

:: MATRIXC1:funcnot 1 => MATRIXC1:func 1
definition
  let a1 be tabular FinSequence of COMPLEX *;
  func A1 *' -> tabular FinSequence of COMPLEX * means
    len it = len a1 &
     width it = width a1 &
     (for b1, b2 being natural set
           st [b1,b2] in Indices a1
        holds it *(b1,b2) = (a1 *(b1,b2)) *');
end;

:: MATRIXC1:def 1
theorem
for b1, b2 being tabular FinSequence of COMPLEX * holds
   b2 = b1 *'
iff
   len b2 = len b1 &
    width b2 = width b1 &
    (for b3, b4 being natural set
          st [b3,b4] in Indices b1
       holds b2 *(b3,b4) = (b1 *(b3,b4)) *');

:: MATRIXC1:th 1
theorem
for b1, b2 being natural set
for b3 being Relation-like Function-like FinSequence-like tabular set holds
      [b1,b2] in Indices b3
   iff
      1 <= b1 & b1 <= len b3 & 1 <= b2 & b2 <= width b3;

:: MATRIXC1:th 2
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   b1 *' *' = b1;

:: MATRIXC1:th 3
theorem
for b1 being complex set
for b2 being tabular FinSequence of COMPLEX * holds
   len (b1 * b2) = len b2 & width (b1 * b2) = width b2;

:: MATRIXC1:th 4
theorem
for b1, b2 being natural set
for b3 being complex set
for b4 being tabular FinSequence of COMPLEX *
      st [b1,b2] in Indices b4
   holds (b3 * b4) *(b1,b2) = b3 * (b4 *(b1,b2));

:: MATRIXC1:th 5
theorem
for b1 being complex set
for b2 being tabular FinSequence of COMPLEX * holds
   (b1 * b2) *' = b1 *' * (b2 *');

:: MATRIXC1:th 6
theorem
for b1, b2 being tabular FinSequence of COMPLEX * holds
len (b1 + b2) = len b1 & width (b1 + b2) = width b1;

:: MATRIXC1:th 7
theorem
for b1, b2 being natural set
for b3, b4 being tabular FinSequence of COMPLEX *
      st len b3 = len b4 & width b3 = width b4 & [b1,b2] in Indices b3
   holds (b3 + b4) *(b1,b2) = (b3 *(b1,b2)) + (b4 *(b1,b2));

:: MATRIXC1:th 8
theorem
for b1, b2 being tabular FinSequence of COMPLEX *
      st len b1 = len b2 & width b1 = width b2
   holds (b1 + b2) *' = b1 *' + (b2 *');

:: MATRIXC1:th 9
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   len - b1 = len b1 & width - b1 = width b1;

:: MATRIXC1:th 10
theorem
for b1, b2 being natural set
for b3 being tabular FinSequence of COMPLEX *
      st len - b3 = len b3 & width - b3 = width b3 & [b1,b2] in Indices b3
   holds (- b3) *(b1,b2) = - (b3 *(b1,b2));

:: MATRIXC1:th 11
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   (- 1) * b1 = - b1;

:: MATRIXC1:th 12
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   (- b1) *' = - (b1 *');

:: MATRIXC1:th 13
theorem
for b1, b2 being tabular FinSequence of COMPLEX * holds
len (b1 - b2) = len b1 & width (b1 - b2) = width b1;

:: MATRIXC1:th 14
theorem
for b1, b2 being natural set
for b3, b4 being tabular FinSequence of COMPLEX *
      st len b3 = len b4 & width b3 = width b4 & [b1,b2] in Indices b3
   holds (b3 - b4) *(b1,b2) = (b3 *(b1,b2)) - (b4 *(b1,b2));

:: MATRIXC1:th 15
theorem
for b1, b2 being tabular FinSequence of COMPLEX *
      st len b1 = len b2 & width b1 = width b2
   holds (b1 - b2) *' = b1 *' - (b2 *');

:: MATRIXC1:funcnot 2 => MATRIXC1:func 2
definition
  let a1 be tabular FinSequence of COMPLEX *;
  func A1 @" -> tabular FinSequence of COMPLEX * equals
    a1 @ *';
end;

:: MATRIXC1:def 2
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   b1 @" = b1 @ *';

:: MATRIXC1:funcnot 3 => MATRIXC1:func 3
definition
  let a1 be FinSequence of COMPLEX;
  assume 0 < len a1;
  func FinSeq2Matrix A1 -> tabular FinSequence of COMPLEX * means
    len it = len a1 &
     width it = 1 &
     (for b1 being natural set
           st b1 in Seg len a1
        holds it . b1 = <*a1 . b1*>);
end;

:: MATRIXC1:def 3
theorem
for b1 being FinSequence of COMPLEX
   st 0 < len b1
for b2 being tabular FinSequence of COMPLEX * holds
      b2 = FinSeq2Matrix b1
   iff
      len b2 = len b1 &
       width b2 = 1 &
       (for b3 being natural set
             st b3 in Seg len b1
          holds b2 . b3 = <*b1 . b3*>);

:: MATRIXC1:funcnot 4 => MATRIXC1:func 4
definition
  let a1 be tabular FinSequence of COMPLEX *;
  func Matrix2FinSeq A1 -> FinSequence of COMPLEX equals
    Col(a1,1);
end;

:: MATRIXC1:def 4
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   Matrix2FinSeq b1 = Col(b1,1);

:: MATRIXC1:funcnot 5 => MATRIXC1:func 5
definition
  let a1, a2 be FinSequence of COMPLEX;
  func mlt(A1,A2) -> FinSequence of COMPLEX equals
    multcomplex .:(a1,a2);
  commutativity;
::  for a1, a2 being FinSequence of COMPLEX holds
::  mlt(a1,a2) = mlt(a2,a1);
end;

:: MATRIXC1:def 5
theorem
for b1, b2 being FinSequence of COMPLEX holds
mlt(b1,b2) = multcomplex .:(b1,b2);

:: MATRIXC1:funcnot 6 => MATRIXC1:func 6
definition
  let a1 be tabular FinSequence of COMPLEX *;
  let a2 be FinSequence of COMPLEX;
  func A1 * A2 -> FinSequence of COMPLEX means
    len it = len a1 &
     (for b1 being natural set
           st b1 in Seg len a1
        holds it . b1 = Sum mlt(Line(a1,b1),a2));
end;

:: MATRIXC1:def 7
theorem
for b1 being tabular FinSequence of COMPLEX *
for b2, b3 being FinSequence of COMPLEX holds
   b3 = b1 * b2
iff
   len b3 = len b1 &
    (for b4 being natural set
          st b4 in Seg len b1
       holds b3 . b4 = Sum mlt(Line(b1,b4),b2));

:: MATRIXC1:th 16
theorem
for b1 being natural set
for b2 being Element of COMPLEX
for b3, b4 being Element of b1 -tuples_on COMPLEX holds
b2 * mlt(b3,b4) = mlt(b2 * b3,b4);

:: MATRIXC1:funcnot 7 => MATRIXC1:func 7
definition
  let a1 be tabular FinSequence of COMPLEX *;
  let a2 be complex set;
  func A1 * A2 -> tabular FinSequence of COMPLEX * equals
    a2 * a1;
end;

:: MATRIXC1:def 8
theorem
for b1 being tabular FinSequence of COMPLEX *
for b2 being complex set holds
   b1 * b2 = b2 * b1;

:: MATRIXC1:th 17
theorem
for b1 being Element of COMPLEX
for b2 being tabular FinSequence of COMPLEX * holds
   (b2 * b1) *' = b1 *' * (b2 *');

:: MATRIXC1:th 19
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being natural set
      st b3 in dom mlt(b1,b2)
   holds (mlt(b1,b2)) . b3 = (b1 . b3) * (b2 . b3);

:: MATRIXC1:funcnot 8 => MATRIXC1:func 8
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on COMPLEX;
  redefine func mlt(a2,a3) -> Element of a1 -tuples_on COMPLEX;
  commutativity;
::  for a1 being Element of NAT
::  for a2, a3 being Element of a1 -tuples_on COMPLEX holds
::  mlt(a2,a3) = mlt(a3,a2);
end;

:: MATRIXC1:th 20
theorem
for b1, b2 being natural set
for b3, b4 being Element of b1 -tuples_on COMPLEX holds
(mlt(b3,b4)) . b2 = (b3 . b2) * (b4 . b2);

:: MATRIXC1:th 21
theorem
for b1, b2 being Element of COMPLEX holds
(addcomplex .(b1,b2 *')) *' = addcomplex .(b1 *',b2);

:: MATRIXC1:th 22
theorem
for b1 being FinSequence of COMPLEX holds
   ex b2 being Function-like quasi_total Relation of NAT,COMPLEX st
      for b3 being natural set
            st 1 <= b3 & b3 <= len b1
         holds b2 . b3 = b1 . b3;

:: MATRIXC1:th 23
theorem
for b1 being FinSequence of COMPLEX
      st 1 <= len (b1 *')
   holds addcomplex "**" (b1 *') = (addcomplex "**" b1) *';

:: MATRIXC1:th 24
theorem
for b1 being FinSequence of COMPLEX
      st 1 <= len b1
   holds Sum (b1 *') = (Sum b1) *';

:: MATRIXC1:th 25
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2
   holds (mlt(b1,b2 *')) *' = mlt(b2,b1 *');

:: MATRIXC1:th 26
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being Element of COMPLEX
      st len b1 = len b2
   holds mlt(b1,b3 * b2) = b3 * mlt(b1,b2);

:: MATRIXC1:th 27
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being Element of COMPLEX
      st len b1 = len b2
   holds mlt(b3 * b1,b2) = b3 * mlt(b1,b2);

:: MATRIXC1:th 28
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2
   holds (mlt(b1,b2)) *' = mlt(b1 *',b2 *');

:: MATRIXC1:th 29
theorem
for b1 being FinSequence of COMPLEX
for b2 being Element of COMPLEX holds
   Sum (b2 * b1) = b2 * Sum b1;

:: MATRIXC1:funcnot 9 => MATRIXC1:func 9
definition
  let a1 be FinSequence of REAL;
  func FR2FC A1 -> FinSequence of COMPLEX equals
    a1;
end;

:: MATRIXC1:def 9
theorem
for b1 being FinSequence of REAL holds
   FR2FC b1 = b1;

:: MATRIXC1:th 30
theorem
for b1 being FinSequence of REAL
for b2 being FinSequence of COMPLEX
      st b1 = b2 & 1 <= len b1
   holds addreal "**" b1 = addcomplex "**" b2;

:: MATRIXC1:th 31
theorem
for b1 being FinSequence of REAL
for b2 being FinSequence of COMPLEX
      st b1 = b2 & 1 <= len b1
   holds Sum b1 = Sum b2;

:: MATRIXC1:th 32
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2
   holds Sum (b1 - b2) = (Sum b1) - Sum b2;

:: MATRIXC1:th 33
theorem
for b1, b2, b3 being FinSequence of COMPLEX
      st len b1 = len b2 & len b2 = len b3
   holds mlt(b1 - b2,b3) = (mlt(b1,b3)) - mlt(b2,b3);

:: MATRIXC1:th 34
theorem
for b1, b2, b3 being FinSequence of COMPLEX
      st len b1 = len b2 & len b2 = len b3
   holds mlt(b1,b2 - b3) = (mlt(b1,b2)) - mlt(b1,b3);

:: MATRIXC1:th 35
theorem
for b1, b2, b3 being FinSequence of COMPLEX
      st len b1 = len b2 & len b2 = len b3
   holds mlt(b1,b2 + b3) = (mlt(b1,b2)) + mlt(b1,b3);

:: MATRIXC1:th 36
theorem
for b1, b2, b3 being FinSequence of COMPLEX
      st len b1 = len b2 & len b2 = len b3
   holds mlt(b1 + b2,b3) = (mlt(b1,b3)) + mlt(b2,b3);

:: MATRIXC1:th 37
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2
   holds Sum (b1 + b2) = (Sum b1) + Sum b2;

:: MATRIXC1:th 38
theorem
for b1, b2 being FinSequence of COMPLEX
for b3, b4 being FinSequence of REAL
      st b1 = b3 & b2 = b4 & len b1 = len b4
   holds multcomplex .:(b1,b2) = multreal .:(b3,b4);

:: MATRIXC1:th 39
theorem
for b1, b2 being FinSequence of REAL
      st len b1 = len b2
   holds FR2FC mlt(b1,b2) = mlt(FR2FC b1,FR2FC b2);

:: MATRIXC1:th 40
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2 & 0 < len b1
   holds |(b1,b2)| = Sum mlt(b1,b2 *');

:: MATRIXC1:th 42
theorem
for b1, b2 being natural set
for b3, b4 being tabular FinSequence of COMPLEX *
      st len b3 = len b4 & width b3 = width b4 & b2 in Seg len b3
   holds Line(b3 + b4,b2) = (Line(b3,b2)) + Line(b4,b2);

:: MATRIXC1:th 43
theorem
for b1 being natural set
for b2 being tabular FinSequence of COMPLEX *
      st b1 in Seg len b2
   holds Line(b2,b1) = (Line(b2 *',b1)) *';

:: MATRIXC1:th 44
theorem
for b1 being natural set
for b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b2 = width b3
   holds mlt(b2,(Line(b3 *',b1)) *') = (mlt(Line(b3 *',b1),b2 *')) *';

:: MATRIXC1:th 45
theorem
for b1 being FinSequence of COMPLEX
for b2 being tabular FinSequence of COMPLEX *
      st len b1 = width b2 & 1 <= len b1
   holds (b2 * b1) *' = b2 *' * (b1 *');

:: MATRIXC1:th 46
theorem
for b1, b2, b3 being FinSequence of COMPLEX
      st len b1 = len b2 & len b2 = len b3
   holds mlt(b1,mlt(b2,b3)) = mlt(mlt(b1,b2),b3);

:: MATRIXC1:th 47
theorem
for b1 being FinSequence of COMPLEX holds
   Sum - b1 = - Sum b1;

:: MATRIXC1:th 49
theorem
for b1, b2 being FinSequence of COMPLEX holds
Sum (b1 ^ b2) = (Sum b1) + Sum b2;

:: MATRIXC1:funcnot 10 => MATRIXC1:func 10
definition
  let a1 be tabular FinSequence of COMPLEX *;
  func LineSum A1 -> FinSequence of COMPLEX means
    len it = len a1 &
     (for b1 being natural set
           st b1 in Seg len a1
        holds it . b1 = Sum Line(a1,b1));
end;

:: MATRIXC1:def 10
theorem
for b1 being tabular FinSequence of COMPLEX *
for b2 being FinSequence of COMPLEX holds
      b2 = LineSum b1
   iff
      len b2 = len b1 &
       (for b3 being natural set
             st b3 in Seg len b1
          holds b2 . b3 = Sum Line(b1,b3));

:: MATRIXC1:funcnot 11 => MATRIXC1:func 11
definition
  let a1 be tabular FinSequence of COMPLEX *;
  func ColSum A1 -> FinSequence of COMPLEX means
    len it = width a1 &
     (for b1 being natural set
           st b1 in Seg width a1
        holds it . b1 = Sum Col(a1,b1));
end;

:: MATRIXC1:def 11
theorem
for b1 being tabular FinSequence of COMPLEX *
for b2 being FinSequence of COMPLEX holds
      b2 = ColSum b1
   iff
      len b2 = width b1 &
       (for b3 being natural set
             st b3 in Seg width b1
          holds b2 . b3 = Sum Col(b1,b3));

:: MATRIXC1:th 50
theorem
for b1 being FinSequence of COMPLEX
      st len b1 = 1
   holds Sum b1 = b1 . 1;

:: MATRIXC1:th 51
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being natural set
      st len b1 = b3 + 1 & b2 = b1 | b3
   holds Sum b1 = (Sum b2) + (b1 /. len b1);

:: MATRIXC1:th 52
theorem
for b1 being tabular FinSequence of COMPLEX *
      st 0 < len b1
   holds Sum LineSum b1 = Sum ColSum b1;

:: MATRIXC1:funcnot 12 => MATRIXC1:func 12
definition
  let a1 be tabular FinSequence of COMPLEX *;
  func SumAll A1 -> Element of COMPLEX equals
    Sum LineSum a1;
end;

:: MATRIXC1:def 12
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   SumAll b1 = Sum LineSum b1;

:: MATRIXC1:th 53
theorem
for b1 being tabular FinSequence of COMPLEX * holds
   ColSum b1 = LineSum (b1 @);

:: MATRIXC1:th 54
theorem
for b1 being tabular FinSequence of COMPLEX *
      st 0 < len b1
   holds SumAll b1 = SumAll (b1 @);

:: MATRIXC1:funcnot 13 => MATRIXC1:func 13
definition
  let a1, a2 be FinSequence of COMPLEX;
  let a3 be tabular FinSequence of COMPLEX *;
  assume len a1 = len a3 & len a2 = width a3;
  func QuadraticForm(A1,A3,A2) -> tabular FinSequence of COMPLEX * means
    len it = len a1 &
     width it = len a2 &
     (for b1, b2 being natural set
           st [b1,b2] in Indices a3
        holds it *(b1,b2) = ((a1 . b1) * (a3 *(b1,b2))) * ((a2 . b2) *'));
end;

:: MATRIXC1:def 13
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
   st len b1 = len b3 & len b2 = width b3
for b4 being tabular FinSequence of COMPLEX * holds
      b4 = QuadraticForm(b1,b3,b2)
   iff
      len b4 = len b1 &
       width b4 = len b2 &
       (for b5, b6 being natural set
             st [b5,b6] in Indices b3
          holds b4 *(b5,b6) = ((b1 . b5) * (b3 *(b5,b6))) * ((b2 . b6) *'));

:: MATRIXC1:th 55
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b1 = len b3 & len b2 = width b3 & 0 < len b1 & 0 < len b2
   holds (QuadraticForm(b1,b3,b2)) @ = (QuadraticForm(b2,b3 @",b1)) *';

:: MATRIXC1:th 56
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b1 = len b3 & len b2 = width b3
   holds (QuadraticForm(b1,b3,b2)) *' = QuadraticForm(b1 *',b3 *',b2 *');

:: MATRIXC1:th 57
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2 & 0 < len b2
   holds |(b1,b2)| = |(b2,b1)| *';

:: MATRIXC1:th 58
theorem
for b1, b2 being FinSequence of COMPLEX
      st len b1 = len b2 & 0 < len b2
   holds |(b1,b2)| *' = |(b1 *',b2 *')|;

:: MATRIXC1:th 59
theorem
for b1 being tabular FinSequence of COMPLEX *
      st 0 < width b1
   holds b1 @ *' = b1 *' @;

:: MATRIXC1:th 60
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b1 = width b3 & len b2 = len b3 & 0 < len b1 & 0 < len b2
   holds |(b1,b3 @" * b2)| = SumAll QuadraticForm(b1,b3 @,b2);

:: MATRIXC1:th 61
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b2 = len b3 & len b1 = width b3 & 0 < len b1 & 0 < len b2 & 0 < len b3
   holds |(b3 * b1,b2)| = SumAll QuadraticForm(b1,b3 @,b2);

:: MATRIXC1:th 62
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b1 = width b3 & len b2 = len b3 & 0 < width b3 & 0 < len b3
   holds |(b3 * b1,b2)| = |(b1,b3 @" * b2)|;

:: MATRIXC1:th 63
theorem
for b1, b2 being FinSequence of COMPLEX
for b3 being tabular FinSequence of COMPLEX *
      st len b1 = len b3 & len b2 = width b3 & 0 < width b3 & 0 < len b3 & 0 < len b1
   holds |(b1,b3 * b2)| = |(b3 @" * b1,b2)|;