[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

80. to_poly_solve


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

80.1 Functions and Variables for to_poly_solve

The packages to_poly and to_poly_solve are experimental; the specifications of the functions in these packages might change or the some of the functions in these packages might be merged into other Maxima functions.

Barton Willis (Professor of Mathematics, University of Nebraska at Kearney) wrote the to_poly and to_poly_solve packages and the English language user documentation for these packages.

Operator: %and

The operator %and is a simplifying nonshort-circuited logical conjunction. Maxima simplifies an %and expression to either true, false, or a logically equivalent, but simplified, expression. The operator %and is associative, commutative, and idempotent. Thus when %and returns a noun form, the arguments of %and form a non-redundant sorted list; for example

(%i1) a %and (a %and b);
(%o1)                       a %and b

If one argument to a conjunction is the explicit the negation of another argument, %and returns false:

(%i2) a %and (not a);
(%o2)                         false

If any member of the conjunction is false, the conjunction simplifies to false even if other members are manifestly non-boolean; for example

(%i3) 42 %and false;
(%o3)                         false

Any argument of an %and expression that is an inequation (that is, an inequality or equation), is simplified using the Fourier elimination package. The Fourier elimination simplifier has a pre-processor that converts some, but not all, nonlinear inequations into linear inequations; for example the Fourier elimination code simplifies abs(x) + 1 > 0 to true, so

(%i4) (x < 1) %and (abs(x) + 1 > 0);
(%o4)                         x < 1

Notes

Limitations The conjunction %and simplifies inequations locally, not globally. This means that conjunctions such as

(%i5) (x < 1) %and (x > 1);
(%o5)                 (x > 1) %and (x < 1)

do not simplify to false. Also, the Fourier elimination code ignores the fact database;

(%i6) assume(x > 5);
(%o6)                        [x > 5]
(%i7) (x > 1) %and (x > 2);
(%o7)                 (x > 1) %and (x > 2)

Finally, nonlinear inequations that aren't easily converted into an equivalent linear inequation aren't simplified.

There is no support for distributing %and over %or; neither is there support for distributing a logical negation over %and.

To use `load(to_poly_solve)'

Related functions %or, %if, and, or, not

Status The operator %and is experimental; the specifications of this function might change and its functionality might be merged into other Maxima functions.

Operator: %if (bool, a, b)

The operator %if is a simplifying conditional. The conditional bool should be boolean-valued. When the conditional is true, return the second argument; when the conditional is false, return the third; in all other cases, return a noun form.

Maxima inequations (either an inequality or an equality) are not boolean-valued; for example, Maxima does not simplify 5 < 6 to true, and it does not simplify 5 = 6 to false; however, in the context of a conditional to an %if statement, Maxima automatically attempts to determine the truth value of an inequation. Examples:

(%i1) f : %if(x # 1, 2, 8);
(%o1)                 %if(x - 1 # 0, 2, 8)
(%i2) [subst(x = -1,f), subst(x=1,f)];
(%o2)                        [2, 8]

If the conditional involves an inequation, Maxima simplifies it using the Fourier elimination package.

Notes

(%i3) %if(42,1,2);
(%o3)                     %if(42, 1, 2)

Limitations The Fourier elimination code only simplifies nonlinear inequations that are readily convertible to an equivalent linear inequation.

To use: `load(to_poly_solve)'

Status: The operator %if is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Operator: %or

The operator %or is a simplifying nonshort-circuited logical disjunction. Maxima simplifies an %or expression to either true, false, or a logically equivalent, but simplified, expression. The operator %or is associative, commutative, and idempotent. Thus when %or returns a noun form, the arguments of %or form a non-redundant sorted list; for example

(%i1) a %or (a %or b);
(%o1)                        a %or b

If one member of the disjunction is the explicit the negation of another member, %or returns true:

(%i2) a %or (not a);
(%o2)                         true

If any member of the disjunction is true, the disjunction simplifies to true even if other members of the disjunction are manifestly non-boolean; for example

(%i3) 42 %or true;
(%o3)                         true

Any argument of an %or expression that is an inequation (that is, an inequality or equation), is simplified using the Fourier elimination package. The Fourier elimination code simplifies abs(x) + 1 > 0 to true, so we have

(%i4) (x < 1) %or (abs(x) + 1 > 0);
(%o4)                         true

Notes

Limitations The conjunction %or simplifies inequations locally, not globally. This means that conjunctions such as

(%i1) (x < 1) %or (x >= 1);
(%o1) (x > 1) %or (x >= 1)

do not simplify to true. Further, the Fourier elimination code ignores the fact database;

(%i2) assume(x > 5);
(%o2)                        [x > 5]
(%i3) (x > 1) %and (x > 2);
(%o3)                 (x > 1) %and (x > 2)

Finally, nonlinear inequations that aren't easily converted into an equivalent linear inequation aren't simplified.

The algorithm that looks for terms that cannot both be false is weak; also there is no support for distributing %or over %and; neither is there support for distributing a logical negation over %or.

To use `load(to_poly_solve)'

Related functions %or, %if, and, or, not

Status The operator %or is experimental; the specifications of this function might change and its functionality might be merged into other Maxima functions.

Function: complex_number_p (x)

The predicate complex_number_p returns true if its argument is either a + %i * b, a, %i b, or %i, where a and b are either rational or floating point numbers (including big floating point); for all other inputs, complex_number_p returns false; for example

(%i1) map('complex_number_p,[2/3, 2 + 1.5 * %i, %i]);
(%o1)                  [true, true, true]
(%i2) complex_number_p((2+%i)/(5-%i));
(%o2)                         false
(%i3) complex_number_p(cos(5 - 2 * %i));
(%o3)                         false

Related functions isreal_p

To use `load(to_poly_solve)'

Status The operator complex_number_p is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: compose_functions (l)

The function call compose_functions(l) returns a lambda form that is the composition of the functions in the list l. The functions are applied from right to left; for example

(%i1) compose_functions([cos, exp]);
                                        %g151
(%o1)             lambda([%g151], cos(%e     ))
(%i2) %(x);
                                  x
(%o2)                       cos(%e )

When the function list is empty, return the identity function:

(%i3) compose_functions([]);
(%o3)                lambda([%g152], %g152)
(%i4)  %(x);
(%o4)                           x

Notes

(%i5) compose_functions([a < b]);

funmake: first argument must be a symbol, subscripted symbol,
string, or lambda expression; found: a < b
#0: compose_functions(l=[a < b])(to_poly_solve.mac line 40)
 -- an error. To debug this try: debugmode(true);

To use `load(to_poly_solve)'

Status The function compose_functions is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: dfloat (x)

The function dfloat is a similar to float, but the function dfloat applies rectform when float fails to evaluate to an IEEE double floating point number; thus

(%i1) float(4.5^(1 + %i));
                               %i + 1
(%o1)                       4.5
(%i2) dfloat(4.5^(1 + %i));
(%o2)        4.48998802962884 %i + .3000124893895671

Notes

Related functions float, bfloat

To use `load(to_poly_solve)'

Status The function dfloat is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: elim (l, x)

The function elim eliminates the variables in the set or list x from the equations in the set or list l. Each member of x must be a symbol; the members of l can either be equations, or expressions that are assumed to equal zero.

The function elim returns a list of two lists; the first is the list of expressions with the variables eliminated; the second is the list of pivots; thus, the second list is a list of expressions that elim used to eliminate the variables.

Here is a example of eliminating between linear equations:

(%i1) elim(set(x + y + z = 1, x - y  - z = 8, x - z = 1), 
           set(x,y));
(%o1)            [[2 z - 7], [y + 7, z - x + 1]]

Eliminating x and y yields the single equation 2 z - 7 = 0; the equations y + 7 = 0 and z - z + 1 = 1 were used as pivots. Eliminating all three variables from these equations, triangularizes the linear system:

(%i2) elim(set(x + y + z = 1, x - y  - z = 8, x - z = 1),
           set(x,y,z));
(%o2)           [[], [2 z - 7, y + 7, z - x + 1]]

Of course, the equations needn't be linear:

(%i3) elim(set(x^2 - 2 * y^3 = 1,  x - y = 5), [x,y]);
                     3    2
(%o3)       [[], [2 y  - y  - 10 y - 24, y - x + 5]]

The user doesn't control the order the variables are eliminated. Instead, the algorithm uses a heuristic to attempt to choose the best pivot and the best elimination order.

Notes

Related functions elim_allbut, eliminate_using, eliminate

Option variables resultant

To use `load(to_poly)'

Status The function elim is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: elim_allbut (l, x)

This function is similar to elim, except that it eliminates all the variables in the list of equations l except for those variables that in in the list x

(%i1) elim_allbut([x+y = 1, x - 5*y = 1],[]);
(%o1)                 [[], [y, y + x - 1]]
(%i2) elim_allbut([x+y = 1, x - 5*y = 1],[x]);
(%o2)                [[x - 1], [y + x - 1]]

To use `load(to_poly)'

Option variables resultant

Related functions elim, eliminate_using, eliminate

Status The function elim_allbut is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: eliminate_using (l, e, x)

Using e as the pivot, eliminate the symbol x from the list or set of equations in l. The function eliminate_using returns a set.

(%i1) eq : [x^2 - y^2 - z^3 , x*y - z^2 - 5, x - y + z];
               3    2    2     2
(%o1)      [- z  - y  + x , - z  + x y - 5, z - y + x]
(%i2) eliminate_using(eq,first(eq),z);
        3              2      2      3    2
(%o2) {y  + (1 - 3 x) y  + 3 x  y - x  - x , 
                        4    3  3       2  2             4
                       y  - x  y  + 13 x  y  - 75 x y + x  + 125}
(%i3) eliminate_using(eq,second(eq),z);
        2            2       4    3  3       2  2             4
(%o3) {y  - 3 x y + x  + 5, y  - x  y  + 13 x  y  - 75 x y + x
                                                           + 125}
(%i4) eliminate_using(eq, third(eq),z);
        2            2       3              2      2      3    2
(%o4) {y  - 3 x y + x  + 5, y  + (1 - 3 x) y  + 3 x  y - x  - x }

Option variables resultant

Related functions elim, eliminate, elim_allbut

To use `load(to_poly)'

Status The function eliminate_using is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: fourier_elim ([eq1, eq2, …], [var1, var, …])

Fourier elimination is the analog of Gauss elimination for linear inequations (equations or inequalities). The function call fourier_elim([eq1, eq2, ...], [var1, var2, ...]) does Fourier elimination on a list of linear inequations [eq1, eq2, ...] with respect to the variables [var1, var2, ...]; for example

(%i1) fourier_elim([y-x < 5, x - y < 7, 10 < y],[x,y]);
(%o1)            [y - 5 < x, x < y + 7, 10 < y]
(%i2) fourier_elim([y-x < 5, x - y < 7, 10 < y],[y,x]);
(%o2)        [max(10, x - 7) < y, y < x + 5, 5 < x]

Eliminating first with respect to x and second with respect to y yields lower and upper bounds for x that depend on y, and lower and upper bounds for y that are numbers. Eliminating in the other order gives x dependent lower and upper bounds for y, and numerical lower and upper bounds for x.

When necessary, fourier_elim returns a disjunction of lists of inequations:

(%i3) fourier_elim([x # 6],[x]);
(%o3)                  [x < 6] or [6 < x]

When the solution set is empty, fourier_elim returns emptyset, and when the solution set is all reals, fourier_elim returns universalset; for example

(%i4) fourier_elim([x < 1, x > 1],[x]);
(%o4)                       emptyset
(%i5) fourier_elim([minf < x, x < inf],[x]);
(%o5)                     universalset

For nonlinear inequations, fourier_elim returns a (somewhat) simplified list of inequations:

(%i6) fourier_elim([x^3 - 1 > 0],[x]);
               2                             2
(%o6) [1 < x, x  + x + 1 > 0] or [x < 1, - (x  + x + 1) > 0]
(%i7) fourier_elim([cos(x) < 1/2],[x]);
(%o7)                  [1 - 2 cos(x) > 0]

Instead of a list of inequations, the first argument to fourier_elim may be a logical disjunction or conjunction:

(%i8) fourier_elim((x + y < 5) and (x - y >8),[x,y]);
                                              3
(%o8)            [y + 8 < x, x < 5 - y, y < - -]
                                              2
(%i9) fourier_elim(((x + y < 5) and x < 1) or  (x - y >8),[x,y]);
(%o9)          [y + 8 < x] or [x < min(1, 5 - y)]

The function fourier_elim supports the inequation operators <, <=, >, >=, #, and =.

The Fourier elimination code has a preprocessor that converts some nonlinear inequations that involve the absolute value, minimum, and maximum functions into linear in equations. Additionally, the preprocessor handles some expressions that are the product or quotient of linear terms:

(%i10) fourier_elim([max(x,y) > 6, x # 8, abs(y-1) > 12],[x,y]);
(%o10) [6 < x, x < 8, y < - 11] or [8 < x, y < - 11]
 or [x < 8, 13 < y] or [x = y, 13 < y] or [8 < x, x < y, 13 < y]
 or [y < x, 13 < y]
(%i11) fourier_elim([(x+6)/(x-9) <= 6],[x]);
(%o11)           [x = 12] or [12 < x] or [x < 9]
(%i12) fourier_elim([x^2 - 1 # 0],[x]);
(%o12)      [- 1 < x, x < 1] or [1 < x] or [x < - 1]

To use `load(fourier_elim)'

Function: isreal_p (e)

The predicate isreal_p returns true when Maxima is able to determine that e is real-valued on the entire real line; it returns false when Maxima is able to determine that e isn't real-valued on some nonempty subset of the real line; and it returns a noun form for all other cases.

(%i1) map('isreal_p, [-1, 0, %i, %pi]);
(%o1)               [true, true, false, true]

Maxima variables are assumed to be real; thus

(%i2) isreal_p(x);
(%o2)                         true

The function isreal_p examines the fact database:

(%i3) declare(z,complex)$

(%i4) isreal_p(z);
(%o4)                      isreal_p(z)

Limitations Too often, isreal_p returns a noun form when it should be able to return false; a simple example: the logarithm function isn't real-valued on the entire real line, so isreal_p(log(x)) should return false; however

(%i5) isreal_p(log(x));
(%o5)                   isreal_p(log(x))

To use `load(to_poly_solve)'

Related functions complex_number_p

Status The function isreal_p is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: new_variable (type)

Return a unique symbol of the form %[z,n,r,c,g]k, where k is an integer. The allowed values for type are integer, natural_number, real, natural_number, and general. (By natural number, we mean the nonnegative integers; thus zero is a natural number. Some, but not all,definitions of natural number exclude zero.)

When type isn't one of the allowed values, type defaults to general. For integers, natural numbers, and complex numbers, Maxima automatically appends this information to the fact database.

(%i1) map('new_variable,
          ['integer, 'natural_number, 'real, 'complex, 'general]);
(%o1)          [%z144, %n145, %r146, %c147, %g148]
(%i2) nicedummies(%);
(%o2)               [%z0, %n0, %r0, %c0, %g0]
(%i3) featurep(%z0, 'integer);
(%o3)                         true
(%i4) featurep(%n0, 'integer);
(%o4)                         true
(%i5) is(%n0 >= 0);
(%o5)                         true
(%i6) featurep(%c0, 'complex);
(%o6)                         true

Note Generally, the argument to new_variable should be quoted. The quote will protect against errors similar to

(%i7) integer : 12$

(%i8) new_variable(integer);
(%o8)                         %g149
(%i9) new_variable('integer);
(%o9)                         %z150

Related functions nicedummies

To use `load(to_poly_solve)'

Status The function new_variable is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: nicedummies

Starting with zero, the function nicedummies re-indexes the variables in an expression that were introduced by new_variable;

(%i1) new_variable('integer) + 52 * new_variable('integer);
(%o1)                   52 %z136 + %z135
(%i2) new_variable('integer) - new_variable('integer);
(%o2)                     %z137 - %z138
(%i3) nicedummies(%);
(%o3)                       %z0 - %z1

Related functions new_variable

To use `load(to_poly_solve)'

Status The function nicedummies is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: parg (x)

The function parg is a simplifying version of the complex argument function carg; thus

(%i1) map('parg,[1,1+%i,%i, -1 + %i, -1]);
                        %pi  %pi  3 %pi
(%o1)               [0, ---, ---, -----, %pi]
                         4    2     4

Generally, for a non-constant input, parg returns a noun form; thus

(%i2) parg(x + %i * sqrt(x));
(%o2)                 parg(x + %i sqrt(x))

When sign can determine that the input is a positive or negative real number, parg will return a non-noun form for a non-constant input. Here are two examples:

(%i3) parg(abs(x));
(%o3) 0
(%i4) parg(-x^2-1);
(%o4)                          %pi

Note The sign function mostly ignores the variables that are declared to be complex (declare(x,complex)); for variables that are declared to be complex, the parg can return incorrect values; for example

(%i1) declare(x,complex)$

(%i2) parg(x^2 + 1);
(%o2) 0

Related function carg, isreal_p

To use `load(to_poly_solve)'

Status The function parg is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: real_imagpart_to_conjugate (e)

The function real_imagpart_to_conjugate replaces all occurrences of realpart and imagpart to algebraically equivalent expressions involving the conjugate.

(%i1) declare(x, complex)$

(%i2) real_imagpart_to_conjugate(realpart(x) +  imagpart(x) = 3);
          conjugate(x) + x   %i (x - conjugate(x))
(%o2)     ---------------- - --------------------- = 3
                 2                     2

To use `load(to_poly_solve)'

Status The function real_imagpart_to_conjugate is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: rectform_log_if_constant (e)

The function rectform_log_if_constant converts all terms of the form log(c) to rectform(log(c)), where c is either a declared constant expression or explicitly declared constant

(%i1) rectform_log_if_constant(log(1-%i) - log(x - %i));
                                 log(2)   %i %pi
(%o1)            - log(x - %i) + ------ - ------
                                   2        4
(%i2) declare(a,constant, b,constant)$

(%i3) rectform_log_if_constant(log(a + %i*b));
                       2    2
                  log(b  + a )
(%o3)             ------------ + %i atan2(b, a)
                       2

To use `load(to_poly_solve)'

Status The function rectform_log_if_constant is experimental; the specifications of this function might change might change and its functionality might be merged into other Maxima functions.

Function: simp_inequality (e)

The function simp_inequality applies some simplifications to conjunctions and disjunctions of inequations.

Limitations The function simp_inequality is limited in at least two ways; first, the simplifications are local; thus

(%i1) simp_inequality((x > minf) %and (x < 0));
(%o1) (x>1) %and (x<1)

And second, simp_inequality doesn't consult the fact database:

(%i2) assume(x > 0)$

(%i3) simp_inequality(x > 0);
(%o3)                         x > 0

To use `load(fourier_elim)'

Status The function simp_inequality is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: standardize_inverse_trig (e)

This function applies the identities cot(x) = atan(1/x), acsc(x) = asin(1/x), and similarly for asec, acoth, acsch and asech to an expression. See Abramowitz and Stegun, Eqs. 4.4.6 through 4.4.8 and 4.6.4 through 4.6.6.

To use `load(to_poly_solve)'

Status The function standardize_inverse_trig is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: subst_parallel (l, e)

When l is a single equation or a list of equations, substitute the right hand side of each equation for the left hand side. The substitutions are made in parallel; for example

(%i1) load(to_poly_solve)$

(%i2) subst_parallel([x=y,y=x], [x,y]);
(%o2)                        [y, x]

Compare this to substitutions made serially:

(%i3) subst([x=y,y=x],[x,y]);
(%o3)                        [x, x]

The function subst_parallel is similar to sublis except that subst_parallel allows for substitution of nonatoms; for example

(%i4) subst_parallel([x^2 = a, y = b], x^2 * y);
(%o4)                          a b
(%i5) sublis([x^2 = a, y = b], x^2 * y);

                                                             2
sublis: left-hand side of equation must be a symbol; found: x
 -- an error. To debug this try: debugmode(true);

The substitutions made by subst_parallel are literal, not semantic; thus subst_parallel does not recognize that x * y is a subexpression of x^2 * y

(%i6) subst_parallel([x * y = a], x^2 * y);
                               2
(%o6)                         x  y

The function subst_parallel completes all substitutions before simplifications. This allows for substitutions into conditional expressions where errors might occur if the simplifications were made earlier:

(%i7) subst_parallel([x = 0], %if(x < 1, 5, log(x)));
(%o7)                           5
(%i8) subst([x = 0], %if(x < 1, 5, log(x)));

log: encountered log(0).
 -- an error. To debug this try: debugmode(true);

Related functions subst, sublis, ratsubst

To use `load(to_poly_solve_extra.lisp)'

Status The function subst_parallel is experimental; the specifications of this function might change might change and its functionality might be merged into other Maxima functions.

Function: to_poly (e, l)

The function to_poly attempts to convert the equation e into a polynomial system along with inequality constraints; the solutions to the polynomial system that satisfy the constraints are solutions to the equation e. Informally, to_poly attempts to polynomialize the equation e; an example might clarify:

(%i1) load(to_poly_solve)$

(%i2) to_poly(sqrt(x) = 3, [x]);
                            2
(%o2) [[%g130 - 3, x = %g130 ], 
                      %pi                               %pi
                   [- --- < parg(%g130), parg(%g130) <= ---], []]
                       2                                 2

The conditions -%pi/2<parg(%g130),parg(%g130)<=%pi/2 tell us that %g130 is in the range of the square root function. When this is true, the solution set to sqrt(x) = 3 is the same as the solution set to %g130-3,x=%g130^2.

To polynomialize trigonometric expressions, it is necessary to introduce a non algebraic substitution; these non algebraic substitutions are returned in the third list returned by to_poly; for example

(%i3) to_poly(cos(x),[x]);
                2                                 %i x
(%o3)    [[%g131  + 1], [2 %g131 # 0], [%g131 = %e    ]]

Constant terms aren't polynomializied unless the number one is a member of the variable list; for example

(%i4) to_poly(x = sqrt(5),[x]);
(%o4)                [[x - sqrt(5)], [], []]
(%i5) to_poly(x = sqrt(5),[1,x]);
                            2
(%o5) [[x - %g132, 5 = %g132 ], 
                      %pi                               %pi
                   [- --- < parg(%g132), parg(%g132) <= ---], []]
                       2                                 2

To generate a polynomial with sqrt(5) + sqrt(7) as one of its roots, use the commands

(%i6) first(elim_allbut(first(to_poly(x = sqrt(5) + sqrt(7),
                                      [1,x])), [x]));
                          4       2
(%o6)                   [x  - 24 x  + 4]

Related functions to_poly_solve

To use `load(to_poly)'

Status: The function to_poly is experimental; its specifications might change and its functionality might be merged into other Maxima functions.

Function: to_poly_solve (e, l, [options])

The function to_poly_solve tries to solve the equations e for the variables l. The equation(s) e can either be a single expression or a set or list of expressions; similarly, l can either be a single symbol or a list of set of symbols. When a member of e isn't explicitly an equation, for example x^2 -1, the solver asummes that the expression vanishes.

The basic strategy of to_poly_solve is to convert the input into a polynomial form and to call algsys on the polynomial system. Internally to_poly_solve defaults algexact to true. To change the default for algexact, append 'algexact=false to the to_poly_solve argument list.

When to_poly_solve is able to determine the solution set, each member of the solution set is a list in a %union object:

(%i1) load(to_poly_solve)$

(%i2) to_poly_solve(x*(x-1) = 0, x);
(%o2)               %union([x = 0], [x = 1])

When to_poly_solve is unable to determine the solution set, a %solve nounform is returned (in this case, a warning is printed)

(%i3) to_poly_solve(x^k + 2* x + 1 = 0, x);

Nonalgebraic argument given to 'to_poly'
unable to solve
                          k
(%o3)            %solve([x  + 2 x + 1 = 0], [x])

Subsitution into a %solve nounform can sometimes result in the solution

(%i4) subst(k = 2, %);
(%o4)                   %union([x = - 1])

Especially for trigonometric equations, the solver sometimes needs to introduce an arbitary integer. These arbitary integers have the form %zXXX, where XXX is an integer; for example

(%i5) to_poly_solve(sin(x) = 0, x);
(%o5)   %union([x = 2 %pi %z33 + %pi], [x = 2 %pi %z35])

To re-index these variables to zero, use nicedummies:

(%i6) nicedummies(%);
(%o6)    %union([x = 2 %pi %z0 + %pi], [x = 2 %pi %z1])

Occasionally, the solver introduces an arbitary complex number of the form %cXXX or an arbitary real number of the form %rXXX. The function nicedummies will re-index these identifiers to zero.

The solution set sometimes involves simplifing versions of various of logical operators including %and, %or, or %if for conjunction, disjuntion, and implication, respectively; for example

(%i7) sol : to_poly_solve(abs(x) = a, x);
(%o7) %union(%if(isnonnegative_p(a), [x = - a], %union()), 
                      %if(isnonnegative_p(a), [x = a], %union()))
(%i8) subst(a = 42, sol);
(%o8)             %union([x = - 42], [x = 42])
(%i9) subst(a = -42, sol);
(%o9)                       %union()

The empty set is represented by %union.

The function to_poly_solve is able to solve some, but not all, equations involving rational powers, some nonrational powers, absolute values, trigonometric functions, and minimum and maximum. Also, some it can solve some equations that are solvable in in terms of the Lambert W function; some examples:

(%i1) load(to_poly_solve)$

(%i2) to_poly_solve(set(max(x,y) = 5, x+y = 2), set(x,y));
(%o2)      %union([x = - 3, y = 5], [x = 5, y = - 3])
(%i3) to_poly_solve(abs(1-abs(1-x)) = 10,x);
(%o3)             %union([x = - 10], [x = 12])
(%i4) to_poly_solve(set(sqrt(x) + sqrt(y) = 5, x + y = 10),
                    set(x,y));
                     3/2               3/2
                    5    %i - 10      5    %i + 10
(%o4) %union([x = - ------------, y = ------------], 
                         2                 2
                                3/2                 3/2
                               5    %i + 10        5    %i - 10
                          [x = ------------, y = - ------------])
                                    2                   2
(%i5) to_poly_solve(cos(x) * sin(x) = 1/2,x,
                    'simpfuncs = ['expand, 'nicedummies]);
                                         %pi
(%o5)              %union([x = %pi %z0 + ---])
                                          4
(%i6) to_poly_solve(x^(2*a) + x^a + 1,x);
                                        2 %i %pi %z81
                                        -------------
                                  1/a         a
                  (sqrt(3) %i - 1)    %e
(%o6) %union([x = -----------------------------------], 
                                  1/a
                                 2
                                                  2 %i %pi %z83
                                                  -------------
                                            1/a         a
                          (- sqrt(3) %i - 1)    %e
                     [x = -------------------------------------])
                                           1/a
                                          2
(%i7) to_poly_solve(x * exp(x) = a, x);
(%o7)              %union([x = lambert_w(a)])

For linear inequalities, to_poly_solve automatically does Fourier elimination:

(%i8) to_poly_solve([x + y < 1, x - y >= 8], [x,y]);
                               7
(%o8) %union([x = y + 8, y < - -], 
                               2
                                                              7
                                 [y + 8 < x, x < 1 - y, y < - -])
                                                              2

Each optional argument to to_poly_solve must be an equation; generally, the order of these options does not matter.

The to_poly_solve uses data stored in the hashed array one_to_one_reduce to solve equations of the form f(a) = f(b). The assignment one_to_one_reduce['f,'f] : lambda([a,b], a=b) tells to_poly_solve that the solution set of f(a) = f(b) equals the solution set of a=b; for example

(%i13) one_to_one_reduce['f,'f] : lambda([a,b], a=b)$

(%i14) to_poly_solve(f(x^2-1) = f(0),x);
(%o14)             %union([x = - 1], [x = 1])

More generally, the assignment one_to_one_reduce['f,'g] : lambda([a,b], w(a, b) = 0 tells to_poly_solve that the solution set of f(a) = f(b) equals the solution set of w(a,b) = 0; for example

(%i15) one_to_one_reduce['f,'g] : lambda([a,b], a = 1 + b/2)$

(%i16) to_poly_solve(f(x) - g(x),x);
(%o16)                   %union([x = 2])

Additionally, the function to_poly_solve uses data stored in the hashed array function_inverse to solve equations of the form f(a) = b. The assignment function_inverse['f] : lambda([s], g(s)) informs to_poly_solve that the solution set to f(x) = b equals the solution set to x = g(b); two examples:

(%i17) function_inverse['Q] : lambda([s], P(s))$

(%i18) to_poly_solve(Q(x-1) = 2009,x);
(%o18)              %union([x = P(2009) + 1])
(%i19) function_inverse['G] : lambda([s], s+new_variable(integer));
(%o19)       lambda([s], s + new_variable(integer))
(%i20) to_poly_solve(G(x - a) = b,x);
(%o20)             %union([x = b + a + %z125])

Notes

(%i1) to_poly_solve([x^2 + y^2 + x * y = 5, x * y = 8],
                    [x^2 + y^2, x * y]);
                                  2    2
(%o1)           %union([x y = 8, y  + x  = - 3])
(%i1) declare(x,complex)$

(%i2) to_poly_solve(x + (5 + %i) * conjugate(x) = 1, x);
                                   %i + 21
(%o2)              %union([x = - -----------])
                                 25 %i - 125
(%i3) declare(y,complex)$

(%i4) to_poly_solve(set(conjugate(x) - y = 42 + %i,
                        x + conjugate(y) = 0), set(x,y));
                           %i - 42        %i + 42
(%o4)        %union([x = - -------, y = - -------])
                              2              2

Relevant option variables algexact, resultant, algebraic

Related functions to_poly

To use `load(to_poly_solve)'

Status: The function to_poly_solve is experimental; its specifications might change and its functionality might be merged into other Maxima functions.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Jaime Villate on November, 25 2014 using texi2html 1.76.