Simplification of expressions

(directly go to documentation on : Simplify, RadSimp, FactorialSimplify, LnExpand, LnCombine, TrigSimpCombine. )

# 11. Simplification of expressions

Simplification of expression is a big and non-trivial subject. Simplification implies that there is a preferred form. In practice the preferred form depends on the calculation at hand. This chapter describes the functions offered that allow simplification of expressions.

Simplify | try to simplify an expression
RadSimp | simplify expression with nested radicals
FactorialSimplify | Simplify hypergeometric expressions containing factorials
LnExpand | expand a logarithmic expression using standard logarithm rules
LnCombine | combine logarithmic expressions using standard logarithm rules
TrigSimpCombine | combine products of trigonometric functions

###

Simplify -- try to simplify an expression

##### Standard library

##### Calling format:

    Simplify(expr)

##### Parameters:

`expr` -- expression to simplify

##### Description:

This function tries to simplify the expression `expr` as much as possible. It does this by grouping powers within terms, and then grouping similar terms.

##### Examples:

    In> a*b*a^2/b-a^3
    Out> (b*a^3)/b-a^3;
    In> Simplify(a*b*a^2/b-a^3)
    Out> 0;

##### See also:

TrigSimpCombine , RadSimp .

###

RadSimp -- simplify expression with nested radicals

##### Standard library

##### Calling format:

    RadSimp(expr)

##### Parameters:

`expr` -- an expression containing nested radicals

##### Description:

This function tries to write the expression "expr" as a sum of roots of integers: Sqrt(e1)+Sqrt(e2)+..., where e1, e2 and so on are natural numbers. The expression "expr" may not contain free variables.

It does this by trying all possible combinations for e1, e2, ... Every possibility is numerically evaluated using `N` and compared with the numerical evaluation of "expr". If the approximations are equal (up to a certain margin), this possibility is returned. Otherwise, the expression is returned unevaluated.

Note that due to the use of numerical approximations, there is a small chance that the expression returned by `RadSimp` is close but not equal to `expr`. The last example underneath illustrates this problem. Furthermore, if the numerical value of `expr` is large, the number of possibilities becomes exorbitantly big so the evaluation may take very long.

##### Examples:

    In> RadSimp(Sqrt(9+4*Sqrt(2)))
    Out> Sqrt(8)+1;
    In> RadSimp(Sqrt(5+2*Sqrt(6)) \
      +Sqrt(5-2*Sqrt(6)))
    Out> Sqrt(12);
    In> RadSimp(Sqrt(14+3*Sqrt(3+2
    *Sqrt(5-12*Sqrt(3-2*Sqrt(2))))))
    Out> Sqrt(2)+3;

But this command may yield incorrect results:

    In> RadSimp(Sqrt(1+10^(-6)))
    Out> 1;

##### See also:

Simplify , N .

###

FactorialSimplify -- Simplify hypergeometric expressions containing factorials

##### Standard library

##### Calling format:

    FactorialSimplify(expression)

##### Parameters:

`expression` -- expression to simplify

##### Description:

`FactorialSimplify` takes an expression that may contain factorials, and tries to simplify it. An expression like (n+1)! /n! would simplify to n+1.

The following steps are taken to simplify:

- binomials are expanded into factorials
- the expression is flattened as much as possible, to reduce it to a sum of simple rational terms
- expressions like
p^n/p^m are reduced to p^(n-m) if n-m is an integer
- expressions like
n! /m! are simplified if n-m is an integer

The function `Simplify` is used to determine if the relevant expressions n-m are integers.

##### Example:

    In> FactorialSimplify( (n-k+1)! / (n-k)! )
    Out> n+1-k
    In> FactorialSimplify(n! / Bin(n,k))
    Out> k! *(n-k)!
    In> FactorialSimplify(2^(n+1)/2^n)
    Out> 2

##### See also:

Simplify , ! , Bin .

###

LnExpand -- expand a logarithmic expression using standard logarithm rules

##### Standard library

##### Calling format:

    LnExpand(expr)

##### Parameters:

`expr` -- the logarithm of an expression

##### Description:

`LnExpand` takes an expression of the form Ln(expr), and applies logarithm rules to expand this into multiple `Ln` expressions where possible. An expression like Ln(a*b^n) would be expanded to Ln(a)+n*Ln(b).

If the logarithm of an integer is discovered, it is factorised using `Factors` and expanded as though `LnExpand` had been given the factorised form. So Ln(18) goes to Ln(x)+2*Ln(3).

##### Example:

    In> LnExpand(Ln(a*b^n))
    Out> Ln(a)+Ln(b)*n
    In> LnExpand(Ln(a^m/b^n))
    Out> Ln(a)*m-Ln(b)*n
    In> LnExpand(Ln(60))
    Out> 2*Ln(2)+Ln(3)+Ln(5)
    In> LnExpand(Ln(60/25))
    Out> 2*Ln(2)+Ln(3)-Ln(5)

##### See also:

Ln , LnCombine , Factors .

###

LnCombine -- combine logarithmic expressions using standard logarithm rules

##### Standard library

##### Calling format:

    LnCombine(expr)

##### Parameters:

`expr` -- an expression possibly containing multiple `Ln` terms to be combined

##### Description:

`LnCombine` finds `Ln` terms in the expression it is given, and combines them using logarithm rules. It is intended to be the exact converse of `LnExpand`.

##### Example:

    In> LnCombine(Ln(a)+Ln(b)*n)
    Out> Ln(a*b^n)
    In> LnCombine(2*Ln(2)+Ln(3)-Ln(5))
    Out> Ln(12/5)

##### See also:

Ln , LnExpand .

###

TrigSimpCombine -- combine products of trigonometric functions

##### Standard library

##### Calling format:

    TrigSimpCombine(expr)

##### Parameters:

`expr` -- expression to simplify

##### Description:

This function applies the product rules of trigonometry, e.g. Cos(u)*Sin(v)=1/2*(Sin(v-u)+Sin(v+u)). As a result, all products of the trigonometric functions `Cos` and `Sin` disappear. The function also tries to simplify the resulting expression as much as possible by combining all similar terms.

This function is used in for instance `Integrate`, to bring down the expression into a simpler form that hopefully can be integrated easily.

##### Examples:

    In> PrettyPrinter'Set("PrettyForm");

    True

    In> TrigSimpCombine(Cos(a)^2+Sin(a)^2)

    1

    In> TrigSimpCombine(Cos(a)^2-Sin(a)^2)

    Cos( -2 * a )

    Out>
    In> TrigSimpCombine(Cos(a)^2*Sin(b))

    Sin( b )   Sin( -2 * a + b )
    -------- + -----------------
       2               4

        Sin( -2 * a - b )
      - -----------------
                4

##### See also:

Simplify , Integrate , Expand , Sin , Cos , Tan .