Matrix raised to a matrix: $M^N$, is this possible? with $M,N\in M_n(\Bbb K).$

Question

I was wondering if there is such a valid operation as raising a matrix to the power of a matrix, e.g. vaguely, if $M$ is a matrix, is $$ M^N $$ valid, or is there at least something similar? Would it be the components of the matrix raised to each component of the matrix it's raised to, resulting in again, another matrix?

Thanks,

Answer 1

It is possible to define the exponential $$\exp(M) = \sum_{n \ge 0}^{\infty} \frac{M^n}{n!}$$

of any matrix using power series. Similarly, it is possible to define the logarithm $$\log(I + M) = \sum_{n \ge 1} \frac{(-1)^{n-1} M^n}{n}$$

when the above series converges (this is guaranteed for example if the largest singular value of $M$ is less than $1$). We can therefore define $$M^N = \exp(N \log M)$$

by imitating the identity $a^b = e^{b \log a}$ for, say, positive reals, but this won't have good properties unless $N$ and $M$ commute, I think. It's better to consider the exponential and logarithm separately.

As I have discussed elsewhere on math.SE, the fact that the ordinary exponential takes two inputs which are the same type is misleading. Most (but not all) "exponential-type" operations in mathematics take two inputs which are different types.

Answer 2

In addition to the other answers, it is possible to rise any square matrix to the power of any other square matrix (even of different order).

I use the following Mathematica code for this:

Clear["Global`*"]
$PrePrint =.; FormatValues@Matrix = {};
Hold[MakeBoxes[Matrix[a_], StandardForm] ^:= 
    Block[{Internal`$ConvertForms = {}}, 
     TemplateBox[{MakeBoxes[MatrixForm@a][[1, 1, 3]]}, "Matrix", 
      DisplayFunction -> (RowBox@{style@"(", "\[NoBreak]", #, 
           "\[NoBreak]", style@")"} &)]]] /. 
  style[string_] -> StyleBox[string, FontColor -> Red] // ReleaseHold
Unprotect[Dot];
Dot[x_?NumberQ, y_] := x y;
Dot[A_?SquareMatrixQ, B_?SquareMatrixQ] := 
  Matrix[KroneckerProduct[A, 
      IdentityMatrix[LCM[Length[A], Length[B]]/Length[A]]] . 
     KroneckerProduct[B, 
      IdentityMatrix[LCM[Length[A], Length[B]]/Length[B]]]] /; 
   Length[A] != Length[B];
Protect[Dot];
Unprotect[Power];
Power[0, 0] = 1;
Protect[Power];
Matrix /: Matrix[x_?MatrixQ] := 
  First[First[x]] /; x == First[First[x]] IdentityMatrix[Length[x]];
Matrix /: NonCommutativeMultiply[Matrix[x_?MatrixQ], y_] := 
  Dot[Matrix[x], y];
Matrix /: NonCommutativeMultiply[y_, Matrix[x_?MatrixQ]] := 
  Dot[y, Matrix[x]];
Matrix /: Dot[Matrix[x_], Matrix[y_]] := Matrix[x . y];
Matrix /: Matrix[x_] + Matrix[y_] := Matrix[x + y];
Matrix /: x_?NumericQ + Matrix[y_] := 
  Matrix[x IdentityMatrix[Length[y]] + y];
Matrix /: x_?NumericQ Matrix[y_] := Matrix[x y];
Matrix /: Matrix[x_]*Matrix[y_] := Matrix[x . y] /; x . y == y . x;
Matrix /: Power[Matrix[x_?MatrixQ], y_?NumericQ] := 
  Matrix[MatrixPower[x, y]];
Matrix /: Power[Matrix[x_?MatrixQ], Matrix[y_?MatrixQ]] := 
  Exp[Log[Matrix[x]] . Matrix[y]];
Matrix /: Log[Matrix[x_?MatrixQ], Matrix[y_?MatrixQ]] := 
 Log[Matrix[x]]^-1 . Log[Matrix[y]]
Matrix /: Dot[Matrix[A_?SquareMatrixQ], Matrix[B_?SquareMatrixQ]] := 
 Matrix[KroneckerProduct[A, 
    IdentityMatrix[LCM[Length[A], Length[B]]/Length[A]]] . 
   KroneckerProduct[B, 
    IdentityMatrix[LCM[Length[A], Length[B]]/Length[B]]]]

$Post2 = 
  FullSimplify[# /. 
     f_[args1___?NumericQ, Matrix[mat_], args2___?NumericQ] :> 
      Matrix[MatrixFunction[f[args1, #, args2] &, mat]]] &;
$Post = Nest[$Post2, #, 3] /. Dot -> NonCommutativeMultiply &;

Now one can use something like this:

Matrix[ {
    {0, 1},
    {1, 0}
   } ] ^ Matrix[ {
    {0, 0, 1},
    {1, 0, 0},
    {0, 1, 0}
   } ]

And get the result. Note though, the computation takes long time and the result may be huge in volume and include Root objects.