Wolfram Language & System Documentation Center

Simplify

performs a sequence of algebraic and other transformations on expr and returns the simplest form it finds.

Simplify[expr,assum]

does simplification using assumptions.

Details and Options

Simplify tries expanding, factoring, and doing many other transformations on expressions, keeping track of the simplest form obtained.
Simplify can be used on equations, inequalities, and domain specifications.
Quantities that appear algebraically in inequalities are always assumed to be real.
FullSimplify does more extensive simplification than Simplify.
You can specify default assumptions for Simplify using Assuming.
The following options can be given:

Assumptions	$Assumptions	default assumptions to append to assum
ComplexityFunction	Automatic	how to assess the complexity of each form generated
ExcludedForms	{}	patterns specifying forms of subexpression that should not be touched
TimeConstraint	300	for how many seconds to try doing any particular transformation
TransformationFunctions	Automatic	functions to try in transforming the expression
Trig	True	whether to do trigonometric as well as algebraic transformations

Assumptions can consist of equations, inequalities, domain specifications such as x∈Integers, and logical combinations of these.
With the setting TimeConstraint->{t_loc,t_tot}, at most t_loc seconds are spent for any particular transformation, and at most t_tot seconds are spent for all transformations before the best result is returned.
Simplify can be used with symbolic array expressions.

Examples

open all close all

Basic Examples (3)

Simplify a rational function:

Wolfram Language code: D[Integrate[1 / (x ^ 3 + 1), x], x]

Wolfram Language code: Simplify[%]

Simplify a trigonometric expression:

Wolfram Language code: Simplify[Sin[x] ^ 2 + Cos[x] ^ 2]

Simplify can get further if assumptions are made about x:

Wolfram Language code: Simplify[Sqrt[x ^ 2]]

Wolfram Language code: Simplify[Sqrt[x ^ 2], x > 0]

Wolfram Language code: Simplify[Sqrt[x ^ 2], Element[x, Reals]]

Scope (5)

Simplify a polynomial:

Wolfram Language code: Simplify[(x - 1)(x + 1)(x ^ 2 + 1) + 1]

Simplify a rational expression:

Wolfram Language code: Simplify[3 / (x + 3) + x / (x + 3)]

Simplify a trigonometric expression:

Wolfram Language code: Simplify[2Tan[x] / (1 + Tan[x] ^ 2)]

Simplify an exponential expression:

Wolfram Language code: Simplify[(E ^ x - E ^ -x) / Sinh[x]]

Simplify an equation:

Wolfram Language code: Simplify[2x - 4y + 6z - 10 == -8]

Simplify expressions using assumptions:

Wolfram Language code: Simplify[1 / Sqrt[x] - Sqrt[1 / x], x > 0]

Wolfram Language code: Simplify[Log[x ^ p], x > 0 && Element[p, Reals]]

Wolfram Language code: Simplify[Sin[n Pi], Element[n, Integers]]

Use assumptions to prove inequalities:

Wolfram Language code: Simplify[x ^ 2 > 3, x > 2]

Wolfram Language code: Simplify[Abs[x] < 2, x ^ 2 + y ^ 2 < 4]

Simplify symbolic array expressions:

Wolfram Language code: Simplify[a.b + 2a.c]

Wolfram Language code: Simplify[m.Inverse[m], Element[m, Matrices[{n, n}]]]

Wolfram Language code:

a = MatrixSymbol["a", {n, n}];
Simplify[Tr[Transpose[KroneckerProduct[Transpose[a], a]]]]

Wolfram Language code: Simplify[D[(VectorSymbol["v", n] + x).(VectorSymbol["v", n] + x), x], Element[x, Complexes]]

Options (10)

Assumptions (3)

Assumptions can be given both as an argument and as an option value:

Wolfram Language code: Simplify[Cos[k Pi] ^ m, Element[k, Integers], Assumptions -> Mod[m, 2] == 0]

The default value of the Assumptions option is $Assumptions:

Wolfram Language code: Assuming[x > 0, Simplify[Sqrt[x ^ 2]]]

Wolfram Language code: Simplify[Sqrt[x ^ 2]]

When assumptions are given as an argument, $Assumptions is used as well:

Wolfram Language code: Assuming[x > 0, Simplify[Sqrt[x ^ 2 y ^ 2], y < 0]]

Specifying assumptions as an option value prevents Simplify from using $Assumptions:

Wolfram Language code: Assuming[x > 0, Simplify[Sqrt[x ^ 2 y ^ 2], Assumptions -> y < 0]]

ComplexityFunction (2)

The default ComplexityFunction counts the subexpressions and digits of integers:

Wolfram Language code: Simplify[100 Log[2]]

LeafCount counts only the number of subexpressions:

Wolfram Language code: Simplify[100 Log[2], ComplexityFunction -> LeafCount]

With the default ComplexityFunction, Abs[x] is simpler than the FullForm of -x:

Wolfram Language code: Simplify[Abs[x], x < 0]

Wolfram Language code: Map[FullForm, {Abs[x], -x}]

This complexity function makes Abs more expensive than Times:

Wolfram Language code: f[e_] := 100Count[e, _Abs, {0, Infinity}] + LeafCount[e]

Wolfram Language code: Simplify[Abs[x], x < 0, ComplexityFunction -> f]

ExcludedForms (1)

This gives no simplification:

Wolfram Language code: Simplify[(x - 1)(x + 1)(x ^ 2 + 1)(x - 2) ^ 10]

Excluding transformations of (x-2)^10 allows Simplify to expand the remaining terms:

Wolfram Language code: Simplify[(x - 1)(x + 1)(x ^ 2 + 1)(x - 2) ^ 10, ExcludedForms -> {(_Plus) ^ _}]

TimeConstraint (2)

This takes a long time, due to trigonometric expansion, but does not yield a simplification:

Wolfram Language code: Simplify[2Sin[10x + 11y + 12z]Cos[10x + 10y + 10t]]//Timing

Use TimeConstraint to limit the time spent on any single transformation:

Wolfram Language code: Simplify[2Sin[10x + 11y + 12z]Cos[10x + 10y + 10t], TimeConstraint -> 1]//Timing

A similar example, where the transformation yields a simplification:

Wolfram Language code: Simplify[2Sin[10x + 11y + 12z]Cos[10x + 10y + 10z]]//Timing

In this case, setting TimeConstraint prevents some simplification:

Wolfram Language code: Simplify[2Sin[10x + 11y + 12z]Cos[10x + 10y + 10z], TimeConstraint -> 1]//Timing

TransformationFunctions (1)

Here Simplify uses t as the only transformation:

Wolfram Language code: t[e_] := PolynomialReduce[e, {s ^ 2 + c ^ 2 - 1}, {c, s}][[2]]

Wolfram Language code: Simplify[(c ^ 3 - s ^ 3) ^ 2 - (s ^ 3 + c ^ 3) ^ 2, TransformationFunctions -> {t}]

Here Simplify uses both t and all built-in transformations:

Wolfram Language code: Simplify[(c ^ 3 - s ^ 3) ^ 2 - (s ^ 3 + c ^ 3) ^ 2, TransformationFunctions -> {Automatic, t}]

Trig (1)

By default, Simplify uses trigonometric identities:

Wolfram Language code: Simplify[4Sin[x] ^ 2Cos[x] ^ 2 + 4Sin[x]Cos[x] + 1]

With Trig->False, Simplify does not use trigonometric identities:

Wolfram Language code: Simplify[4Sin[x] ^ 2Cos[x] ^ 2 + 4Sin[x]Cos[x] + 1, Trig -> False]

Applications (4)

Prove that a solution satisfies its equations:

Wolfram Language code: Solve[x ^ 2 + x + 1 == 0, x]

Wolfram Language code: x ^ 2 + x + 1 == 0 /. %//Simplify

Wolfram Language code: DSolve[y''[x] + y[x] == Exp[x], y, x]

Wolfram Language code: y''[x] + y[x] == Exp[x] /. First[%]//Simplify

Wolfram Language code: RSolve[y[k + 2] + y[k] == 2 ^ k, y, k]

Wolfram Language code: y[k + 2] + y[k] == 2 ^ k /. First[%]//Simplify

Show that the arithmetic mean is larger than the geometric one:

Wolfram Language code: Simplify[(x + y) / 2 >= Sqrt[x y], x >= 0 && y >= 0]

This applies Fermat's little theorem:

Wolfram Language code: Simplify[Mod[a ^ p, p], a∈Integers && p∈Primes]

Prove commutativity from Wolfram's minimal axiom for Boolean algebra:

Wolfram Language code: Simplify[f[a, b] == f[b, a], ForAll[{p, q, r}, f[f[f[p, q], r], f[p, f[f[p, r], p]]] == r]]

Properties & Relations (3)

Use Assuming to propagate assumptions:

Wolfram Language code: Assuming[x > 0, Simplify[Sqrt[x ^ 2]]]

Use FullSimplify to simplify expressions involving special functions:

Wolfram Language code: Simplify[Gamma[x] Gamma[1 - x]]

Wolfram Language code: FullSimplify[%]

ArraySimplify performs only array transformations:

Wolfram Language code: v = VectorSymbol["v", n / 2 + m / 2];

Wolfram Language code: ArraySimplify[v - Transpose[v]]

Simplify performs other transformations as well:

Wolfram Language code: Simplify[v - Transpose[v]]

Possible Issues (2)

The Wolfram Language evaluates zero times a symbolic expression to zero:

Wolfram Language code: 0 symbolic

This happens even if the symbolic expression is always infinite:

Wolfram Language code: hiddenzero = x ^ 2 + 2x + 1 - (x + 1) ^ 2;

Wolfram Language code: 0 / hiddenzero

Because of this, results of simplification of expressions with singularities are uncertain:

Wolfram Language code: anotherhiddenzero = Sin[x] ^ 2 + Cos[x] ^ 2 - 1;

Wolfram Language code: betterhiddenzero = Gamma[x + 1] - x Gamma[x];

Wolfram Language code:

Map[Simplify, {hiddenzero / anotherhiddenzero, anotherhiddenzero / hiddenzero, hiddenzero / betterhiddenzero, betterhiddenzero / hiddenzero}]

In this case, FullSimplify recognizes the zero:

Wolfram Language code: FullSimplify[betterhiddenzero]

Results of simplification may depend on the names of symbols:

Wolfram Language code: Simplify[(1 - a ^ 2) / b ^ 2, a ^ 2 + b ^ 2 == 1]

Wolfram Language code: Simplify[(1 - c ^ 2) / b ^ 2, c ^ 2 + b ^ 2 == 1]

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

Simplify

Details and Options

Examples

Basic Examples (3)

Scope (5)