Introduction to Simplification
==============================

Maxima interacts with the user through a cycle of actions called the read-eval-print loop (REPL). This consists of three steps: reading and parsing, evaluating and simplifying, and outputting. Parsing converts a syntactically valid sequence of typed characters into a internal data structure. Evaluation replaces variable and function names with their values and simplification rewrites expressions to be easier for the user or other programs to understand. Output displays results in a variety of different formats and notations.

Evaluation and simplification sometimes appear to have similar functionality, and Maxima uses simplification in many cases where other systems use evaluation. For example, arithmetic both on numbers and on symbolic expressions is simplification, not evaluation: 2+2 simplifies to 4, 2+x+x simplifies to 2+2*x, and sqrt(7)^4 simplifies to 49. Evaluation and simplification are interleaved. For example, factor(integrate(x+1,x)) first calls the built-in function integrate, giving x+x*x*2^-1; that simplifies to x+(1/2)*x^2; this in turn is passed to the factor function, which returns (x*(x+2))/2.

Evaluation is what makes Maxima a programming language: it implements functions, subroutines, variables, values, loops, assignments and so on. Evaluation replaces built-in or user-defined function names by their definitions and variables by their values. This is largely the same as activities of a conventional programming language, but extended to work with symbolic mathematical data. The system has various optional "flags" which the user can set to control the details of evaluation. See Functions and Variables for Evaluation.

Simplification maintains the value of an expression while re-formulating its form to be smaller, simpler to understand, or to conform to a particular specification (like expanded). For example, sin(%pi/2) to 1, and x+x to 2*x. There are many flags which control simplification. For example, with triginverses:true, atan(tan(x)) does not simplify to x, but with triginverses:all, it does.

Simplification can be provided in three ways:

  * The internal, built-in automated simplifier,

  * User-written pattern-matching transformations, linked to the simplifier by using "tellsimp" or "tellsimpafter" and called automatically,

  * User-written simplification routines adding using the simplifying subsystem.

The internal simplifier belongs to the heart of Maxima. It is a large and complicated collection of programs, and it has been refined over many years and by thousands of users. Nevertheless, especially if you are trying out novel ideas or unconventional notation, you may find it helpful to make small (or large) changes to the program yourself. For details see for example the paper at the end of https://people.eecs.berkeley.edu/~fateman/papers/intro5.txt.

Maxima internally represents expressions as "trees" with operators or "roots" like +, * , = and operands ("leaves") which are variables like X, Y, Z, functions or sub-trees, like x*y. Each operator has a simplification program associated with it.  + (which also covers binary - since a-b = a+(-1)*b) and * (which also covers / since a/b = a*b^(-1)) have rather elaborate simplification programs. These simplification programs (simplus, simptimes, simpexpt, etc.) are called whenever the simplifier encounters the respective arithmetic operators in an expression tree to be analyzed.

The structure of the simplifier dates back to 1965, and many hands have worked on it through the years. It is data-directed, or object-oriented in the sense that it dispatches to the appropriate routine depending on the root of some sub-tree of the expression, recursively. This general approach means that modifications to simplification are generally localized. In many cases it is straightforward to add an operator and its simplification routine without disturbing existing code.

Maxima also provides a variety of transformation routines that can change the form of an expression, including factor (polynomial factorization), horner (reorganize a polynomial using Horner's rule), partfrac (rewrite a rational function as partial fractions), trigexpand (apply the sum formulas for trigonometric functions), and so on.

Users can also write routines that change the form of an expression.

Besides this general simplifier operating on algebraic expression trees, there are several other representations of expressions in Maxima which have separate methods. For example, the rat function converts polynomials to vectors of coefficients to assist in rapid manipulation of such forms. Other representations include Taylor series and the (rarely used) Poisson series.

All operators introduced by the user initially have no simplification programs associated with them.  Maxima does not know anything about function "f"  and so typing f(a,b) will result in simplifying A,B, but not f. Even some built-in operators have no simplifications. For example, = does not "simplify" -- it is a place-holder with no simplification semantics other than to simplify its two arguments, in this case referred to as the left and right sides. Other parts of Maxima such as the solve program take special note of equations, that is, trees with = as the root. (Note -- in Maxima, the assignment operation is : . That is, q: 4 sets the value of the symbol Q to 4. Function definition is done with :=. )

The general simplifier returns results with an internal flag indicating the expression and each sub-expression has been simplified. This does not guarantee that it is unique over all possible equivalent expressions. That's too hard (theoretically, not possible given the generality of what can be expressed in Maxima). However, some aspects of the expression, such as the ordering of terms in a sum or product, are made uniform. This is important for the other programs to work properly.

A number of option variables control simplification. Indeed, simplification can be turned off entirely using simp:false. However, many internal routines will not operate correctly with simp:false. (About the only time it seems plausible to turn off the simplifier is in the rare case that you want to over-ride a built-in simplification. In that case  you might temporarily disable the simplifier, put in the new transformation via tellsimp and then re-enable the simplifier by simp:true.)

It is more plausible for you to associate user-defined symbolic function names or operators with properties (additive lassociative oddfun antisymmetric linear outative commutative multiplicative rassociative evenfun nary and symmetric). These options steer the simplifier processing in systematic directions.

For example, declare(f,oddfun) specifies that f is an odd function. Maxima will simplify f(-x) to -f(x). In the case of an even function, that is declare(g,evenfun), Maxima will simplify g(-x) to g(x). You can also associate a programming function with a name such as h(x):=x^2+1. In that case the evaluator will immediately replace h(3) by 10, and h(a+1) by (a+1)^2+1, so any properties of h will be ignored.

In addition to these directly related properties set up by the user, facts and properties from the actual context may have an impact on the simplifier's behavior, too. See Introduction to Maxima's Database.

Example: sin(n*%pi) is simplified to zero, if N is an integer.

     (%i1) sin(n*%pi);
     (%o1)                      sin(%pi n)

     (%i2) declare(n, integer);
     (%o2)                         done

     (%i3) sin(n*%pi);
     (%o3)                           0

If automated simplification is not sufficient, you can consider a variety of built-in, but explicitly called simplfication functions (ratsimp expand factor radcan and others). There are also flags that will push simplification into one or another direction. Given demoivre:true the simplifier rewrites complex exponentials as trigonometric forms. Given exponentialize:true the  simplifier tries to do the reverse: rewrite trigonometric forms as complex exponentials.

As everywhere in Maxima, by writing your own functions (be it in the Maxima user language or in the implementation language Lisp) and explicitly calling them at selected places in the program, you can respond to your individual simplification needs. Lisp gives you a handle on all the internal mechanisms, but you rarely need this full generality. "Tellsimp" is designed to generate much of the Lisp internal interface into the simplifier automatically. See Rules and Patterns.

Over the years (Maxima/Macsyma's origins date back to about 1966!) users have contributed numerous application packages and tools to extend or alter its functional behavior. Various non-standard and "share" packages exist to modify or extend simplification as well. You are invited to look into this more experimental material where work is still in progress see simplification-pkg.

The following appended material is optional on a first reading, and reading it is not necessary for productive use of Maxima. It is for the curious user who wants to understand what is going on, or the ambitious programmer who might wish to change the (open-source) code. Experimentation with redefining Maxima Lisp code is easily possible: to change the definition of a Lisp program (say the one that simplifies cos(), named simp%cos), you simply load into Maxima a text file that will overwrite the simp%cos function from the maxima package.

Functions and Variables for Simplification
==========================================

 -- Property: additive

     If declare(f,additive) has been executed, then:

     (1) If f is univariate, whenever the simplifier encounters f applied to a sum, f will be distributed over that sum.  I.e. f(y+x) will simplify to f(y)+f(x).

     (2) If f is a function of 2 or more arguments, additivity is defined as additivity in the first argument to f, as in the case of sum or integrate, i.e.  f(h(x)+g(x),x) will simplify to f(h(x),x)+f(g(x),x).  This simplification does not occur when f is applied to expressions of the form sum(x[i],i,lower-limit,upper-limit).

     Example:

          (%i1) F3 (a + b + c);
          (%o1)                     F3(c + b + a)

          (%i2) declare (F3, additive);
          (%o2)                         done

          (%i3) F3 (a + b + c);
          (%o3)                 F3(c) + F3(b) + F3(a)

     Categories: Operators Declarations and inferences

 -- Property: antisymmetric

     If declare(h,antisymmetric) is done, this tells the simplifier that h is antisymmetric.  E.g.  h(x,z,y) will simplify to - h(x, y, z).  That is, it will give (-1)^n times the result given by symmetric or commutative where n is the number of interchanges of two arguments necessary to convert it to that form.

     Examples:

          (%i1) S (b, a);
          (%o1)                        S(b, a)

          (%i2) declare (S, symmetric);
          (%o2)                         done

          (%i3) S (b, a);
          (%o3)                        S(a, b)

          (%i4) S (a, c, e, d, b);
          (%o4)                   S(a, b, c, d, e)

          (%i5) T (b, a);
          (%o5)                        T(b, a)

          (%i6) declare (T, antisymmetric);
          (%o6)                         done

          (%i7) T (b, a);
          (%o7)                       - T(a, b)

          (%i8) T (a, c, e, d, b);
          (%o8)                   T(a, b, c, d, e)

     Categories: Operators Declarations and inferences

 -- Function: combine (EXPR)

     Simplifies the sum EXPR by combining terms with the same denominator into a single term.

     See also: rncombine

     Example:

          (%i1) 1*f/2*b + 2*c/3*a + 3*f/4*b +c/5*b*a;
                                5 b f   a b c   2 a c
          (%o1)                 ----- + ----- + -----
                                  4       5       3

          (%i2) combine (%);
                            75 b f + 4 (3 a b c + 10 a c)
          (%o2)             -----------------------------
                                         60

     Categories: Expressions

 -- Property: commutative

     If declare(h, commutative) is done, this tells the simplifier that h is a commutative function.  E.g.  h(x, z, y) will simplify to h(x, y, z).  This is the same as symmetric

     Example:

          (%i1) S (b, a);
          (%o1)                        S(b, a)

          (%i2) S (a, b) + S (b, a);
          (%o2)                   S(b, a) + S(a, b)

          (%i3) declare (S, commutative);
          (%o3)                         done

          (%i4) S (b, a);
          (%o4)                        S(a, b)

          (%i5) S (a, b) + S (b, a);
          (%o5)                       2 S(a, b)

          (%i6) S (a, c, e, d, b);
          (%o6)                   S(a, b, c, d, e)

     Categories: Operators Declarations and inferences

 -- Function: demoivre (EXPR)
 -- Option variable: demoivre

     The function demoivre (expr) converts one expression without setting the global variable demoivre.

     When the variable demoivre is true, complex exponentials are converted into equivalent expressions in terms of circular functions: exp (a + b*%i) simplifies to %e^a * (cos(b) + %i*sin(b)) if b is free of %i.  a and b are not expanded.

     The default value of demoivre is false.

     exponentialize converts circular and hyperbolic functions to exponential form.  demoivre and exponentialize cannot both be true at the same time.

     Categories: Complex variables Trigonometric functions Hyperbolic functions

 -- Function: distrib (EXPR)

     Distributes sums over products.  It differs from expand in that it works at only the top level of an expression, i.e., it doesn't recurse and it is faster than expand.  It differs from multthru in that it expands all sums at that level.

     Examples:

          (%i1) distrib ((a+b) * (c+d));
          (%o1)                 b d + a d + b c + a c
          (%i2) multthru ((a+b) * (c+d));
          (%o2)                 (b + a) d + (b + a) c
          (%i3) distrib (1/((a+b) * (c+d)));
                                          1
          (%o3)                    ---------------
                                   (b + a) (d + c)
          (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                          1
          (%o4)                 ---------------------
                                b d + a d + b c + a c

     Categories: Expressions

 -- Option variable: distribute_over
     Default value: true

     distribute_over controls the mapping of functions over bags like lists, matrices, and equations.  At this time not all Maxima functions have this property.  It is possible to look up this property with the command properties.

     The mapping of functions is switched off, when setting distribute_over to the value false.

     Examples:

     The sin function maps over a list:

          (%i1) sin([x,1,1.0]);
          (%o1)         [sin(x), sin(1), 0.8414709848078965]

     mod is a function with two arguments which maps over lists.  Mapping over nested lists is possible too:

          (%i1) mod([x,11,2*a],10);
          (%o1)             [mod(x, 10), 1, 2 mod(a, 5)]

          (%i2) mod([[x,y,z],11,2*a],10);
          (%o2) [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]

     Mapping of the floor function over a matrix and an equation:

          (%i1) floor(matrix([a,b],[c,d]));
                               [ floor(a)  floor(b) ]
          (%o1)                [                    ]
                               [ floor(c)  floor(d) ]

          (%i2) floor(a=b);
          (%o2)                  floor(a) = floor(b)

     Functions with more than one argument map over any of the arguments or all arguments:

          (%i1) expintegral_e([1,2],[x,y]);
          (%o1) [[expintegral_e(1, x), expintegral_e(1, y)],
                                [expintegral_e(2, x), expintegral_e(2, y)]]

     Check if a function has the property distribute_over:

          (%i1) properties(abs);
          (%o1) [integral, rule, distributes over bags, noun, gradef,
                                                           system function]

     The mapping of functions is switched off, when setting distribute_over to the value false.

          (%i1) distribute_over;
          (%o1)                         true

          (%i2) sin([x,1,1.0]);
          (%o2)         [sin(x), sin(1), 0.8414709848078965]

          (%i3) distribute_over : not distribute_over;
          (%o3)                         false

          (%i4) sin([x,1,1.0]);
          (%o4)                   sin([x, 1, 1.0])

     Categories: Simplification flags and variables

 -- Option variable: domain
     Default value: real

     When domain is set to complex, sqrt (x^2) will remain sqrt (x^2) instead of returning abs(x).

     Categories: Simplification flags and variables

 -- Property: evenfun
 -- Property: oddfun

     declare(f, evenfun) or declare(f, oddfun) tells Maxima to recognize the function f as an even or odd function.

     Examples:

          (%i1) o (- x) + o (x);
          (%o1)                     o(x) + o(- x)
          (%i2) declare (o, oddfun);
          (%o2)                         done
          (%i3) o (- x) + o (x);
          (%o3)                           0
          (%i4) e (- x) - e (x);
          (%o4)                     e(- x) - e(x)
          (%i5) declare (e, evenfun);
          (%o5)                         done
          (%i6) e (- x) - e (x);
          (%o6)                           0

 -- Function: expand
     expand (EXPR)
     expand (EXPR, P, N)

     Expand expression EXPR. Products of sums and exponentiated sums are multiplied out, numerators of rational expressions which are sums are split into their respective terms, and multiplication (commutative and non-commutative) are distributed over addition at all levels of EXPR.

     For polynomials one should usually use ratexpand which uses a more efficient algorithm.

     maxnegex and maxposex control the maximum negative and positive exponents, respectively, which will expand.

     expand (EXPR, P, N) expands EXPR, using P for maxposex and N for maxnegex. This is useful in order to expand part but not all of an expression.

     expon - the exponent of the largest negative power which is automatically expanded (independent of calls to expand).  For example if expon is 4 then (x+1)^(-5) will not be automatically expanded.

     expop - the highest positive exponent which is automatically expanded. Thus (x+1)^3, when typed, will be automatically expanded only if expop is greater than or equal to 3.  If it is desired to have (x+1)^n expanded where n is greater than expop then executing expand ((x+1)^n) will work only if maxposex is not less than n.

     expand(expr, 0, 0) causes a resimplification of expr.  expr is not reevaluated.  In distinction from ev(expr, noeval) a special representation (e. g. a CRE form) is removed.  See also ev

     The expand flag used with ev causes expansion.

     The file share/simplification/facexp.mac contains several related functions (in particular facsum, factorfacsum and collectterms, which are autoloaded) and variables (nextlayerfactor and facsum_combine) that provide the user with the ability to structure expressions by controlled expansion. Brief function descriptions are available in simplification/facexp.usg. A demo is available by doing demo("facexp").

     Examples:

          (%i1) expr:(x+1)^2*(y+1)^3;
                                         2        3
          (%o1)                   (x + 1)  (y + 1)

          (%i2) expand(expr);
                 2  3        3    3      2  2        2      2      2
          (%o2) x  y  + 2 x y  + y  + 3 x  y  + 6 x y  + 3 y  + 3 x  y
                                                                2
                                               + 6 x y + 3 y + x  + 2 x + 1

          (%i3) expand(expr,2);
                         2        3              3          3
          (%o3)         x  (y + 1)  + 2 x (y + 1)  + (y + 1)

          (%i4) expr:(x+1)^-2*(y+1)^3;
                                             3
                                      (y + 1)
          (%o4)                       --------
                                             2
                                      (x + 1)

          (%i5) expand(expr);
                      3               2
                     y             3 y            3 y             1
          (%o5) ------------ + ------------ + ------------ + ------------
                 2              2              2              2
                x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1

          (%i6) expand(expr,2,2);
                                             3
                                      (y + 1)
          (%o6)                     ------------
                                     2
                                    x  + 2 x + 1

     Resimplify an expression without expansion:

          (%i1) expr:(1+x)^2*sin(x);
                                          2
          (%o1)                    (x + 1)  sin(x)

          (%i2) exponentialize:true;
          (%o2)                         true

          (%i3) expand(expr,0,0);
                                      2    %i x     - %i x
                            %i (x + 1)  (%e     - %e      )
          (%o3)           - -------------------------------
                                           2

     Categories: Expressions

 -- Function: expandwrt (EXPR, X_1, ..., X_N)

     Expands expression expr with respect to the variables X_1, ..., X_N. All products involving the variables appear explicitly.  The form returned will be free of products of sums of expressions that are not free of the variables.  X_1, ..., X_N may be variables, operators, or expressions.

     By default, denominators are not expanded, but this can be controlled by means of the switch expandwrt_denom.

     This function is autoloaded from simplification/stopex.mac.

     Categories: Expressions

 -- Option variable: expandwrt_denom
     Default value: false

     expandwrt_denom controls the treatment of rational expressions by expandwrt.  If true, then both the numerator and denominator of the expression will be expanded according to the arguments of expandwrt, but if expandwrt_denom is false, then only the numerator will be expanded in that way.

     Categories: Expressions

 -- Function: expandwrt_factored (EXPR, X_1, ..., X_N)

     is similar to expandwrt, but treats expressions that are products somewhat differently.  expandwrt_factored expands only on those factors of expr that contain the variables X_1, ..., X_N.

     This function is autoloaded from simplification/stopex.mac.

     Categories: Expressions

 -- Option variable: expon
     Default value: 0

     expon is the exponent of the largest negative power which is automatically expanded (independent of calls to expand).  For example, if expon is 4 then (x+1)^(-5) will not be automatically expanded.

     Categories: Expressions

 -- Function: exponentialize (EXPR)
 -- Option variable: exponentialize

     The function exponentialize (expr) converts circular and hyperbolic functions in EXPR to exponentials, without setting the global variable exponentialize.

     When the variable exponentialize is true, all circular and hyperbolic functions are converted to exponential form. The default value is false.

     demoivre converts complex exponentials into circular functions. exponentialize and demoivre cannot both be true at the same time.

     Categories: Complex variables Trigonometric functions Hyperbolic functions

 -- Option variable: expop
     Default value: 0

     expop is the highest positive exponent which is automatically expanded. Thus (x + 1)^3, when typed, will be automatically expanded only if expop is greater than or equal to 3.  If it is desired to have (x + 1)^n expanded where n is greater than expop then executing expand ((x + 1)^n) will work only if maxposex is not less than n.

     Categories: Expressions

 -- Property: lassociative

     declare (g, lassociative) tells the Maxima simplifier that g is left-associative.  E.g., g (g (a, b), g (c, d)) will simplify to g (g (g (a, b), c), d).

     See also rassociative

     Categories: Declarations and inferences Operators Simplification

 -- Property: linear

     One of Maxima's operator properties.  For univariate f so declared, "expansion" f(x + y) yields f(x) + f(y), f(a*x) yields a*f(x) takes place where a is a "constant".  For functions of two or more arguments, "linearity" is defined to be as in the case of sum or integrate i.e., f (a*x + b, x) yields a*f(x,x) + b*f(1,x) for a and b free of x.

     Example:

          (%i1) declare (f, linear);
          (%o1)                         done

          (%i2) f(x+y);
          (%o2)                      f(y) + f(x)

          (%i3) declare (a, constant);
          (%o3)                         done

          (%i4) f(a*x);
          (%o4)                        a f(x)

     linear is equivalent to additive and outative See also opproperties

     Example:

          (%i1) 'sum (F(k) + G(k), k, 1, inf);
                                 inf
                                 ====
                                 \
          (%o1)                   >    (G(k) + F(k))
                                 /
                                 ====
                                 k = 1

          (%i2) declare (nounify (sum), linear);
          (%o2)                         done

          (%i3) 'sum (F(k) + G(k), k, 1, inf);
                               inf          inf
                               ====         ====
                               \            \
          (%o3)                 >    G(k) +  >    F(k)
                               /            /
                               ====         ====
                               k = 1        k = 1

     Categories: Declarations and inferences Operators Simplification

 -- Option variable: maxnegex
     Default value: 1000

     maxnegex is the largest negative exponent which will be expanded by the expand command, see also maxposex

     Categories: Expressions

 -- Option variable: maxposex
     Default value: 1000

     maxposex is the largest exponent which will be expanded with the expand command, see also maxnegex

     Categories: Expressions

 -- Property: multiplicative

     declare(f, multiplicative) tells the Maxima simplifier that f is multiplicative.

      1. If f is univariate, whenever the simplifier encounters f applied to a product, f distributes over that product.  E.g., f(x*y) simplifies to f(x)*f(y). This simplification is not applied to expressions of the form f('product(...)).

      2. If f is a function of 2 or more arguments, multiplicativity is defined as multiplicativity in the first argument to f, e.g., f (g(x) * h(x), x) simplifies to f (g(x) ,x) * f (h(x), x).

     declare(nounify(product), multiplicative) tells Maxima to simplify symbolic products.

     Example:

          (%i1) F2 (a * b * c);
          (%o1)                       F2(a b c)

          (%i2) declare (F2, multiplicative);
          (%o2)                         done

          (%i3) F2 (a * b * c);
          (%o3)                   F2(a) F2(b) F2(c)

     declare(nounify(product), multiplicative) tells Maxima to simplify symbolic products.

          (%i1) product (a[i] * b[i], i, 1, n);
                                       n
                                     /===\
                                      ! !
          (%o1)                       ! !  a  b
                                      ! !   i  i
                                     i = 1

          (%i2) declare (nounify (product), multiplicative);
          (%o2)                         done

          (%i3) product (a[i] * b[i], i, 1, n);
                                    n         n
                                  /===\     /===\
                                   ! !       ! !
          (%o3)                  ( ! !  a )  ! !  b
                                   ! !   i   ! !   i
                                  i = 1     i = 1

     Categories: Declarations and inferences Expressions Simplification

 -- Function: multthru
     multthru (EXPR)
     multthru (EXPR_1, EXPR_2)

     Multiplies a factor (which should be a sum) of EXPR by the other factors of EXPR.  That is, EXPR is F_1 F_2 ... F_N where at least one factor, say F_I, is a sum of terms.  Each term in that sum is multiplied by the other factors in the product.  (Namely all the factors except F_I).  multthru does not expand exponentiated sums. This function is the fastest way to distribute products (commutative or noncommutative) over sums.  Since quotients are represented as products multthru can be used to divide sums by products as well.

     multthru (EXPR_1, EXPR_2) multiplies each term in EXPR_2 (which should be a sum or an equation) by EXPR_1.  If EXPR_1 is not itself a sum then this form is equivalent to multthru (EXPR_1*EXPR_2).

          (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                                1        x         f(x)
          (%o1)             - ----- + -------- - --------
                              x - y          2          3
                                      (x - y)    (x - y)
          (%i2) multthru ((x-y)^3, %);
                                     2
          (%o2)             - (x - y)  + x (x - y) - f(x)
          (%i3) ratexpand (%);
                                     2
          (%o3)                   - y  + x y - f(x)
          (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                                  10  2              2  2
                           (b + a)   s  + 2 a b s + a  b
          (%o4)            ------------------------------
                                            2
                                       a b s
          (%i5) multthru (%);  /* note that this does not expand (b+a)^10 */
                                                  10
                                 2   a b   (b + a)
          (%o5)                  - + --- + ---------
                                 s    2       a b
                                     s
          (%i6) multthru (a.(b+c.(d+e)+f));
          (%o6)            a . f + a . c . (e + d) + a . b
          (%i7) expand (a.(b+c.(d+e)+f));
          (%o7)         a . f + a . c . e + a . c . d + a . b

     Categories: Expressions

 -- Property: nary

     declare(f, nary) tells Maxima to recognize the function f as an n-ary function.

     The nary declaration is not the same as calling the function_nary, nary function.  The sole effect of declare(f, nary) is to instruct the Maxima simplifier to flatten nested expressions, for example, to simplify foo(x, foo(y, z)) to foo(x, y, z).  See also declare

     Example:

          (%i1) H (H (a, b), H (c, H (d, e)));
          (%o1)               H(H(a, b), H(c, H(d, e)))
          (%i2) declare (H, nary);
          (%o2)                         done
          (%i3) H (H (a, b), H (c, H (d, e)));
          (%o3)                   H(a, b, c, d, e)

 -- Option variable: negdistrib
     Default value: true

     When negdistrib is true, -1 distributes over an expression. E.g., -(x + y) becomes - y - x.  Setting it to false will allow - (x + y) to be displayed like that.  This is sometimes useful but be very careful: like the simp flag, this is one flag you do not want to set to false as a matter of course or necessarily for other than local use in your Maxima.

     Example:

          (%i1) negdistrib;
          (%o1)                         true

          (%i2) -(x+y);
          (%o2)                       (- y) - x

          (%i3) negdistrib : not negdistrib ;
          (%o3)                         false

          (%i4) -(x+y);
          (%o4)                       - (y + x)

     Categories: Simplification flags and variables

 -- System variable: opproperties

     opproperties is the list of the special operator properties recognized by the Maxima simplifier.

     Items are added to the opproperties list by the function define_opproperty

     Example:

          (%i1) opproperties;
          (%o1) [linear, additive, multiplicative, outative, evenfun,
          oddfun, commutative, symmetric, antisymmetric, nary,
          lassociative, rassociative]

     Categories: Global variables Operators Simplification

 -- Function: define_opproperty (PROPERTY_NAME, SIMPLIFIER_FN)

     Declares the symbol PROPERTY_NAME to be an operator property, which is simplified by SIMPLIFIER_FN, which may be the name of a Maxima or Lisp function or a lambda expression. After define_opproperty is called, functions and operators may be declared to have the PROPERTY_NAME property, and SIMPLIFIER_FN is called to simplify them.

     SIMPLIFIER_FN must be a function of one argument, which is an expression in which the main operator is declared to have the PROPERTY_NAME property.

     SIMPLIFIER_FN is called with the global flag simp disabled. Therefore SIMPLIFIER_FN must be able to carry out its simplification without making use of the general simplifier.

     define_opproperty appends PROPERTY_NAME to the global list opproperties

     define_opproperty returns done.

     Example:

     Declare a new property, identity, which is simplified by simplify_identity. Declare that f and g have the new property.

          (%i1) define_opproperty (identity, simplify_identity);
          (%o1)                         done

          (%i2) simplify_identity(e) := first(e);
          (%o2)           simplify_identity(e) := first(e)

          (%i3) declare ([f, g], identity);
          (%o3)                         done

          (%i4) f(10 + t);
          (%o4)                        t + 10

          (%i5) g(3*u) - f(2*u);
          (%o5)                           u

     Categories: Operators Simplification

 -- Property: outative

     declare(f, outative) tells the Maxima simplifier that constant factors in the argument of f can be pulled out.

      1. If f is univariate, whenever the simplifier encounters f applied to a product, that product will be partitioned into factors that are constant and factors that are not and the constant factors will be pulled out.  E.g., f(a*x) will simplify to a*f(x) where a is a constant. Non-atomic constant factors will not be pulled out.

      2. If f is a function of 2 or more arguments, outativity is defined as in the case of sum or integrate i.e., f (a*g(x), x) will simplify to a * f(g(x), x) for a free of x.

     sum integrate and limit are all outative.

     Example:

          (%i1) F1 (100 * x);
          (%o1)                       F1(100 x)

          (%i2) declare (F1, outative);
          (%o2)                         done

          (%i3) F1 (100 * x);
          (%o3)                       100 F1(x)

          (%i4) declare (zz, constant);
          (%o4)                         done

          (%i5) F1 (zz * y);
          (%o5)                       zz F1(y)

     Categories: Declarations and inferences Operators

 -- Function: radcan (EXPR)

     Simplifies EXPR, which can contain logs, exponentials, and radicals, by converting it into a form which is canonical over a large class of expressions and a given ordering of variables; that is, all functionally equivalent forms are mapped into a unique form.  For a somewhat larger class of expressions, radcan produces a regular form.  Two equivalent expressions in this class do not necessarily have the same appearance, but their difference can be simplified by radcan to zero.

     For some expressions radcan is quite time consuming.  This is the cost of exploring certain relationships among the components of the expression for simplifications based on factoring and partial-fraction expansions of exponents.

     Examples:

          (%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2));
                                              a/2
          (%o1)                     log(x + 1)

          (%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x)));
          (%o2)                           2

          (%i3) radcan((%e^x-1)/(1+%e^(x/2)));
                                        x/2
          (%o3)                       %e    - 1

     Categories: Simplification functions

 -- Option variable: radexpand
     Default value: true

     radexpand controls some simplifications of radicals.

     When radexpand is all, causes nth roots of factors of a product which are powers of n to be pulled outside of the radical.  E.g. if radexpand is all, sqrt (16*x^2) simplifies to 4*x.

     More particularly, consider sqrt (x^2).

       * If radexpand is all or assume (x > 0) has been executed, sqrt(x^2) simplifies to x.

       * If radexpand is true and domain is real (its default), sqrt(x^2) simplifies to abs(x).

       * If radexpand is false, or radexpand is true and domain is complex, sqrt(x^2) is not simplified.

     Note that domain only matters when radexpand is true.

     Categories: Simplification flags and variables

 -- Property: rassociative

     declare (g, rassociative) tells the Maxima simplifier that g is right-associative.  E.g., g(g(a, b), g(c, d)) simplifies to g(a, g(b, g(c, d))).

     See also lassociative

     Categories: Declarations and inferences Operators

 -- Function: scsimp (EXPR, RULE_1, ..., RULE_N)

     Sequential Comparative Simplification (method due to Stoute). scsimp attempts to simplify EXPR according to the rules RULE_1, ..., RULE_N. If a smaller expression is obtained, the process repeats.  Otherwise after all simplifications are tried, it returns the original answer.

     example (scsimp) displays some examples.

     Categories: Simplification functions

 -- Option variable: simp
     Default value: true

     simp enables simplification.  This is the default.  simp is also an evflag, which is recognized by the function ev.  See ev

     When simp is used as an evflag with a value false, the simplification is suppressed only during the evaluation phase of an expression. The flag does not suppress the simplification which follows the evaluation phase.

     Many Maxima functions and operations require simplification to be enabled to work normally. When simplification is disabled, many results will be incomplete, and in addition there may be incorrect results or program errors.

     Examples:

     The simplification is switched off globally.  The expression sin(1.0) is not simplified to its numerical value.  The simp-flag switches the simplification on.

          (%i1) simp:false;
          (%o1)                         false

          (%i2) sin(1.0);
          (%o2)                       sin(1.0)

          (%i3) sin(1.0),simp;
          (%o3)                  0.8414709848078965

     The simplification is switched on again.  The simp-flag cannot suppress the simplification completely.  The output shows a simplified expression, but the variable x has an unsimplified expression as a value, because the assignment has occurred during the evaluation phase of the expression.

          (%i1) simp:true;
          (%o1)                         true

          (%i2) x:sin(1.0),simp:false;
          (%o2)                  0.8414709848078965

          (%i3) :lisp $x
          ((%SIN) 1.0)

     Categories: Evaluation flags

 -- Property: symmetric

     declare (h, symmetric) tells the Maxima simplifier that h is a symmetric function.  E.g., h (x, z, y) simplifies to h (x, y, z).

     commutative is synonymous with symmetric.

     Categories: Declarations and inferences Operators

 -- Function: xthru (EXPR)

     Combines all terms of EXPR (which should be a sum) over a common denominator without expanding products and exponentiated sums as ratsimp does.  xthru cancels common factors in the numerator and denominator of rational expressions but only if the factors are explicit.

     Sometimes it is better to use xthru before ratsimping an expression in order to cause explicit factors of the gcd of the numerator and denominator to be canceled thus simplifying the expression to be ratsimped.

     Examples:

          (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
                                          20
                           1       (x + 2)   - 2 y       x
          (%o1)        --------- + --------------- - ---------
                              19             20             20
                       (y + x)        (y + x)        (y + x)

          (%i2) xthru (%);
                                           20
                                    (x + 2)   - y
          (%o2)                     -------------
                                             20
                                      (y + x)

     Categories: Expressions