help-octave
[Top][All Lists]

## mat-by-mat power of commutating matrices

 From: Rolf Fabian Subject: mat-by-mat power of commutating matrices Date: Mon, 24 Jan 2000 12:35:47 +0100

```Hi.

Actually, I had this idea while reflecting the basic quantum-mechanical concept
of ,COMMUTATOR operators' (there, we generally deal with infinite dimensional
operators). I came to the conclusion, that it works also well for (finite
dimensional) matrices.

The basic idea is, that a matrix-by-matrix power
C  =    ( Base B ) ^  ( Exponent A )
is well defined,  if
* either Base and/or  Exponents are scalar
(alreadys handled by octave V2 )

* B ,commutates' with A,                >>> NEW<<<
which means, that the condition
A*B - B*A  == ZERO-MAT
holds. Obviously, this is only possible for
square matrices of same dimension (size).

C = B^A  ?= expm( logm(B)*A )           ( I )
?= expm( A*logm(B) )

In general (e.g. for random element) matrices
the two right sides are different EVEN FOR square
matrices of same size, because logm(B) generally doesn't
,commutate with A', equivalent to
logm(B)*A -A*logm(B) != ZERO      (II)

But if (and only if)
logm(B)*A==A*logm(B),           (III)
the two RHS of (I) are identical, so that that the
result C=B^A is well defined and UNIQUE
(called ,observable' in quantum mechanics).

It can be concluded in general, that requirement (III) is identical to the
condition,
B*A - A*B == ZERO                       (IV)
i.e. in order to check, we don't need to calculate the matrix-logarithm
logm(B)
explicitely.

So in order to calculate a matrix-by-matrix power,
we've to check  for:
* size compatibility (square matrices of same size)
* commutation property (IV) preset

If both checks are successful, the matrix-by-matrix power may be
calculated as   C = expm( logm(B)*A )   -or-  equivalently by
C = expm( A*logm(B) )

Inversion function:     B = C ^ ( inv(A) )
analogous to  scalars  ( may be looked at as matrix-base root generalization)

Today, I've uploaded two scripts to ,octave-sources' which outline
the described extension of the power operator. They're called
* powm.m                ( C= B^A  calculation)
* commutate.m   (commutator check)

Any feedback welcome.

Rolf

PS Today, we had severe problems with our network. Propably, this upload went
to bug-octave too. If this had happened, it was not intended. Sorry.

-----------------------------------------------------------------------
Octave is freely available under the terms of the GNU GPL.

Octave's home on the web:  http://www.che.wisc.edu/octave/octave.html
How to fund new projects:  http://www.che.wisc.edu/octave/funding.html
Subscription information:  http://www.che.wisc.edu/octave/archive.html
-----------------------------------------------------------------------

```