I need to take a simple linear equation, and break out various pieces from it symbolically, and demonstrate that the original equation is still satisfied. For example
x=a+b+c
where a = \sum_{i=0}^N{d_ie_i}{} and b=...
I then want to expand the definition of x and subtract pieces from it, ultimately showing that a new way of calculating x is equivalent to the simple way, but highlights some interesting components.
In my case, I still need to figure out what the new way is. I can do this with a paper and pen, but it will get tedious since the equation I am working with has a lot of pieces and would be error prone. If I make a mistake early on, it will ruin everything that follows.
I am wondering if there is some free software I can use that will ensure that each line of math follows from the previous?
Doesn’t seem like SymPy can deal with the abstract concept of a vector. All vectors need to be concretely defined in terms of its members, as far as I can tell.
Not sure what the problem that you are experiencing is:
>>> from sympy import *
>>> from sympy.abc import x,y,z
>>> d1,d2,d3=symbols('d(1:4)')
>>> e1,e2,e3=symbols('e(1:4)')
>>> a = d1*e1 + d2*e2
>>> a
d1*e1 + d2*e2
>>> b = d2*e2+d3*e3
>>> x = a - b
>>> x
d1*e1 - d3*e3
>>>
Note that nothing need be “concretely defined”, you can work with “symbols”.
If you need more of a kitchen-sink environment you can use Sage instead (already includes Sympy, Maxima, Singular, etc.):
ok, let me try it again. The equations I have written on paper involve indexing vectors and summations with subscripts etc. I should be able to re-write using inner products and element wise products.
If you want to do such things, then another code library (also for the Python programming language, like SymPy) named NumPy might do the trick. In particular, it offers arrays, which are arrangements of numbers of as many dimensions as you want. A one-dimensional array is simply an ordered list of numbers and can be used to represent a vector; a two-dimensional array is a grid of numbers in two dimensions and can be used to represent a matrix. The library comes with a range of functions that allow you to code all sorts of manipulations over your arrays very succinctly.
Numpy (as far as I know) can only do numerical computations. It has no concept of symbolic mathematics.
I ended up just doing this with a pencil and paper.
My ultimate goal here is a set of equations and a proof that a combination of certain relatively complicated equations is equivalent to a much simpler equation.
Numpy could be a package used to implement such equations, not to derive them in the first place.
Can you give a small example of what you are trying to do? Another suggestion is to use Sage; e.g. if you are dealing with vectors in Euclidean space:
sage: E.<x,y,z> = EuclideanSpace()
sage: E
Euclidean space E^3
sage: u = E.vector_field(-y, x, x*y + z, name='u')
sage: u.display()
u = -y e_x + x e_y + (x*y + z) e_z
sage: v = E.vector_field(z, y, 0, name='v')
sage: v.display()
v = z e_x + y e_y
sage: from sage.manifolds.operators import *
sage: w = u.cross(v)
sage: w.display()
u x v = (-x*y^2 - y*z) e_x + (x*y*z + z^2) e_y + (-y^2 - x*z) e_z
sage: w.div()
Scalar field div(u x v) on the Euclidean space E^3
sage: _.display()
div(u x v): E^3 --> R
(x, y, z) |--> -y^2 + x*z - x
sage: u.dot(v.cross(w))
Scalar field u.v x u x v on the Euclidean space E^3
sage: _.display()
u.v x u x v: E^3 --> R
(x, y, z) |--> (x^2 + 1)*y^4 + 2*x*y*z^3 + z^4 + ((x^2 + 1)*y^2 + x^2)*z^2 + 2*(x*y^3 + x*y^2)*z
sage:
The vectors are of unknown size. They could all be size 10, they could all be size 500 etc. The equations involve things like inner products and element wise addition, all operations that can be written down and symbolically manipulated without needing to know the size of the vectors. When I get some time later I will give some concrete examples.