MATRICES AND MATRIX OPERATIONS: Unit 16

Dr. Wlodzislaw Kostecki

The Papua New Guinea University of Technology (PNGUT)

Department of Electrical and Communication Engineering

Lae, Morobe Province

Papua New Guinea

Copyright ฉ 2000 by Wlodzislaw Kostecki

All rights reserved

-------------------------------------------------------------------

(16) The complex matrix and its conjugate

OBJECTIVES :

• To define the complex-numbered or complex matrix.

• To provide alternative methods of creating matrices whose elements are real parts, imaginary parts, moduli, and arguments of elements of a given complex matrix.

• To provide alternative methods of creating matrices whose elements are expressed in Maple ’ s polar form .

• To provide alternative methods of creating matrices whose elements are expressed in the special polar form used in electrical engineering.

• To introduce the function evalc for evaluation of complex matrices.

• To investigate the methods of display and evaluation of complex matrices whose elements are given in the polar or other transcendental form containing decimal or irrational numbers.

• To provide an example of a matrix comprising functions of the imaginary unit , which evaluates to a real matrix.

• To introduce the k-matrix and investigate its properties.

• To provide a universal method for presenting the product of complex matrices with symbolic elements as the sum of a matrix comprising real parts and a matrix comprising imaginary parts of elements of the product matrix.

• To define the conjugate of a complex matrix.

• To provide alternative methods of computation of the conjugate of a given complex matrix.

• To introduce the Hermitian matrix and investigate its properties.

• To investigate properties of the conjugate of a complex matrix.

• To investigate properties of certain operations involving both a complex matrix and its conjugate.

• To investigate properties of operations involving the determinant of a complex matrix and the determinant of the matrix conjugate.

• To introduce the concept of the imaginary unit matrix and investigate its properties.

> restart : with(linalg, adj, coldim, det, diag, inverse, multiply, rowdim, transpose) :

A . The complex matrix

The complex-numbered or complex matrix is a matrix, in which at least one element is a complex number .

Exemplarily, consider a ( ื ) complex matrix [ Z ] given as

> Z := matrix(3, 3, [1+5*I, 2+6*I, 3-7*I, 4+8*I, 5-9*I, 6+10*I, 7+11*I, 8+12*I, 9-13*I]) : Z = matrix(Z) ;

The various operations on the complex matrix [ Z ] are analysed hereunder.

• To obtain a matrix containing only the real part of the elements of [ Z ], use any of the following alternative methods.

Method 1 . Using the evalm and Re functions:

> `Re(Z)` := evalm(Re(Z)) : `Re(Z)` = matrix(`Re(Z)`) ;

Method 2 . Using the map and Re functions:

> `Re(Z)` := map(Re, Z) : `Re(Z)` = matrix(`Re(Z)`) ;

Method 3 . Using the map and op functions together with the arrow-type procedure:

> `Re(Z)` := map(x->op(1, x), Z) : `Re(Z)` = matrix(`Re(Z)`) ;

• To obtain a matrix containing only the numerical value of the imaginary part of the elements of [ Z ], use any of the following alternative methods.

Method 1 . Using the evalm and Im functions:

> `Im(Z)` := evalm(Im(Z)) : `Im(Z)` = matrix(`Im(Z)`) ;

Method 2 . Using the map and Im functions:

> `Im(Z)` := map(Im, Z) : `Im(Z)` = matrix(`Im(Z)`) ;

Method 3 . Using the function map and twice the function op together with the arrow-type procedure:

> `Im(Z)` := map(x->op(1, op(2, x)), Z) : `Im(Z)` = matrix(`Im(Z)`) ;

• To obtain a matrix containing only the imaginary part of the elements of [ Z ], use any of the following alternative methods.

Method 1 . Using the evalm and Re functions:

> `Im(Z) I` := evalm(Z - `Re(Z)`) : `Im(Z) I` = matrix(`Im(Z) I`) ;

Method 2 . Using the map and op functions together with the arrow-type procedure:

> `Im(Z) I` := map(x->op(2, x), Z) : `Im(Z) I` = matrix(`Im(Z) I`) ;

Method 3 . Using the functions evalm and Im multiplied by the imaginary unit:

> `Im(Z) I` := evalm(Im(Z) * I) : `Im(Z) I` = matrix(`Im(Z) I`) ;

Method 4 . Using the functions map and Im multiplied by the imaginary unit:

> `Im(Z) I` := map(Im * I, Z) : `Im(Z) I` = matrix(`Im(Z) I`) ;

• To obtain a matrix with the elements of [ Z ] expressed in Maple ’ s polar form , i.e.

> z[i,j] = polar(z[i,j]) ;

use any of the following alternative methods.

Method 1 . Using the function map and function convert together with the arrow-type procedure and function polar :

> Z_p := map(x->convert(x, polar), Z) : Z_p = matrix(Z_p) ;

Method 2 . Using the function map and function polar together with the arrow-type procedure:

> Z_p := map(x->polar(x), Z) : Z_p = matrix(Z_p) ;

Method 3 . Using the map and polar functions (simplest):

> Z_p := map(polar, Z) : Z_p = matrix(Z_p) ;

• To obtain a matrix containing the modulus (absolute value, magnitude) of the elements of [ Z ], use any of the following alternative methods.

Method 1 . Using the map , sqrt , Re , and Im functions:

> `abs(Z)` := map(sqrt(Re^2+Im^2), Z) : abs(Z) = matrix(`abs(Z)`) ;

Method 2 . Using the evalm and abs functions:

> `abs(Z)` := evalm(abs(Z)) : abs(Z) = matrix(`abs(Z)`) ;

Method 3 . Using the map and abs functions:

> `abs(Z)` := map(abs, Z) : abs(Z) = matrix(`abs(Z)`) ;

Method 4 . Using the function map and function op together with the arrow-type procedure applied to the first argument (modulus) of matrix [ Z_p ]:

> `abs(Z)` := map(x->op(1, x), Z_p) : abs(Z) = matrix(`abs(Z)`) ;

Floating-point evaluation of any of the above exact results gives the following approximation:

> `approx(abs(Z))` := evalf(matrix(`abs(Z)`)) : abs(Z) = matrix(`approx(abs(Z))`) ;

• To obtain a matrix containing the principal argument ( in radians ) of the elements of [ Z ], use either of the following alternative methods.

Method 1 . Using the evalm and argument functions:

> `arg(Z)` := evalm(argument(Z)) : Arg(Z) = matrix(`arg(Z)`) ;

Method 2 . Using the map and argument functions:

> `arg(Z)` := map(argument, Z) : Arg(Z) = matrix(`arg(Z)`) ;

Method 3 . Using the function map and function op together with the arrow-type procedure applied to the second argument (principal argument in radians) of matrix [ Z_p ]:

> `arg(Z)` := map(x->op(2, x), Z_p) : Arg(Z) = matrix(`arg(Z)`) ;

Floating-point evaluation of any of the above exact result gives the following approximation:

> `approx(arg(Z))` := evalf(matrix(`arg(Z)`)) : Arg(Z) = matrix(`approx(arg(Z))`) ;

• To obtain a matrix containing the principal argument ( in degrees ) of the elements of [ Z ], use any of the following alternative methods.

Method 1 . Using the evalm function:

> `deg(arg(Z))` := evalf(evalm(`arg(Z)` *180/Pi)) : deg(Arg(Z)) = matrix(`deg(arg(Z))`) ;

Method 2 . Using the map function:

> `deg(arg(Z))` := evalf(map(x->x*180/Pi, `arg(Z)`)) : deg(Arg(Z)) = matrix(`deg(arg(Z))`) ;

Method 3 . Using the function map and function op together with the arrow-type procedure applied to the second argument (principal argument in radians) of matrix [ Z_p ]:

> `deg(arg(Z))` := evalf(evalm(map(x->op(2, x), Z_p) *180/Pi)) : deg(Arg(Z)) = matrix(`deg(arg(Z))`) ;

* * *

N.B. A customary practice in electrical engineering is to represent the exponential form of a complex number using a shorthand notation, which includes a (rounded-off) modulus and (rounded-off) principal argument in degrees . This notation as used in textbooks looks like this

where the argument is placed in conjuction with a so-called Kennelly’ s operator and the complex number is read " (modulus) at (argument) degrees". This form is referred to as the polar form of a complex number.

The symbol of Kennelly’ s operator does not exist in Maple . Therefore, it is necessary to develop a method for representing elements of a complex matrix in a way resembling the above "engineering" polar form. Three alternative methods are proposed hereunder.

Step 1 . Obtain a matrix with moduli of the elements of [ Z ] rounded-off to, say, significant digits:

> `abs(Z)` := evalf(matrix(`abs(Z)`), 4) : abs(Z) = matrix(`abs(Z)`) ;

Note that the same effect may be obtained setting the environment variable Digits to , i.e. using the command line as follows:

> Digits := 4 : `abs(Z)` := evalf(matrix(`abs(Z)`)) : abs(Z) = matrix(`abs(Z)`) ;

Step 2 . Obtain a matrix with principal arguments ( in degrees ) of the elements of [ Z ] rounded-off to, say, significant digits:

> `deg(arg(Z))` := map(x->evalf(x, 3), `deg(arg(Z))`) : deg(Arg(Z)) = matrix(`deg(arg(Z))`) ;

Step 3 . Define an auxiliary matrix of the same size as that of matrix [ Z ]:

> z_p_e := matrix(rowdim(Z), coldim(Z)) :

Step 4 . Construct a matrix [ Z_p_eng ] containing "engineering" polar forms of the elements of [ Z ].

This may be done using any of the following methods.

Method 1

> z_p_e1 := map(x->x * `@`, `abs(Z)`) : z_p_e2 := map(x->[x * `ฐ`], `deg(arg(Z))`) :

> for i to rowdim(Z) do for j to coldim(Z) do z_p_e[i,j] := z_p_e1[i,j]*z_p_e2[i,j] : od : od :

> Z_p_eng := matrix(z_p_e) : Z_p_eng = matrix(Z_p_eng) ;

Any element of this matrix may be easily extracted and so may be its numerical components, e.g.

> z_p_eng[32] := Z_p_eng[3,2] : 'z_p_eng[32]' = z_p_eng[32] ;

> `abs(z_p_eng)`[32] := op(1, z_p_eng[32]) : Abs('z_p_eng[32]') = `abs(z_p_eng)`[32] ;

> `deg(arg(z_p_eng))`[32] := op(op(3, z_p_eng[32]))/`ฐ` :

> deg(Arg('z_p_eng[32]')) = `deg(arg(z_p_eng))`[32] ;

Method 2

> z_p_e1 := map(x->x * `@`, `abs(Z)`) : z_p_e2 := map(x->angle(x * `ฐ`), `deg(arg(Z))`) :

> for i to rowdim(Z) do for j to coldim(Z) do z_p_e[i,j] := z_p_e1[i,j]*z_p_e2[i,j] : od : od :

> Z_p_eng := matrix(z_p_e) : Z_p_eng = matrix(Z_p_eng) ;

Any element of this matrix may be easily extracted and so may be its numerical components, e.g.

> z_p_eng[13] := Z_p_eng[1,3] : 'z_p_eng[13]' = z_p_eng[13] ;

> `abs(z_p_eng)`[13] := op(1, z_p_eng[13]) : Abs('z_p_eng[13]') = `abs(z_p_eng)`[13] ;

> `deg(arg(z_p_eng))`[13] := op(op(3, z_p_eng[13]))/`ฐ` :

> deg(Arg('z_p_eng[13]')) = `deg(arg(z_p_eng))`[13] ;

Method 3

> z_p_e1 := map(x->x * `|`, `abs(Z)`) : z_p_e2 := map(x->[x * `ฐ`], `deg(arg(Z))`) :

> for i to rowdim(Z) do for j to coldim(Z) do z_p_e[i,j] := z_p_e1[i,j]*z_p_e2[i,j] : od : od :

> Z_p_eng := matrix(z_p_e) : Z_p_eng = matrix(Z_p_eng) ;

Any element of this matrix may be easily extracted and so may be its numerical components, e.g.

> z_p_eng[11] := Z_p_eng[1,1] : 'z_p_eng[11]' = z_p_eng[11] ;

> `abs(z_p_eng)`[11] := op(1, z_p_eng[11]) : Abs('z_p_eng[11]') = `abs(z_p_eng)`[11] ;

> `deg(arg(z_p_eng))`[11] := op(op(3, z_p_eng[11]))/`ฐ` :

> deg(Arg('z_p_eng[11]')) = `deg(arg(z_p_eng))`[11] ;

Each method serves the purpose equally well.

* * *

N.B. If the elements of a complex matrix are given in the polar form containing decimal numbers and it is required to display them in this form, the list of the elements must be enclosed in single quotes to prevent internal evaluation, e.g.

> A := matrix(2, 2, '[4*exp(0.4*I), -0.7*exp(-0.6*I), -4*exp(0.5*I), 2.3*exp(0.2*I)]') : A = matrix(A) ;

otherwise Maple would evaluate all the elements internally and display them in the canonical form (rectangular form), i.e.

> A = matrix(2, 2, [4*exp(0.4*I), -0.7*exp(-0.6*I), -4*exp(0.5*I), 2.3*exp(0.2*I)]) ;

Matrix [ A ] defined and input with the element list enclosed in single quotes may then be evaluated and displayed in the canonical form using any of the following alternative methods.

Method 1 . Using the function evalf and any of the functions evalm , matrix , or op :

> A = evalf(evalm(A)) ; A = evalf(matrix(A)) ; A = evalf(op(A)) ;

Method 2 . Using the function convert together with the form (type) float ( float ing-point number) and any of the functions evalm , matrix , or op :

> A = convert(evalm(A), float) ; A = convert(matrix(A), float) ; A = convert(op(A), float) ;

Method 3 . Using the function map together with the arrow-type procedure including any of the functions eval , evalc , evalf , or value :

> A = map(x->eval(x), A) ; A = map(x->evalc(x), A) ; A = map(x->evalf(x), A) ; A = map(x->value(x), A) ;

where the function evalc is specifically designed to eval uate c omplex-valued expressions.

The same applies to matrix elements given in any other transcendental form containing decimal numbers , e.g.

> B := matrix(2, 2, '[2*sin(0.2-0.3*I), 0.4*cos(0.4+0.6*I), 1.1*cos(0.5-0.7*I), -5*sin(0.6+0.2*I)]') :

> B = matrix(B) ;

since not enclosing the element list in single quotes would display the matrix with the elements in the canonical form, i.e.

> B = matrix(2, 2, [2*sin(0.2-0.3*I), 0.4*cos(0.4+0.6*I), 1.1*cos(0.5-0.7*I), -5*sin(0.6+0.2*I)]) ;

Subsequent floating-point evaluation of matrix [ B ] defined and input with the element list enclosed in single quotes yields

> B = evalf(matrix(B)) ;

* * *

N.B. If the elements of a complex matrix are given in the polar form containing irrational numbers and it is required to display them in this form, the list of the elements must be enclosed in single quotes to prevent internal evaluation, e.g.

> C := matrix(2, 2, '[3*exp(Pi/3*I), -3/5*exp(Pi/4*I), 4/7*exp(Pi/5*I), 5*exp(Pi/6*I)]') : C = matrix(C) ;

otherwise Maple would evaluate the elements internally and display them as exact numbers, viz.

> C = matrix(2, 2, [3*exp(Pi/3*I), -3/5*exp(Pi/4*I), 4/7*exp(Pi/5*I), 5*exp(Pi/6*I)]) ;

A further exact symbolic evaluation of the element at location (2,1) is possible, which may be performed using the function map together with the arrow-type procedure including function evalc , i.e.

> C := map(x->evalc(x), C) : C = matrix(C) ;

Floating-point evaluation of the matrix yields

> C = evalf(matrix(C)) ;

* * *

N.B. If the elements of a complex matrix are given in any other transcendental form containing irrational numbers, and it is required to display them in this form, the list of the elements need not be enclosed in single quotes, e.g.

> E := matrix(2, 2, [6*sin(1/5-Pi/4*I), -sqrt(3)*cos(2/5+Pi/3*I), 2*cos(1/2-Pi/5*I), -5*sin(3/7+Pi/6*I)]) :

> E = matrix(E) ;

since the matrix function will not perform any further exact evaluation internally and the matrix will be displayed in the unaltered exact form, viz.

> E = matrix(2, 2, [6*sin(1/5-Pi/4*I), -sqrt(3)*cos(2/5+Pi/3*I), 2*cos(1/2-Pi/5*I), -5*sin(3/7+Pi/6*I)]) ;

A further exact symbolic evaluation of the matrix elements is possible and may be performed using the function map together with the arrow-type procedure including function evalc , i.e.

> E := map(x->evalc(x), E) : E = matrix(E) ;

Floating-point evaluation of the matrix yields

> E = evalf(matrix(E)) ;

* * *

N.B. The following matrix formed from elements containing the imaginary unit

> F := matrix(2, 3, '[I^(I/2), I^I, I^(2*I), exp(I*Pi), exp(2*I*Pi), cosh(I)]') : F = matrix(F) ;

evaluates to a real matrix as evidenced by the following exact result,

> F := map(x->evalc(x), F) : F = matrix(F) ;

or by its the floating-point approximation,

> F := evalf(matrix(F)) : F = matrix(F) ;

* * *

N.B. The following matrix formed from elements containing the imaginary unit

> G := matrix(2, 2, '[exp(I*Pi/2), (I/2)^I, exp(I), sinh(I)]') : G = matrix(G) ;

evaluates to a complex matrix as evidenced by the following exact result,

> G := map(x->evalc(x), G) : G = matrix(G) ;

or by its floating-point approximation,

> G := evalf(matrix(G)) : G = matrix(G) ;

* * *

N.B. A ( ื ) complex matrix, which satisfies the equation

[ k ] ^(3 n ) = [ U ]

where n is any (positive or negative) integer, is called the k-matrix .

Let a ( ื ) complex matrix be given as

> k := matrix(3,3, [0, 0, -I, I, 0, 0, 0, 1, 0]) : k = matrix(k) ;

Exemplarily, let and . Compute [ k ] ^(3 n ) for both values of n .

> n := 1 : `k^3*1` := evalm(k^(3*n)) : n := -2 : `k^3*(-2)` := evalm(k^(3*n)) :

> k^3 = matrix(`k^3*1`) ; k^` -6` = matrix(`k^3*(-2)`) ;

Notice that the k-matrix may be considered to be the cube root of a ( ื ) unit matrix [ U ], or

[ k ] = [ U ] ^(1/3)

By definition, the cube root of a matrix [ U ] is a matrix [ U ] ^(1/3) having the property that

[ U ] = { [ U ] ^(1/3)} { [ U ] ^(1/3)} { [ U ] ^(1/3)}

Setting

[ U ] ^(1/3) = [ k ]

and substituting it into the above yields

[ U ] = [ k ] [ k ] [ k ] = [ k ] ^3

The k-matrix is not a unique cube root of [ U ] since the unit matrix [ U ] is itself also a cube root of [ U ].

Notice that the determinant of the k-matrix is , viz.

> `det(k)` := det(k) : Det(k) = `det(k)` ;

* * *

N.B. The matrix product of complex matrices with symbolic elements may be presented as the sum of a matrix comprising real parts and a matrix comprising imaginary parts of elements of the product matrix.

The method presented hereunder is universal , i.e. it works for complex matrices with symbolic elements, which satisfy the multiplication conformability rule. The matrix elements may have both real and imaginary parts, or some of them may be only real or pure imaginary , or .

For simplicity in display, consider square ( ื ) complex matrices [ Z1 ] and [ Z2 ] given as

> Z1 := matrix(2, 2, [a[11]+b[11]*I, b[12]*I, 0, a[22]+b[22]*I]) :

> Z2 := matrix(2, 2, [c[11], c[12]+d[12]*I, d[21]*I, 0]) :

> Z1 = matrix(Z1) ; Z2 = matrix(Z2) ;

The product [ Z1 ] [ Z2 ] is the following ( ื ) matrix:

> `Z1 Z2` := map(expand, evalm(Z1 &* Z2)) : Z1*Z2 = matrix(`Z1 Z2`) ;

The product [ Z1 ] [ Z2 ] may be presented as either

> Z1*Z2 = Real(Z1*Z2) + I*Imaginary(Z1*Z2) ;

or, in the matrix form,

> R_e := matrix(rowdim(`Z1 Z2`), coldim(`Z1 Z2`)) : I_m := matrix(rowdim(`Z1 Z2`), coldim(`Z1 Z2`)) :

> for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do R_e[i,j] := re[i,j] : I_m[i,j] := im[i,j] : od : od :

> R_e := matrix(R_e) : I_m := matrix(I_m) : Z1*Z2 = matrix(R_e) + I*matrix(I_m) ;

To determine the real elements and imaginary elements of the component matrices, do the following steps.

Step 1 . Convert each element of the product [ Z1 ] [ Z2 ] to a list comprising individual terms of a given element:

> for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do L[i,j] := convert(`Z1 Z2`[i,j], list) : print(evaln(L[i,j]) = L[i,j]) : od : od :

Step 2 . Rename the lists by indexing each with a single-digit subscript:

> n := 0 : for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do n := n+1 : L[n] := L[i,j] : print(evaln(L[n]) = L[i,j]) : od : od :

Step 3 . Assign a temporary initial value to each real and imaginary element of the component matrices:

> for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do re[i,j] := 0 : im[i,j] := 0 : print(evaln(re[i,j]) = re[i,j], ` ` * evaln(im[i,j]) = im[i,j]) : od : od :

Step 4 . Isolate real and imaginary elements from each of the above lists:

> n := 0 : for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do n := n+1 : for m to nops(L[n]) do if L[n][m] = 0 then re[i,j] := 0 : im[i,j] := 0 elif sign((L[n][m])^2/abs(L[n][m])) = 1 then re[i,j] := re[i,j] + L[n][m] else im[i,j] := im[i,j] + L[n][m] fi : if m = nops(L[n]) then print(evaln(re[i,j]) = re[i,j]) : print(evaln(im[i,j]) = im[i,j]) fi : od : od : od :

Step 5 . Compute the value of each element of the real and imaginary matrices:

> for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do R_e[i,j] := re[i,j] : re[i,j] := R_e[i,j] : I_m[i,j] := evalc(-I*im[i,j]) : im[i,j] := I_m[i,j] : od : od :

• values of elements of the real matrix:

> for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do print(evaln(re[i,j]) = re[i,j]) : od : od :

• values of elements of the imaginary matrix:

> for i to rowdim(`Z1 Z2`) do for j to coldim(`Z1 Z2`) do print(evaln(im[i,j]) = im[i,j]) : od : od :

Step 6 . Construct and display the real and imaginary matrices:

> R_e := matrix(R_e) : I_m := matrix(I_m) :

> Real(Z1*Z2) = matrix(R_e) ; `` ; Imaginary(Z1*Z2) = matrix(I_m) ;

Thus, the multiplication operation of [ Z1 ] and [ Z2 ] may be displayed in "like-in-a-book" form, viz.

> matrix(Z1)*matrix(Z2) = matrix(R_e) + I*matrix(I_m) ;

Notice that multiplying separately real and imaginary parts of [ Z1 ] and [ Z2 ] yields a different result, which is evidently incorrect .

* * *

B . The complex conjugate of a complex matrix

The complex conjugate of a complex matrix is the matrix whose elements are complex conjugates of the corresponding elements of a given matrix.

Exemplarily, consider the ( ื ) complex matrix [ Z ] given in Section A . Its complex conjugate, Conj [ Z ] (or , as in textbooks), is the ( ื ) complex matrix, which may be obtained using any of the following alternative methods.

Method 1 . Using the evalm and conjugate functions:

> `conj(Z)` := conjugate(Z) : `Conj(Z)` := evalm(conjugate(Z)) : `conj(Z)` = matrix(`Conj(Z)`) ;

Method 2 . Using the map and conjugate functions:

> `Conj(Z)` := map(conjugate, Z) : `conj(Z)` = matrix(`Conj(Z)`) ;

Method 3 . Using the function map together with the arrow-type procedure including the conjugate function:

> `Conj(Z)` := map(x->conjugate(x), Z) : `conj(Z)` = matrix(`Conj(Z)`) ;

* * *

N.B. A complex matrix, which satisfies the condition

[ H ] = Transp(Conj [ H ] )

is called the Hermitian matrix.

Exemplarily, consider a ( ื ) complex matrix [ H ] given as

> H := matrix(3, 3, [1, 2+3*I, 1-6*I, 2-3*I, 3, 0, 1+6*I, 0, 5]) : H = matrix(H) ;

The transpose of the conjugate of the matrix, Transp(Conj [ H ] ) , is the following ( ื ) matrix

> `transp(conj(H))` := transpose(evalm(conjugate(H))) : Transp(Conj(H)) = matrix(`transp(conj(H))`) ;

which is equal to the complex matrix [ H ].

The determinant of the Hermitian matrix is a real number, viz.

> `det(H)` := det(H) : Det(H) = `det(H)` ;

[ Refer also to Unit (21) for the eigenvalues of the Hermitian matrix, which are real. ]

* * *

N.B. The absolute value of the complex conjugate of a complex matrix is equal to the absolute value of the matrix

or

Exemplarily, consider the ( ื ) complex matrix [ Z ] used earlier and its complex conjugate.

(a) The absolute value of the matrix [ Z ] is the following ( ื ) matrix:

> `abs(Z)` := evalm(abs(Z)) : abs(Z) = matrix(`abs(Z)`) ;

(b) The absolute value of the complex conjugate of the matrix [ Z ] is the following ( ื ) matrix:

> `abs(conj(Z))` := evalm(abs(conjugate(Z))) : abs(Conj(Z)) = matrix(`abs(conj(Z))`) ;

Both matrices of (a) and (b) are equal.

* * *

N.B. The complex conjugate of a complex matrix raised to the power (or the reciprocal of the complex conjugate) is a matrix equal to the inverse of the complex matrix

/ Conj [ Z ] = Inv [ Z ]

Exemplarily, consider the same ( ื ) complex matrix [ Z ] and its complex conjugate.

(a) The reciprocal of the complex conjugate, / Conj [ Z ], is the following ( ื ) matrix:

> `1/conj(Z)` := evalm(1/conjugate(Z)) : 1/Conj(Z) = matrix(`1/conj(Z)`) ;

or, as a floating-point approximation to four significant digits,

> `1/conj(Z)` := evalf(matrix(`1/conj(Z)`), 4) : 1/Conj(Z) = matrix(`1/conj(Z)`) ;

(b) The inverse of the complex matrix, Inv [ Z ], is the following ( ื ) matrix:

> `inv(Z)` := inverse(Z) : Inv(Z) = matrix(`inv(Z)`) ;

or, as a floating-point approximation to four significant digits,

> `inv(Z)` := evalf(matrix(`inv(Z)`), 4) : Inv(Z) = matrix(`inv(Z)`) ;

Both resultant matrices are equal.

* * *

N.B. The conjugate of a complex matrix raised to an integer power ( positive or negative ) is equal to the conjugate raised to the same power

Conj( [ Z ] ^ ) = (Conj [ Z ] )^

Exemplarily, consider the same ( ื ) complex matrix [ Z ] and its complex conjugate. Let .

> n := 2 :

(a) The conjugate of the matrix squared, Conj( [ Z ] ^ ) , is the following ( ื ) matrix:

> `conj(Z^2)` := map(conjugate, evalm(Z^n)) : Conj(Z^2) = matrix(`conj(Z^2)`) ;

(b) The matrix conjugate squared, (Conj [ Z ] )^ , is the following ( ื ) matrix:

> `(conj(Z))^2` := evalm(`Conj(Z)`^2) : [Conj(Z)]^n = matrix(`(conj(Z))^2`) ;

Both resultant matrices are equal.

* * *

N.B. The sum of a complex matrix and its conjugate is a real matrix whose elements are doubled real parts of the elements of the complex matrix

[ Z ] + Conj [ Z ] = Re [ Z ]

Exemplarily, consider the same ( ื ) complex matrix [ Z ] and its complex conjugate.

(a) The sum [ Z ] + Conj [ Z ] is the following ( ื ) real matrix:

> `Z+conj(Z)` := evalm(Z + `Conj(Z)`) : Z + Conj(Z) = matrix(`Z+conj(Z)`) ;

(b) The product Re [ Z ] is the following ( ื ) real matrix:

> `2Re(Z)` := evalm(2 * `Re(Z)`) : 2 * `Re(Z)` = matrix(`2Re(Z)`) ;

Both resultant matrices are equal.

* * *

N.B. The difference of a complex matrix and its conjugate is a complex matrix whose elements are doubled imaginary parts of the elements of the complex matrix multiplied by the imaginary unit

[ Z ] – Conj [ Z ] = Im [ Z ] I

Exemplarily, consider the ( ื ) complex matrix [ Z ] and its complex conjugate.

(a) The difference [ Z ] – Conj [ Z ] is the following ( ื ) complex matrix:

> `Z-conj(Z)` := evalm(Z - `Conj(Z)`) : Z - Conj(Z) = matrix(`Z-conj(Z)`) ;

(b) The product Im [ Z ] I is the following ( ื ) complex matrix:

> `2Im(Z) I` := evalm(2*`Im(Z) I`) : 2 * `Im(Z) I` = matrix(`2Im(Z) I`) ;

Both resultant matrices are equal.

* * *

N.B. Unlike the product of a complex number and its conjugate , where , the product of a complex matrix and its conjugate , [ Z ] Conj [ Z ], yields a complex matrix, which is equal to the conjugate of the product of the matrix conjugate and the matrix

[ Z ] Conj [ Z ] = Conj{Conj [ Z ] [ Z ] }

Exemplarily, consider the same ( ื ) complex matrix [ Z ] and its complex conjugate.

(a) The product [ Z ] Conj [ Z ] is the following ( ื ) complex matrix:

> `Z conj(Z)` := multiply(Z, `Conj(Z)`) : Z*Conj(Z) = matrix(`Z conj(Z)`) ;

(b) The conjugate of the product of the matrix conjugate and the matrix, Conj{Conj [ Z ] [ Z ] } , is the following ( ื ) complex matrix:

> `conj(conj(Z) Z)` := map(conjugate, multiply(`Conj(Z)`, Z)) :

> Conj(`Conj(Z)`*Z) = matrix(`conj(conj(Z) Z)`) ;

Both resultant matrices are equal.

* * *

N.B. The product of the conjugate of a complex matrix and the matrix is equal to the conjugate of the product of the matrix and its conjugate

(Conj [ Z ] ) [ Z ] = Conj{ [ Z ] Conj [ Z ] }

Exemplarily, consider the same ( ื ) complex matrix [ Z ] and its complex conjugate.

(a) The product (Conj [ Z ] ) [ Z ] is the following ( ื ) complex matrix:

> `conj(Z) Z` := multiply(`Conj(Z)`, Z) : `Conj(Z)` * Z = matrix(`conj(Z) Z`) ;

(b) The conjugate of the product of the matrix and its conjugate, Conj{ [ Z ] Conj [ Z ] } , is the following ( ื ) complex matrix:

> `conj(Z conj(Z))` := map(conjugate, multiply(Z, `Conj(Z)`)) :

> Conj(Z*Conj(Z)) = matrix(`conj(Z conj(Z))`) ;

Both resultant matrices are equal.

* * *

N.B. The sum of the product of a complex matrix and its conjugate and of the product of the matrix conjugate and the matrix is a matrix whose all elements are real numbers

[ Z ] Conj [ Z ] + (Conj [ Z ] ) [ Z ] = [ real elements ]

Exemplarily, consider the same (