MathGroup Archive 2004

[Date Index] [Thread Index] [Author Index]

Search the Archive

RE: Defining anti-symmetric operation. New ideas requested.

By an error of mine, this did not reach MathGroup. The basic idea is the
same as communicated by Daniel Lichtblau (and sketched by Jens-Peer Kuska),
namely to convert any expression with Commute to a "normal form", which
contains the definition (or the default). This then avoids infinite
recursion. Here below a slightly polished version of my attempt.

>-----Original Message-----
>From: Oleksandr Pavlyk [mailto:pavlyk at]
To: mathgroup at
>Sent: Wednesday, March 31, 2004 9:58 AM
>To: mathgroup at
>Subject: [mg47313] [mg47223] Defining anti-symmetric operation. New ideas
>Dear MathGroup,
>In order to explain the problem I would need to
>say few words about what I am trying to accomplish.
>So please bear with me.
>I am often define bare bones of a Lie algebra,
>and check its consistency by Mathematica. To that
>end I have some generators, and I define their
>commutation relation. As an example let us take
>SU(2) with 3 generators  H[], X[], Y[]
>To define the algebra I write
>    Commute[ H[], X[] ] = Y[]
>    Commute[ X[], Y[] ] = H[]
>    Commute[ Y[], H[] ] = X[]
>now because of properties of Commute,
>Commute[ OperatorA, OperatorB ] = - Commute[OperatorB, OperatorA]
>So far I am realizing this property by defining
>    Commute[ X[], H[] ] := -Commute[ H[], X[] ]
>    Commute[ Y[], X[] ] := -Commute[ X[], Y[] ]
>    Commute[ H[], Y[] ] := -Commute[ Y[], H[] ]
>So I come to my question. I would like Mathematica to
>define automatically
>    Commute[OperatorB, OperatorA]
>every time I define Commute[OperatorA, OperatorB].
>I tried to approach the problem by examining
>DownValues of Commute.
>(* This is evaluated if no direct definition was matched *)
>Commute[a_, b_]:=Module[{res},
>   res = HoldComplete[Commute[b,a]]/.DownValues[Commute];
>   If[ res === HoldComplete[Commute[b,a]], (* If nothing in 
>DownValues *)
>         Return[0]      (* we declare everything else commuting *)
>       ,
>         Return[ -ReleaseHold[res] ]
>   ]
>This definition indeed gives Commute[ X[], H[] ] = -Y[], but if I try
>it on some undefined generators
>   Commute[ J[], H[] ]
>I get infinite recursion, which is there because the very definition
>of trick solving part of Commute is also in DownValues, and 
>hence we get
>  res = HoldComplete[ Module[{},.... ] ]
>Any ideas on how to encode anti-symmetric properties of Commute would
>be very appreciated.
>I am sorry for slightly long post. The Mathematica notebook with the
>code is posted at
>Thank you,

An idea:
define the anticommuting property with respect to normal order:

In[2]:= Commute[a__] := Signature[{a}]Sort[Unevaluated[Commute[a]]]

If there is no definition for normal order, things commute:

In[3]:= Commute[a__] /; OrderedQ[{a}] := 0 

You now may work, but have to adhere to a strict discipline as to set up
definitions only in normal order. This certainly is inconvenient. Else we
might try to convert to normal order at definiton time:

Commute /: Set[Commute[a__], c_] /; ! OrderedQ[{a}] := 
  With[{normalOrderedArg = Sequence @@ Sort[{a}]},
    Commute[normalOrderedArg] = Signature[{a}] c]

Now your definitions: Define commutation relations for SU(2)

In[5]:= Commute[H[], X[]] = Y[];

In[6]:= Commute[X[], Y[]] = H[];

In[7]:= Commute[Y[], H[]] = X[];

The last one is not given in normal order, let's see what happens:

In[8]:= Commute[H[], X[]]
Out[8]= Y[]

In[9]:= Commute[X[], H[]]
Out[9]= -Y[]

In[10]:= Commute[X[], Y[]]
Out[10]= H[]

In[11]:= Commute[Y[], X[]]
Out[11]= -H[]

In[12]:= Commute[Y[], H[]]
Out[12]= X[]

In[13]:= Commute[H[], Y[]]
Out[13]= -X[]

In[14]:= Commute[J[], H[]]
Out[14]= 0

It appears to work; but what had been defined effectively?

In[16]:= ?Commute
>From In[16]:= 
>From In[16]:=
 (Commute[a__] = c_) /; ! OrderedQ[{a}] ^:= 
  With[{normalOrderedArg = Sequence @@ Sort[{a}]}, 
    Commute[normalOrderedArg] = Signature[{a}] c]

 Commute[H[], X[]] = Y[]

 Commute[H[], Y[]] = -X[]

 Commute[X[], Y[]] = H[]

 Commute[a__] /; OrderedQ[{a}] := 0

 Commute[a__] := Signature[{a}] Sort[Unevaluated[Commute[a]]]

If you want to to define Commute only for two arguments, just replace
everywhere Commute[a__] by Commute[a_,b_], and {a} by {a,b}, Commute[a] by

Hartmut Wolf

  • Prev by Date: Re: Finding all cycles in a graph
  • Next by Date: Signals and Systems Package
  • Previous by thread: Re: Defining anti-symmetric operation. New ideas requested.
  • Next by thread: Plot bug?