sympy.physics.quantum.pauli

This pull request contains a few minor fixes for the sympy.physics.quantum, and a new module for pauli operators, like sigma x, sigma y, sigma z, and the annihilation and creation operators sigma minus and sigma plus.

The pauli sigma operators are of course a special case of the angular momentum spin J operators, but I think they are deserve operator classes of their own because they are so commonly used. I have been looking at ways of making the new pauli operator classes subclasses of spin J classes, but I found that there was no advantage in doing that, because I had to reimplement all the methods and add new ones. However, earlier this summer when I discussed the  sympy.physics.quantum.fermion and sympy.physics.quantum.boson modules with @ellisonbg I also mentioned that I had worked a bit on these pauli operator classes and he recommended asking @flacjacket for advise and discussion on how these pauli operator classes could be related to the existing spin J operator classes.

So, @flacjacket, if you could have a look at this PR and give comments I would be very grateful. Also @ellisonbg  and @certik might be interested in having a look.

Here are a few ipython notebook that demonstrates a few applications of the new pauli operators implemented in this PR:

http://nbviewer.ipython.org/github/jrjohansson/sympy-quantum-notebooks/blob/master/lecture-sympy-quantum-two-level-system.ipynb

http://nbviewer.ipython.org/github/jrjohansson/sympy-quantum-notebooks/blob/master/lecture-sympy-quantum-atom-cavity.ipynb

http://nbviewer.ipython.org/github/eunjongkim/reproduced-papers/blob/master/Reproduce-PRA-80-033846-2009-Zueco.ipynb
Yes, sometime operator precedence prevents expressions to be fully evaluated, but even in those cases it is relatively simple to simplify expressions further using the standard simplify/expand/etc. It is not completely elegant, but in practice it works pretty well in my experience, so I don't see a big problem with using `__mul__`. But what is it that you suggest to do instead? A special 'pauli_simplify' function that performs these kind of multiplication simplifications? I'm not sure I like that any better than the current solution. It has the disadvantage that the multiplication rules for a certain operators is moved out of the class definition of that operator (where I think it belongs) to this new simplification function that would have to have all the rules for different sigma operators builtin. Another problem with this that I can think of is that in some cases you want to be able to manipulate operators expression without knowing what type of operators are included in the expression (for example in a unitary transformation) and then it becomes messier if operator-specific simplification functions has to be called on the resulting expressions. I think this would become clumsier than the current implementation that uses `__mul__` to automatically take care of this as far as possible.

Also, I don't really agree with your reasoning for not simplifying expressions that have identities that are simplier expressions. In my view the whole point with having specialized classes like BosonOp, SigmaX, SigmaY, etc. is that such simplifications should be made. If you want to demonstrate that `[sx, sy] = sx * sy - sy * sx` then you can define `sx` and `sy` using the base `Operator` class. This is also how the commutation relations work for specialized classes: they don't evaluate to `sx * sy - sy * sx` but to the simplest form of the commutator for the particular operators.

I would also like to make an analogy to how the `Matrix` class in SymPy works. When two matrices are multiplied, the result of the multiplication is shown, not the unevaluated `Mul` expression, and if you really want the expression unevaluated you use `MatMul`. I think quantum operators should behave in this way too. Perhaps there should even be a class `OperatorMul` for unevaluated operator multiplications (although you can already accomplish this by creating instances of `Operator` instead of say `SigmaX` and `SigmaZ`).

Well, this is just my two cents on the topic..