# Sympy: working with equalities manually

I'm currently doing a maths course where my aim is to understand the concepts and process rather than crunch through problem sets as fast as possible. When solving equations, I'd like to be able to poke at them myself rather than have them solved for me.

Let's say we have the very simple equation z + 1 = 4- if I were to solve this myself, I would obviously subtract 1 from both sides, but I can't figure out if sympy provides a simple way to do this. At the moment the best solution I can come up with is:

```from sympy import *
z = symbols('z')
eq1 = Eq(z + 1, 4)
Eq(eq1.lhs - 1, eq1.rhs - 1)
# Output:
# z == 3
```

Where the more obvious expression eq1 - 1 only subtracts from the left-hand side. How can I use sympy to work through equalities step-by-step like this (i.e. without getting the solve() method to just given me the answer)? Any pointers to the manipulations that are actually possible with sympy equalities would be appreciated.

There is a "do" method and discussion at https://github.com/sympy/sympy/issues/5031#issuecomment-36996878 that would allow you to "do" operations to both sides of a Equality. It's not been accepted as an addition to SymPy but it is a simple add-on that you can use. It is pasted here for convenience:

```def do(self, e, i=None, doit=False):
"""Return a new Eq using function given or a model
model expression in which a variable represents each
side of the expression.

Examples
========

>>> from sympy import Eq
>>> from sympy.abc import i, x, y, z
>>> eq = Eq(x, y)

When the argument passed is an expression with one
free symbol that symbol is used to indicate a "side"
in the Eq and an Eq will be returned with the sides
from self replaced in that expression. For example, to
add 2 to both sides:

>>> eq.do(i + 2)
Eq(x + 2, y + 2)

To add x to both sides:

>>> eq.do(i + x)
Eq(2*x, x + y)

In the preceding it was actually ambiguous whether x or i
was to be added but the rule is that any symbol that are
already in the expression are not to be interpreted as the
dummy variable. If we try to add z to each side, however, an
error is raised because now it is unclear whether i or z is being

>>> eq.do(i + z)
Traceback (most recent call last):
...
ValueError: not sure what symbol is being used to represent a side

The ambiguity must be resolved by indicating with another parameter
which is the dummy variable representing a side:

>>> eq.do(i + z, i)
Eq(x + z, y + z)

Alternatively, if only one Dummy symbol appears in the expression then
it will be automatically used to represent a side of the Eq.

>>> eq.do(2*Dummy() + z)
Eq(2*x + z, 2*y + z)

It is also possible to do Eq/Eq operations:
>>> eq.do(i + Eq(x, 2))
Eq(2*x, y + 2)

Operations like differentiation must be passed as a
lambda:

>>> Eq(x, y).do(lambda i: i.diff(x))
Eq(1, 0)

Because doit=False by default, the result is not evaluated. to
evaluate it, either use the doit method or pass doit=True.

>>> _.doit == Eq(x, y).do(lambda i: i.diff(x), doit=True)
True
"""
if not isinstance(e, (FunctionClass, Lambda, type(lambda:1))):
e = S(e)
if len(e.args) == 2:
a, b = e.args
if isinstance(a, Equality)  or isinstance(b, Equality):
if isinstance(b, Symbol):
return self.func(e.func(a.lhs, self.lhs),
e.func(a.rhs, self.rhs), evaluate=doit)
if isinstance(a, Symbol):
return self.func(e.func(self.lhs, b.lhs),
e.func(self.rhs, b.rhs), evaluate=doit)
raise ValueError('expecting 1 arg to be a symbol')
imaybe = e.free_symbols - self.free_symbols
if not imaybe:
raise ValueError('expecting a symbol')
if imaybe and i and i not in imaybe:
raise ValueError('indicated i not in given expression')
if len(imaybe) != 1 and not i:
d = [i for i in i if isinstance(i, Dummy)]
if len(d) != 1:
raise ValueError(
'not sure what symbol is being used to represent a side')
i = set(d)
i = i.pop()
f = lambda side: e.subs(i, side)
else:
f = e
return self.func(*[f(side) for side in self.args], evaluate=doit)

from sympy.core.relational import Equality
Equality.do = do
```

### How to get the current opened stage in JavaFX?

Is there a way to get the current opened Stage in JavaFX, if there is one open?

### Method cannot be applied to java.lang.Object (should accept object of specific class as argument)

I'm trying to get a string from the content of an object with a custom method in my Android application. The object is an instance of the class Game and is contained in an arraylist: