python - Setting Assumptions on Variables in Sympy Relative to Other Variables

Question

I know that sympy in python can set assumptions on variables, such as x is positive, negative, real, complex, etc. I was wondering if sympy can set assumptions on variables relative to other variables. For example, if I have variables x and y, can I set sympy to assume that x > y in its solutions. Or, alternatively, if I have two variables, a and B, can I set sympy to assume that a + 2B < 1? These sorts of assumptions would possibly help sympy simplify complicated solutions to solve() and eigenvectors.

I've looked all over and haven't found information pertaining to setting these kinds of assumptions in sympy.

I ask because I'm attempting to find the eigenvectors of a particular matrix

a,b = symbols('a,b', nonnegative=False)
M = Matrix([ [1-a-2*b, a, b, b], 
             [a, 1-a-2*b, b, b],
             [b, b, 1-a-2*b, a],
             [b, b, a, 1-a-2*b] ])

Sympy finds the eigenvalues correctly

M.eigenvals()

which I've confirmed via MATLAB and WolframAlpha, which all give the same results. However, the eigenvectors are a mess

M.eigenvects()

MATLAB and WolframAlpha both return eigenvectors of [1,1,1,1] [-1,-1,1,1] [0,0,-1,1] [-1,1,0,0], which are the correct eigenvectors. I haven't even tried to simplify sympy's results because they're incredibly long and complex. I suspect it has to do with assumptions on the variables, like specifying that a+2b < 1, but I'm not sure.

Answer 1

I was wondering whether to post this as a comment but it is too long:

Short answer: not in a usable way.

The assumption system of SymPy is kind of a mess right now (version 0.7.2, latest as of May 2013). There is a possibility that it will get better this summer due to a prospective GSoC project, but this is not certain yet.

There are actually two assumption systems within SymPy. The old one, which adds the assumptions to the Symbols themselves (hence causes problems with rebuilding of expression trees) and is called in the constructor (e.g. Symbol(..., positive=True)), and there is the new one, which is based around global variables for the global assumptions and context managers (with assume(...):) for local ones.

Many of the functions within SymPy do check the old assumptions (for instance Abs will check whether the keyword argument positive was set), but there still can be misses. The new assumption system can be more powerful but is almost unused at the moment (except in very recent submodules).

In the old assumption system what you want is not possible. In the new one it is possible, but probably not implemented yet and not used in any parts of SymPy.

So you have two options: help us with the assumption systems or help us with the matrix module. Both can use some more love.