Hadamard Lemma and commutators algebra

Question

I would like to implement the following formula, which goes under the name of Hadamard Lemma:

$ e^A \, B \, e^{-A} = \sum_{k=0}^{+\infty} \frac{1}{k!} [A,B]_k $

where

$ [A,B]_0 = B , \quad [A,B]_1=[A,B], \quad [A,B]_2=[A,[A,B]], \quad \dots $

Of course $[A,B]$ is the standard commutator: $[A,B]=AB-BA$.

The first big problem is how to define my own operator algebra $\mathcal{A}= \{A,B,C\}$. In other words, I would like to be able to define the constitutive commutators of my own algebra. For example:

$ [A,B]=C, \quad [B,C]=A, \quad [C,A]=B $

And then of course, I would like to implement Hadamard Lemma. To be more precise, I would like to write a function, Rotation[X_,Y_] with X,Y $\in \mathcal{A}$ which outputs:

$ \sum_{k=0}^{+\infty} \frac{1}{k!} [X,Y]_k $

Example:

Let's consider angular momentum algebra, whose defining commutators are:

$ [L_1,L_2]=i L_3, \quad [L_2,L_3]=i L_1, \quad [L_3,L_1]=iL_2 \quad $

It's well known that

$e^{i\varphi L_2}L_1e^{-i\varphi L_2} = L_1\cos \varphi +L_3 \sin \varphi $

The way one can manually prove this relation is straightforward:

$\sum_{k=0}^{+\infty} \frac{(i\varphi)^k}{k!} [L_2,L_1]_k = L_1 + i\varphi[L_2,L_1]+\frac{(i\varphi)^2}{2}[L_2,[L_2,L_1]] + \dots =$

$ = L_1 + i\varphi(-iL_3) +\frac{(i\varphi)^2}{2} [L_2, (-i L_3)]+\dots = $

$= L_1 +\varphi L_3 -\frac{\varphi^2}{2} L_1 + \dots =$

And than one recognizes the Taylor series of $\sin$ and $\cos$:

$L_1 \cos \varphi+ L_3 \sin \varphi$

Well, I would like to implement this computation on Mathematica, starting from an user-defined commutator algebra.

Answer 1

One should really use commutator rather than Commutator for future-proofing concerns, but I have some bad habits...

Clear[Commutator]

(* Manually implement the algebra of interest: *)

Commutator[L1, L2] = I L3; Commutator[L2, L1] = -I L3;
Commutator[L2, L3] = I L1; Commutator[L3, L2] = -I L1;
Commutator[L3, L1] = I L2; Commutator[L1, L3] = -I L2;

(* Implement linearity, so that numbers can be pulled out. *)

Commutator[Times[c_, A__], B_] := c Commutator[Times[A], B] /; NumericQ[c]
Commutator[A_, Times[c_, B__]] := c Commutator[A, Times[B]] /; NumericQ[c]

(* Linearity
[A+B+...,C] = [A,C]+[B,C]+... and [A,B+C+...] = [A,B]+[A,C]+...
*)

Commutator[Plus[A_, Addends__], B_]:=Commutator[A, B] + Commutator[Plus[Addends], B]
Commutator[A_, Plus[B_, Bddends__]]:=Commutator[A, B] + Commutator[A, Plus[Bddends]]

(* Note the reversed ordering! *)
hadamard[order_] := Sum[1/k! Fold[Commutator[#2, #1] &, B, Table[A, {k}]], {k, 0, order}]

NumericQ[\[Phi]] = True;
hadamard[10] /. {B -> L1, A -> I \[Phi] L2}

It is possible to make Commutator naturally antisymmetric in its arguments, but it takes more thinking. If you've got an algebra already it's probably worth writing out explicitly.

We can implement additional rules, but it requires a general implementation of noncommutative multiply. Mathematica has a built-in NonCommutativeMultiply which we can write as an infix operator **. But it requires some additional structure:

Unprotect[NonCommutativeMultiply];
Clear[NonCommutativeMultiply];

(* Flatness causes infinite loop problems for the pattern matcher *)
ClearAttributes[NonCommutativeMultiply, Flat];

(* But one-way flatness is fine. *)
NonCommutativeMultiply[A___, NonCommutativeMultiply[B__], C___] := NonCommutativeMultiply[A, B, C]
(* And if there's only one argument, you can get rid of the NCM wrapper *)
NonCommutativeMultiply[A_] := A
(* And if NCM has nothing in it, evaluate to the empty product. *)
NonCommutativeMultiply[] := 1

(* Distribution of ** over + *)
NonCommutativeMultiply[A___, Plus[B_, Bddends__], C___] := NonCommutativeMultiply[A, B, C] + NonCommutativeMultiply[A, Plus[Bddends], C]

(* Numeric things commute. *)
NonCommutativeMultiply[A___, c_, B___] := c NonCommutativeMultiply[A, B] /; NumericQ[c]
NonCommutativeMultiply[A___, Times[b_, B___], C___] := b NonCommutativeMultiply[A, Times[B], C]/; NumericQ[b]

(* Leibniz rule [AB,C] = A[B,C] + [A,C]B and [A,BC]=B[A,C]+[A,B]C *)
Commutator[NonCommutativeMultiply[A_, B__], C_] := Commutator[A, C] ** NonCommutativeMultiply[B] + A ** Commutator[NonCommutativeMultiply[B], C]
Commutator[A_, NonCommutativeMultiply[B__, C_]] := Commutator[A, NonCommutativeMultiply[B]] ** C + NonCommutativeMultiply[B] ** Commutator[A, C]

You further can add additional rules too, like

Commutator[A_, A_] := 0
Commutator[A_, B_] := A**B - B**A

which allows you to arrive at conclusions like

Commutator[L1, L2 ** L3]
(* I L1 ** L1 - I L2 ** L2 *)

using the above definitions for the specific Commutators given by the specified algebra. Note that you can't derive that it's zero without an additional explicit assumption. This also could let you define products L1**L2 rather than Commutator[L1,L2] if you so desired.

At this point I should point out that this answer is converging towards my answer to https://mathematica.stackexchange.com/a/63880/7936 but also that there's a bug there that I never tracked down.