5

In short, I have an expression that contains multiplications between p1, p2, q1 and q2, and I'd like to use [qi,pi]=ii*hb, where i={1,2} to get the expression to a symmetric form (pi^a*qi^b+qi^b*pi^a)/2.

So for example, for p2*q2*p2^2 I get (p2*q2^3+q2^3*p2)/2 + 1/2*ii*p2^2*hb using simplification and some replacements. But I cannot simplify q2*q1^2*p2 although I have specified a rule q2*p2-> (p2*q2+q2*p2)/2 +ii/2*hb and that variables with 1s and 2s commute.

In more detail, here is the Mathematica code (I use the quantum package).

The code works when the index is either 1 or 2 but doesn't work when both indexes are used:

p2*q2*q1*q2 gives p2*q1*q2^2, p2*q2*q2 can further be simplified but since there is q1, Mathematica doesn't do it.

In even more detail: I'm trying to write a Mathematica code that can get equations in appendix (eq. A2) in this paper and this is the code that I'm using. The code in latter file is a little different from the code above because I couldn't get the code above to run as well but it would be ideal.

In the end I'd like to use the final code for other kind of Hamiltonians up to 4th power or even higher.

I'd love an advice how I can learn how to write a package that can do targeted simplifications for me.

Floern
  • 33,559
  • 24
  • 104
  • 119
kirill_igum
  • 3,953
  • 5
  • 47
  • 73
  • 1
    I have to say that Mathematica is not the best tool for what you are trying to do. At heart Mathematica is a giant search-replace engine and works best if you don't specifically care about the formatting of the output. That said see my answer for some hint on how to go about this. – Timo Oct 18 '10 at 11:35

1 Answers1

6

If you are just using rules to simplify (and I'm assuming that you mean that you use Replace[]) then there can be problems if the pattern you want to replace is present but not in the exact correct form. E.g., your example of Replace[q2*q1^2*p2,q2*p2->(p2*q2+q2*p2)/2] which will do nothing in this case (Note that writing q2*p2*q1^2 won't help either since Mathematica sorts all input before starting evaluation.

I have in the past encountered similar simplification problems with Mathematica and there are two strategies that have yielded reasonable success. I'm sorry I can't give you a specific solution, I hope these help you figure it out.

Solution 1: You have to write your own ReplaceUnordered[form,rule] function that parses through all the different orderings of form for possible applications of rule. This can be done with Permutations[] and the use of HoldForm[].

Solution 2: Use Simplify[]. Specifically use the option ComplexityFunction to make non-symmetrical expressions more "expensive", and the option TransformationFunctions to specify your own simplification rules.

Here (pdf) is a nice short(ish) introduction to Mathematica and it's constructs and the evaluation process.

Extra Bonus Solution: Use FORM which is a language written specifically to solve the problem you are having.

EDIT: Extra Extra Bonus (possibly very easy) Solution: As rcollier pointed out SymmetricReduction[] might do what you want very easily.

And one more for the road: When I have had to do calculations with non-commutative variables I have used this package which contains algebra and calculus for Grassmann variables.

Community
  • 1
  • 1
Timo
  • 4,246
  • 6
  • 29
  • 42
  • +1, for `ComplexityFunction` and `TransformationFunctions`. I've been using Mathematica for years, and only within the last 2 have I discovered the usefulness of these two options. – rcollyer Oct 18 '10 at 12:24
  • Thanks, and yes, Simplify is very good if you know how to use those two, the one additional thing I would (figuratively) give an arm for is for Simplify to support `levelspec` like targeting. – Timo Oct 18 '10 at 19:12
  • 1
    Just to point out, the `Simplify` documentation gives an example using `PolynomialReduce` in the `TransformationFunctions`. For the OP's problem, `SymmetricReduction` will most likely give the results they're looking for. – rcollyer Oct 18 '10 at 19:23