Expression transformation problem

Question

Let's say we have the following statement: s = 3 * a * b - 2 * c, where s, a, b and c are variables. Also, we used Shunting Yard algorithm to build RPN expression, so now we can assign values to variables a, b and c and calculate s value by using simple RPN evaluator.

But, the problem is that I should be able to calculate a value of any variable a, b or c when values of all other variables are set.

So, I need to transform existing expression somehow to get a set of expressions:

a = (s + 2 * c) / (3 * b)
b = (s + 2 * c) / (3 * a)
c = (3 * a * b - s) / 2

How can I generate such expressions on basis of one original statement? Is there any standard approaches for solving such problems?

Constraints:

1. A set of available operators: +, -, *, /, including unary + and -
2. operators *, / and = can't have the same variable on both sides (e.g. s = a * a, or s = a + s are not acceptable)

Thanks

Answer 1

See this first: Postfix notation to expression tree to convert your RPN into a tree.

Once you have the equation left expression = right expression change this to left expression - right expression = 0 and create a tree of left expression - right expression via Shunting Yard and the above answer. Thus when you evaluate the tree, you must get the answer as 0.

Now based on your restrictions, observe that if a variable (say x) is unknown, the resulting expression will always be of the form

(ax + b)/(cx + d) where a,b,c,d will depend on the other variables.

You can now recursively compute the expression as a tuple (a,b,c,d).

In the end, you will end up solving the linear equation

(ax + b)/(cx + d) = 0 giving x = -b/a

This way you don't have to compute separate expressions for each variable. One expression tree is enough. And given the other variables, you just recursively compute the tuple (a,b,c,d) and solve the linear equation in the end.

The (incomplete) pseudocode will be

TupleOrValue Eval (Tree t) {

       if (!t.ContainsVariable) {
           blah;
           return value;
       }

       Tuple result;

       if (t.Left.ContainsVariable) {
            result = Eval(t.Left);  
            value = Eval(t.Right);

            return Compose(t.Operator, result, value);      
       } else {
            result = Eval(t.Right);  
            value = Eval(t.Left);

            return Compose(t.Operator, result, value);      
       }
}

Tuple Compose(Operator op, Tuple t, Value v) {

    switch (op) {

        case 'PLUS': return new Tuple(t.a + v*t.c, t.b + v*t.d, t.c, t.d);
                    // (ax+b)/(cx+d) + v = ( (a + vc)x + b + dv)/(cx + d)
        // blah
    }
}

For an example, if the expression is x+y-z = 0. The tree will be

     +
    /  \
   x    -
       / \
       y  z

For y=5 and z=2.

Eval (t.Right) will return y-z = 3 as that subtree does not contain x.

Eval(t.Left) will return (1,0,0,1) which corresponds to (1x + 0)/(0x + 1). Note: the above pseudo-code is incomplete.

Now Compose of (1,0,0,1) with the value 3 will give (1 + 3*0, 0 + 3*1, 0, 1) = (1,3,0,1) which corresponds to (x + 3)/(0x + 1).

Now if you want to solve this you take x to be -b/a = -3/1 = -3

---

I will leave the original answer:

In general it will be impossible.

For instance consider the expression

x*x*x*x*x + a*x*x*x*x + b*x*x*x + c*x*x + d*x = e

Getting an expression for x basically corresponds to find the roots of the polynomial

x⁵ + ax⁴ + bx³ + cx² + dx -e

which has been proven to be impossible in general, if you want to use +,-,/,* and nth roots. See Abel Ruffini Theorem.

Are there are some restrictions you forgot to mention, which might simplify the problem?

Answer 2

The basic answer is you have to apply algebra to the set of equations you have, to produce equations that you want.

In general, if you start with this symbolic equation:

s = 3 * a * b - 2 * c

and you add constraints for s, a, and c:

s = ...
a = ...
c = ...

you need to apply standard laws of algebra to rearrange the set of equations to produce what you want, in this case, a formula for b:

b = ...

If you add different constraints, you need the same laws of algebra, applied in different ways.

If your equations are all of the form (as your example is not) of

left_hand_side_variable_n = combination_of_variables

then you can use rules for solving simultaneous equations. For linear combinations, this is pretty straightforward (you learned how to do this high school). And you can even set up a standard matrix and solve using a standard solver package without doing algebra.

If the equations are not linear, then you may not be able to find a solution no matter how good your math is (see other answers for examples). To the extent it is possible to do so, you can use a computer algebra system (CAS) to manipulate formulas. They do so by representing the formulas essentially as [math] abstract syntax trees, not as RPN, and apply source-to-source transformation rules (you would call these "algebra rules" from high school). They usually have a pretty big set of built-in rules ("knowledge") already. Some CAS will attempt to solve such systems of equations for you using the built-in rules; others, you have to tell what sequence of algebraic laws to apply in what order.

You may also use a constraint solver, which is a special kind of computer algebra system focused only on answering the kind of question you've posed, e.g., "with this set of constraints, and specific values for variables, what is the value of other variables?". These are pretty good if your equations follows the forms they are designed to solve; otherwise no gaurantee but that's not surprising.

One can also use a program transformation system, which manipulate arbitrary "syntax trees", because algrebra trees are just a special case of syntax trees. To use such a system, you define the langauge to be manipulated (e.g., conventional algebra) and the rules by which it can be manipulated, and the order in which to apply the rules. [The teacher did exactly this for you in your intro algebra class, but not in such a formal way] Here's an example of a my program transformation system manipulating algebra. For equation solving, you want much the same rules, but a different order of application.

Finally, if you want to do this in a C++ program, either you have to simulate one of the above more general mechanisms (which is a huge amount of work), or you have narrow what you are willing to solve significantly (e.g., "linear combinations") so that you can take advantage of a much simpler algorithm.

Answer 3

There is a quite straight-forward one for very basic expressions (like in your example) where each variable occurs mostly once and every operator is binary. The algorithm is mostly what you would do by hand.

The variable we are looking for will be x in the following lines. Transform your expression into the form f(...,x,...) == g(...). Either variable x is already on the left hand side or you just switch both sides.

You now have two functions consisting of applications of binary operators to sub-expressions, i.e. f = o_1(e_1,e_2) where each e_i is either a variable, a number or another function e_i = o_i(e_j, e_k). Think of this as the binary tree representation where nodes are operators and leafs are variables or numbers. Same applies for g.

Yyou can apply the following algorithm (our goal is to transform the tree into one representing the expression x == h(...):

while f != x:
    // note: f is not a variable but x is a subexpression of f
    // and thus f has to be of the form binop(e_1, e_2)

    if x is within e_1:
        case f = e_1 + e_2: // i.e. e_1 + e_2 = g
            g <- g - e_2
        case f = e_1 - e_2: // i.e. e_1 - e_2 = g
            g <- g + e_2
        case f = e_1 * e_2: // i.e. e_1 * e_2 = g
            g <- g / e_2
        case f = e_1 / e_2: // i.e. e_1 / e_2 = g
            g <- g * e_2
        f <- e_1
    else if x is within e_2:
        case f = e_1 + e_2: // i.e. e_1 + e_2 = g
            g <- g - e_2
        case f = e_1 - e_2: // i.e. e_1 - e_2 = g
            g <- g + e_2
        case f = e_1 * e_2: // i.e. e_1 * e_2 = g
            g <- g / e_2
        case f = e_1 / e_2: // i.e. e_1 / e_2 = g
            g <- g * e_2
        f <- e_1

Now that f = x and f = g was saved during all steps we have x = g as solution.

In each step you ensure that x remains on the lhs and at the same time you reduce the depth of the lhs by one. Thus this algorithm will terminate after a finite amount of steps.

In your example (solve for b):

1. f = 3a*b*2c*- and g = s
2. f = 3a*b* and g = s2c*+
3. f = b and g = s2c*+3a*/

and thus b = (s + 2*c)/(3*a).

If you have more operators you can extend the algorithm but you might run into problems if they are not invertible.