initial implementation of sympy.physics.quantum.pauli, containing the pauli sigma operators and states that they act on
made pauli operators commute with boson operators
fix bug in use of warnings module. improved support for normal ordering expression of products of mix of differetnt types of operators
improved support for simplification of products that includes an identity operator
Fixed bug in handling of non-operator base Pow instances in sympy.physics.quantum.operatorordering
support for indices for Pauli operators the in quantum.pauli module
Added docstring to lambdified functions

If arguments have names, that is used. Otherwise the stack is inspected
to determine if the name can be inferred *with certainty*. If there is
more than one variable pointing to the object, then the name cannot be
determined with certainty, and 'arg_#', where '#' is the number of the
arg is used.
Removed unused "tests" variable.  setup() now uses find_packages()
Adopt classifiers to include py3.4
Document where should be changed __version__
Re-use sympy.__doc__ as the long_description kwarg for setup()
Don't use setup_args, use setup() kwargs directly
Relational: Unify `Lt` and `<`, a fix for pr #7783

Make long form and symbolic operators take the same path through the code.
This effects `Lt`, `Gt`, `Ge`, `Le`, their longer forms (`StrictLessThan`,
etc) and the symbolic versions (`<`, etc) which call `__lt__` etc.

Here is an outline of the approach:

1. If we come via `__lt__` than we do all we can to reduce to bool or
raise exception.  This can go through several classes' `__lt__` methods,
but in the end (currently `Expr.__lt__`) we ask `Lt` to make a
non-evaluated inequality with `evaluated=False`.

2. On the other hand, if we come from `Lt(lhs, rhs)`, we first ask
`lhs.__lt__(rhs)`.  Which will then either return a boolean, raise an
exception or eventually call `Lt` again but with `evaluated=False` as
above.

In this fashion, we always have the same result whichever form we called.
test_relational: fix some incorrect tests

`Gt(I, 2)` is supposed to raise TypeError, not give `false`.
Inequalities: UnXFAIL tests from pr #7783
Relational: don't use symbol ops `<` in `Lt` lest it reorder arguments

I encountered and filed issue #7951, where `x < p` can become `p > x`
even when both are sympified.  This adds tests.  Issue causes failures
in `meijerint._condsimp` and more specifically `subs` where an `cls=Wild`
variable was substituted for a regular symbol in an Inequality.

As a workaround (which is probably safer against this sort of bug), we
call `__lt__` and friends instead of the symbols.
test_relational: better tests for ineq flip test

Perhaps issue 7951 not fixable, so replace XFAIL test with a test
that specifically tests the workaround I put in place.
Relational: if simplify lhs/rhs not enough, try harder with equals(0)

Call `_eval_sides` when simplifying inequalities (this can be expensive
so we first try the existing simplify lhs/rhs approach).

A consequence of unifying `Lt` and `<` (the fix for pr #7783) is that
`_eval_sides` is no longer called in `Relational.__new__`.  Sometimes
this meant inequalities did not reduce to boolean when they did before.
Now we have the essentially the same code: if an expression previously
reduced to bool upon creation, it should now do so after simplify().
fix tests that fail due to Inequalities no longer simplifying automatically

Just a matter of putting `simplify()` around them.
solve_univariate_inequality: simplify inequalities after subs

Inequalities no longer simplify automatically, which caused some test
failures.  Add `simplify` calls to prevent this.  Only one of these lines
explicitly lead to failures; but other two lines are similar so changed
those as well.