Non Commutative sorting in Mathematica

Question

I have been trying to do some oscillator algebra in Mathematica and having troubles with sorting and simplifying expressions. I am using the NCAlgebra package which helps to improve the properties of NonCommutativeMultiply in Mathematica. However I have to create a huge list of rules to replace terms using the algebra. This quickly becomes impractical since I get these enormous expressions and I have to sift through the terms to see what simplifies and add more rules.

I have been wondering if there is a way to write a sorting function that would take an elementary expression and change it to a list and then permute the elements of list to sort the expression. I am fairly new to Mathematica but I would eventually like to write a small package which would allow me to these kind of manipulations.

For example, I have terms like $a**b**c**a^\dagger$ where $a$, $b$, $c$, etc. commute with each other but $a**a^\dagger-a^\dagger**a =1$. So I would like to sort things such that all dagger operators are to the left and have Mathematica use the fact that $a$, $b$, $c$ commute to rewrite the expressions. Right now I am assigning rules for every type of term that appears in my calculation but the number of terms has become unmanageable.

Answer 1

The trick here is to take control of the non-commuting operators, and to define your own set of rules. Use prod as the head of each operator product, where prod[x,y] represents x ** y, and you can then define rules for manipulating prod.

Define rules that move $a^\dagger$ to the left in an operator product.

prod[u___, a, ad, v___] := prod[u, ad, a, v] + prod[u, v];
prod[u___, x : b | c, ad, v___] := prod[u, ad, x, v];

then you can evaluate

prod[a, b, c, ad]

(* prod[b, c] + prod[ad, a, b, c] *)

Generalisations of this sort of trick should solve your problem.

Answer 2

One possibility is to use FeynCalc:

[rolfm@localhost ~]$ math
Mathematica 9.0 for Linux x86 (64-bit)
Copyright 1988-2012 Wolfram Research, Inc.

In[1]:= FilePrint@"karan"                                                                                                                                                                                                                                                                    
(*
If FeynCalc is not already installed, do:
Import["http://www.feyncalc.org/install.m"]
*)
$LoadFeynArts=False;
Quiet@Get["HighEnergyPhysics`FeynCalc`"]
FI;
DeclareNonCommutative[a,b,ad,bd];
Commutator[a, ad] = 1;
Commutator[b, bd] = 1;
Commutator[b, ad] = 0;
Commutator[a, bd] = 0;
Commutator[ad,bd] = 0;
Commutator[a,  b] = 0;
DotSimplify[ a.b.ad ] 

In[2]:= <<karan                                                                                                                                                                                                                                                                              
Loading FeynCalc from /home/rolfm/.Mathematica/Applications/HighEnergyPhysics
FeynCalc 8.2.0 Type ?FeynCalc for help or visit http://www.feyncalc.org/
$PrePrint is set to FeynCalcForm. Use FI and FC to change the display format.

Out[2]= b + ad . b . a

Answer 3

It would have helped if you have gives a simple example of what you want.

But you could always do something like

expr = a x^3 + b x^2 + c x + d
Apply[List, expr]
(*  {d, c*x, b*x^2, a*x^3}  *)

Now to sort it, use Sort and you can apply your sorting function, as described in help:

"Sort[list,p] applies the function p to pairs of elements in list to 
determine whether they are in order. The default function p is 
OrderedQ[{#1,#2}]&."

You can also use Permute using some permutation group.

If you give a small example of an input, and what you like to get as output it will help.