Algebraic Manipulation—Wolfram Documentation

Algebraic Manipulation

Structural Operations on Polynomials

Expand[poly]	expand out products and powers
Factor[poly]	factor completely
FactorTerms[poly]	pull out any overall numerical factor
FactorTerms[poly,{x,y,…}]	pull out any overall factor that does not depend on x, y, …
Collect[poly,x]	arrange a polynomial as a sum of powers of x
Collect[poly,{x,y,…}]	arrange a polynomial as a sum of powers of x, y, …

Structural operations on polynomials.

Here is a polynomial in one variable:

Expand expands out products and powers, writing the polynomial as a simple sum of terms:

Factor performs complete factoring of the polynomial:

FactorTerms pulls out the overall numerical factor from t:

There are several ways to write any polynomial. The functions Expand, FactorTerms, and Factor give three common ways. Expand writes a polynomial as a simple sum of terms, with all products expanded out. FactorTerms pulls out common factors from each term. Factor does complete factoring, writing the polynomial as a product of terms, each of as low degree as possible.

When you have a polynomial in more than one variable, you can put the polynomial in different forms by essentially choosing different variables to be "dominant". Collect[poly,x] takes a polynomial in several variables and rewrites it as a sum of terms containing different powers of the "dominant variable" x.

Here is a polynomial in two variables:

Collect reorganizes the polynomial so that x is the "dominant variable":

If you specify a list of variables, Collect will effectively write the expression as a polynomial in these variables:

Expand[poly,patt]

expand out poly, avoiding those parts which do not contain terms matching patt

Controlling polynomial expansion.

This avoids expanding parts which do not contain x:

This avoids expanding parts which do not contain objects matching b[_]:

Expanding powers and logarithms.

The Wolfram System does not automatically expand out expressions of the form (ab)^c except when c is an integer. In general it is only correct to do this expansion if a and b are positive reals. Nevertheless, the function PowerExpand does the expansion, effectively assuming that a and b are indeed positive reals.

The Wolfram System does not automatically expand out this expression:

PowerExpand does the expansion, effectively assuming that x and y are positive reals:

Log is not automatically expanded out:

PowerExpand returns a result correct for the given assumptions:

Collect[poly,patt]	collect separately terms involving each object that matches patt
Collect[poly,patt,h]	apply h to each final coefficient obtained

Ways of collecting terms.

Here is an expression involving various functions f:

This collects terms that match f[_]:

This applies Factor to each coefficient obtained:

HornerForm[expr,x]

puts expr into Horner form with respect to x

Horner form is a way of arranging a polynomial that allows numerical values to be computed more efficiently by minimizing the number of multiplications.

This gives the Horner form of a polynomial:

Finding the Structure of a Polynomial

PolynomialQ[expr,x]	test whether expr is a polynomial in x
PolynomialQ[expr,{x₁,x₂,…}]	test whether expr is a polynomial in the x_i
Variables[poly]	a list of the variables in poly
Exponent[poly,x]	the maximum exponent with which x appears in poly
Coefficient[poly,expr]	the coefficient of expr in poly
Coefficient[poly,expr,n]	the coefficient of exprⁿ in poly
Coefficient[poly,expr,0]	the term in poly independent of expr
CoefficientList[poly,{x₁,x₂,…}]	generate an array of the coefficients of the x_i in poly
CoefficientRules[poly,{x₁,x₂,…}]	get exponent vectors and coefficients of monomials

Finding the structure of polynomials written in expanded form.

Here is a polynomial in two variables:

This is the polynomial in expanded form:

This expression, however, is not a polynomial in x:

Variables gives a list of the variables in the polynomial t:

This gives the maximum exponent with which x appears in the polynomial t. For a polynomial in one variable, Exponent gives the degree of the polynomial:

Coefficient[poly,expr] gives the total coefficient with which expr appears in poly. In this case, the result is a sum of two terms:

This picks out the coefficient of

in t:

For multivariate polynomials, CoefficientList gives an array of the coefficients for each power of each variable:

It is important to notice that the functions in this tutorial will often work even on polynomials that are not explicitly given in expanded form.

Many of the functions also work on expressions that are not strictly polynomials.

Without giving specific integer values to a, b, and c, this expression cannot strictly be considered a polynomial:

Exponent[expr,x] still gives the maximum exponent of x in expr, but here has to write the result in symbolic form:

The leading term of a polynomial can be chosen in many different ways. For multivariate polynomials, sorting by the total degree of the monomials is often useful.

Different representations of polynomials.

Here is a polynomial in three variables:

This is the list of the monomials:

This is the list of the monomials represented as exponent vectors and coefficients:

The first vector corresponds to

If the second argument to MonomialList or CoefficientRules is omitted, the variables are taken in the order in which they are returned by the function Variables.

The list of the variables is not always sorted:

Now the first vector corresponds to

An order can also be described by giving a weight matrix. In that case the exponent vectors are multiplied by the weight matrix and the results are sorted lexicographically, also in the decreasing order. The matrices for different orderings are given as follows.

Weight matrices corresponding to different orderings.

For functions such as GroebnerBasis and PolynomialReduce, it is necessary that the order be well-founded, which ensures that any decreasing sequence of elements is finite (the elements being the vectors of non-negative exponents). In order for that condition to hold, the first nonzero value in each column of the weight matrix must be positive.

The default sorting used for polynomial terms in an expression corresponds to the negative lexicographic ordering with variables sorted in the reversed order. This is commonly known as reverse lexicographic ordering.

This is the internal representation of a polynomial. The arguments of Plus and Times are sorted on evaluation:

This is the sorted list of terms:

This is the reverse lexicographic order in variables {x,y,z}:

This is the same order specified by a weight matrix:

The result is identical to the automatically sorted list of terms in poly:

TraditionalForm tries to arrange the terms in an order close to the lexicographic ordering.

This uses advanced typesetting capabilities to obtain the list of terms in the same order as they appear in the TraditionalForm output:

The result agrees with the list of the monomials given in the default (lexicographic) order:

The option ParameterVariables tells TraditionalForm which variables should be excluded from the ordering.

By default, the list of independent variables is assumed to be {a,b,x}:

Here x is assumed to be the only variable:

One can obtain additional orderings from the six orderings used in MonomialList simply by reversing the resulting list. This is effectively equivalent to negating the exponent vectors. In a commutative setting, one can also obtain other orderings by reversing the order of the variables.

This diagram illustrates the relations between various orderings. Red lines indicate reversing the list of variables and blue lines indicate negating the power vectors.

Structural Operations on Rational Expressions

For ordinary polynomials, Factor and Expand give the most important forms. For rational expressions, there are many different forms that can be useful.

Different kinds of expansion for rational expressions.

Here is a rational expression:

Expand expands the numerator of each term, and divides all the terms by the appropriate denominators:

ExpandAll does all possible expansions in the numerator and denominator of each term:

ExpandAll[expr,patt]

, etc.

avoid expanding parts which contain no terms matching patt

This avoids expanding the term which does not contain z:

Together[expr]	combine all terms over a common denominator
Apart[expr]	write an expression as a sum of terms with simple denominators
Cancel[expr]	cancel common factors between numerators and denominators
Factor[expr]	perform a complete factoring

Structural operations on rational expressions.

Here is a rational expression:

Together puts all terms over a common denominator:

You can use Factor to factor the numerator and denominator of the resulting expression:

Apart writes the expression as a sum of terms, with each term having as simple a denominator as possible:

Cancel cancels any common factors between numerators and denominators:

Factor first puts all terms over a common denominator, then factors the result:

In mathematical terms, Apart decomposes a rational expression into "partial fractions".

In expressions with several variables, you can use Apart[expr,var] to do partial fraction decompositions with respect to different variables.

Here is a rational expression in two variables:

This gives the partial fraction decomposition with respect to x:

Here is the partial fraction decomposition with respect to y:

Algebraic Operations on Polynomials

For many kinds of practical calculations, the only operations you will need to perform on polynomials are essentially structural ones.

If you do more advanced algebra with polynomials, however, you will have to use the algebraic operations discussed in this tutorial.

You should realize that most of the operations discussed in this tutorial work only on ordinary polynomials, with integer exponents and rational‐number coefficients for each term.

PolynomialQuotient[poly₁,poly₂,x]	find the result of dividing the polynomial poly₁ in x by poly₂, dropping any remainder term
PolynomialRemainder[poly₁,poly₂,x]	find the remainder from dividing the polynomial poly₁ in x by poly₂
PolynomialQuotientRemainder[poly₁,poly₂,x]
	give the quotient and remainder in a list
PolynomialMod[poly,m]	reduce the polynomial poly modulo m
PolynomialGCD[poly₁,poly₂]	find the greatest common divisor of two polynomials
PolynomialLCM[poly₁,poly₂]	find the least common multiple of two polynomials
PolynomialExtendedGCD[poly₁,poly₂]	find the extended greatest common divisor of two polynomials
Resultant[poly₁,poly₂,x]	find the resultant of two polynomials
Subresultants[poly₁,poly₂,x]	find the principal subresultant coefficients of two polynomials
Discriminant[poly,x]	find the discriminant of the polynomial poly
GroebnerBasis[{poly₁,poly₂,…},{x₁,x₂,…}]
	find the Gröbner basis for the polynomials poly_i
GroebnerBasis[{poly₁,poly₂,…},{x₁,x₂,…},{y₁,y₂,…}]
	find the Gröbner basis eliminating the y_i
PolynomialReduce[poly,{poly₁,poly₂,…},{x₁,x₂,…}]
	find a minimal representation of poly in terms of the poly_i

Reduction of polynomials.

This gives back the original expression:

Here the result depends on whether the polynomials are considered to be in x or y:

PolynomialMod is essentially the analog for polynomials of the function Mod for integers. When the modulus m is an integer, PolynomialMod[poly,m] simply reduces each coefficient in poly modulo the integer m. If m is a polynomial, then PolynomialMod[poly,m] effectively tries to get a polynomial with as low a degree as possible by subtracting from poly appropriate multiples q m of m. The multiplier q can itself be a polynomial, but its degree is always less than the degree of poly. PolynomialMod yields a final polynomial whose degree and leading coefficient are both as small as possible.

The main difference between PolynomialMod and PolynomialRemainder is that while the former works simply by multiplying and subtracting polynomials, the latter uses division in getting its results. In addition, PolynomialMod allows reduction by several moduli at the same time. A typical case is reduction modulo both a polynomial and an integer.

PolynomialGCD[poly₁,poly₂] finds the highest degree polynomial that divides the poly_i exactly. It gives the analog for polynomials of the integer function GCD.

PolynomialGCD gives the greatest common divisor of the two polynomials:

Here is the resultant with respect to y of two polynomials in x and y. The original polynomials have a common root in y only for values of x at which the resultant vanishes:

The function Discriminant[poly,x] is the product of the squares of the differences of its roots. It can be used to determine whether the polynomial has any repeated roots. The discriminant is equal to the resultant of the polynomial and its derivative, up to a factor independent of the variable.

This polynomial has a repeated root, so its discriminant vanishes:

This polynomial has distinct roots, so its discriminant is nonzero:

Gröbner bases appear in many modern algebraic algorithms and applications. The function GroebnerBasis[{poly₁,poly₂,…},{x₁,x₂,…}] takes a set of polynomials, and reduces this set to a canonical form from which many properties can conveniently be deduced. An important feature is that the set of polynomials obtained from GroebnerBasis always has exactly the same collection of common roots as the original set.

The

is effectively redundant, and so does not appear in the Gröbner basis:

The polynomial 1 has no roots, showing that the original polynomials have no common roots:

The polynomials are effectively unwound here, and can now be seen to have exactly five common roots:

Functions for factoring polynomials.

Factor, FactorTerms, and FactorSquareFree perform various degrees of factoring on polynomials. Factor does full factoring over the integers. FactorTerms extracts the "content" of the polynomial. FactorSquareFree pulls out any multiple factors that appear.

Here is a polynomial, in expanded form:

FactorTerms pulls out only the factor of 2 that does not depend on x:

FactorSquareFree factors out the 2 and the term

, but leaves the rest unfactored:

Factor does full factoring, recovering the original form:

Particularly when you write programs that work with polynomials, you will often find it convenient to pick out pieces of polynomials in a standard form. The function FactorList gives a list of all the factors of a polynomial, together with their exponents. The first element of the list is always the overall numerical factor for the polynomial.

The form that FactorList returns is the analog for polynomials of the form produced by FactorInteger for integers.

Here is a list of the factors of the polynomial in the previous set of examples. Each element of the list gives the factor, together with its exponent:

Factoring polynomials with complex coefficients.

Factor and related functions usually handle only polynomials with ordinary integer or rational‐number coefficients. If you set the option GaussianIntegers->True, however, then Factor will allow polynomials with coefficients that are complex numbers with rational real and imaginary parts. This often allows more extensive factorization to be performed.

This polynomial is irreducible when only ordinary integers are allowed:

When Gaussian integer coefficients are allowed, the polynomial factors:

A polynomial is irreducible over a field F if it cannot be represented as a product of two nonconstant polynomials with coefficients in F.

This polynomial is irreducible over the rationals:

Over the Gaussian rationals, the polynomial is reducible:

By default, algebraic numbers are treated as independent variables:

Over the rationals extended by Sqrt[2], the polynomial is reducible:

Cyclotomic[n,x]

give the cyclotomic polynomial of order n in x

This is the cyclotomic polynomial

Decompose[poly,x]

decompose poly, if possible, into a composition of a list of simpler polynomials

Here are two polynomial functions:

This gives the composition of the two functions:

Decompose[poly,x] is set up to give a list of polynomials in x, which, if composed, reproduce the original polynomial. The original polynomial can contain variables other than x, but the sequence of polynomials that Decompose produces are all intended to be considered as functions of x.

Generating interpolating polynomials.

This yields a quadratic polynomial which goes through the specified three points:

When x is 0, the polynomial has value 2:

Polynomials Modulo Primes

Functions for manipulating polynomials over finite fields.

Here is an ordinary polynomial:

This reduces the coefficients modulo 2:

Here are the factors of the resulting polynomial over the integers:

If you work modulo 2, further factoring becomes possible:

are called elementary symmetric polynomials in variables

SymmetricPolynomial[k,{x₁,…,x_n}]	give the ^th elementary symmetric polynomial in the variables
SymmetricReduction[f,{x₁,…,x_n}]	give a pair of polynomials in such that , where is the symmetric part and is the remainder
SymmetricReduction[f,{x₁,…,x_n},{s₁,…,s_n}]
	give the pair with the elementary symmetric polynomials in replaced by

Functions for symmetric polynomial computations.

Here is the elementary symmetric polynomial of degree three in four variables:

This writes the polynomial

in terms of elementary symmetric polynomials. The input polynomial is symmetric, so the remainder is zero:

Here the elementary symmetric polynomials in the symmetric part are replaced with variables

. The polynomial is not symmetric, so the remainder is not zero:

Polynomials over Algebraic Number Fields

Functions like Factor usually assume that all coefficients in the polynomials they produce must involve only rational numbers. But by setting the option Extension you can extend the domain of coefficients that will be allowed.

Factor[poly,Extension->{a₁,a₂,…}]

factor poly allowing coefficients that are rational combinations of the a_i

Factoring polynomials over algebraic number fields.

Allowing only rational number coefficients, this polynomial cannot be factored:

With coefficients that can involve

, the polynomial can now be factored:

The polynomial can also be factored if one allows coefficients involving

Expand gives the original polynomial back again:

Factoring polynomials with algebraic number coefficients.

Here is a polynomial with a coefficient involving

By default, Factor will not factor this polynomial:

But now the field of coefficients is extended by including

, and the polynomial is factored:

Other polynomial functions work much like Factor. By default, they treat algebraic number coefficients just like independent symbolic variables. But with the option Extension->Automatic they perform operations on these coefficients.

By default, Cancel does not reduce these polynomials:

A polynomial is irreducible over a field F if it cannot be represented as a product of two nonconstant polynomials with coefficients in F.

By default, algebraic numbers are treated as independent variables:

Over the rationals extended by Sqrt[2], the polynomial is reducible:

This polynomial is irreducible over the rationals:

Over the rationals extended by Sqrt[3], the polynomial is reducible:

This polynomial is irreducible over the field of all complex numbers:

Trigonometric Expressions

TrigExpand[expr]	expand trigonometric expressions out into a sum of terms
TrigFactor[expr]	factor trigonometric expressions into products of terms
TrigFactorList[expr]	give terms and their exponents in a list
TrigReduce[expr]	reduce trigonometric expressions using multiple angles

Functions for manipulating trigonometric expressions.

This expands out a trigonometric expression:

This factors the expression:

And this reduces the expression to a form that is linear in the trigonometric functions:

TrigExpand works on hyperbolic as well as circular functions:

The Wolfram System automatically uses functions like Tan whenever it can:

TrigToExp[expr]	write trigonometric functions in terms of exponentials
ExpToTrig[expr]	write exponentials in terms of trigonometric functions

Converting to and from exponentials.

TrigToExp writes trigonometric functions in terms of exponentials:

TrigToExp also works with hyperbolic functions:

ExpToTrig does the reverse, getting rid of explicit complex numbers whenever possible:

ExpToTrig deals with hyperbolic as well as circular functions:

You can also use ExpToTrig on purely numerical expressions:

Expressions Involving Complex Variables

The Wolfram Language usually pays no attention to whether variables like x stand for real or complex numbers. Sometimes, however, you may want to make transformations which are appropriate only if particular variables are assumed to be either real or complex.

The function ComplexExpand expands out algebraic and trigonometric expressions, making definite assumptions about the variables that appear.

ComplexExpand[expr]	expand expr assuming that all variables are real
ComplexExpand[expr,{x₁,x₂,…}]	expand expr assuming that the x_i are complex

Expanding complex expressions.

This expands the expression, assuming that x and y are both real:

In this case, a is assumed to be real, but x is assumed to be complex, and is broken into explicit real and imaginary parts:

With several complex variables, you quickly get quite complicated results:

There are several ways to write a complex variable z in terms of real parameters. As above, for example, z can be written in the "Cartesian form" Re[z]+I Im[z]. But it can equally well be written in the "polar form" Abs[z] Exp[I Arg[z]].

The option TargetFunctions in ComplexExpand allows you to specify how complex variables should be written. TargetFunctions can be set to a list of functions from the set {Re,Im,Abs,Arg,Conjugate,Sign}. ComplexExpand will try to give results in terms of whichever of these functions you request. The default is typically to give results in terms of Re and Im.

This gives an expansion in Cartesian form:

Here is an expansion in polar form:

Here is another form of expansion:

Logical and Piecewise Functions

Nested logical and piecewise functions can be expanded out much like nested arithmetic functions. You can do this using LogicalExpand and PiecewiseExpand.

Expanding out logical and piecewise functions.

LogicalExpand puts logical expressions into a standard disjunctive normal form (DNF), consisting of an OR of ANDs.

By default, the Wolfram Language leaves this expression unchanged:

LogicalExpand works on all logical functions, always converting them into a standard OR of ANDs form. Sometimes the results are inevitably quite large.

Xor can be expressed as an OR of ANDs:

Any collection of nested conditionals can always in effect be flattened into a piecewise normal form consisting of a single Piecewise object. You can do this in the Wolfram Language using PiecewiseExpand.

By default, the Wolfram Language leaves this expression unchanged:

Functions like Max and Abs, as well as Clip and UnitStep, implicitly involve conditionals, and combinations of them can again be reduced to a single Piecewise object using PiecewiseExpand.

This gives a result as a single Piecewise object:

With x assumed real, this can also be written as a Piecewise object:

Functions like Floor, Mod, and FractionalPart can also be expressed in terms of Piecewise objects, though in principle they can involve an infinite number of cases.

Without a bound on x, this would yield an infinite number of cases:

The Wolfram Language by default limits the number of cases that the Wolfram Language will explicitly generate in the expansion of any single piecewise function such as Floor at any stage in a computation. You can change this limit by resetting the value of $MaxPiecewiseCases.

Simplify[expr]	try various algebraic and trigonometric transformations to simplify an expression
FullSimplify[expr]	try a much wider range of transformations

The Wolfram Language does not automatically simplify an algebraic expression like this:

Simplify performs standard algebraic and trigonometric simplifications:

It does not, however, do more sophisticated transformations that involve, for example, special functions:

Controlling simplification.

Here is an expression involving trigonometric functions and square roots:

FullSimplify[expr,TimeConstraint->t]
	try to simplify expr, working for at most t seconds on each transformation
FullSimplify[expr,TransformationFunctions->{f₁,f₂,…}]
	use only the functions f_i in trying to transform parts of expr
FullSimplify[expr,TransformationFunctions->{Automatic,f₁,f₂,…}]
	use built‐in transformations as well as the f_i
Simplify[expr,ComplexityFunction->c] and FullSimplify[expr,ComplexityFunction->c]
	simplify using c to determine what form is considered simplest

Further control of simplification.

In both Simplify and FullSimplify there is always an issue of what counts as the "simplest" form of an expression. You can use the option ComplexityFunction->c to provide a function to determine this. The function will be applied to each candidate form of the expression, and the one that gives the smallest numerical value will be considered simplest.

With its default definition of simplicity, Simplify leaves this unchanged:

This now tries to minimize the number of elements in the expression:

The Wolfram Language normally makes as few assumptions as possible about the objects you ask it to manipulate. This means that the results it gives are as general as possible. But sometimes these results are considerably more complicated than they would be if more assumptions were made.

Refine[expr,assum]	refine expr using assumptions
Simplify[expr,assum]	simplify with assumptions
FullSimplify[expr,assum]	full simplify with assumptions
FunctionExpand[expr,assum]	function expand with assumptions

Doing operations with assumptions.

Simplify by default does essentially nothing with this expression:

The reason is that its value is quite different for different choices of x:

With the assumption x>0, Simplify can immediately reduce the expression to 0:

Without making assumptions about x and y, nothing can be done:

If x and y are both assumed positive, the log can be expanded:

By applying Simplify and FullSimplify with appropriate assumptions to equations and inequalities, you can in effect establish a vast range of theorems.

Without making assumptions about x, the truth or falsity of this equation cannot be determined:

Now Simplify can prove that the equation is true:

This establishes the standard result that the arithmetic mean is larger than the geometric one:

Simplify and FullSimplify always try to find the simplest forms of expressions. Sometimes, however, you may just want the Wolfram Language to follow its ordinary evaluation process, but with certain assumptions made. You can do this using Refine. The way it works is that Refine[expr,assum] performs the same transformations as the Wolfram Language would perform automatically if the variables in expr were replaced by numerical expressions satisfying the assumptions assum.

There is no simpler form that Simplify can find:

Refine just evaluates Log[x] as it would for any explicit negative number x:

An important class of assumptions is those which assert that some object is an element of a particular domain. You can set up such assumptions using x∈dom, where the ∈ character can be entered as EscelEsc or ∖[Element].

x∈dom or Element[x,dom]	assert that x is an element of the domain dom
{x₁,x₂,…}∈dom	assert that all the x_i are elements of the domain dom
patt∈dom	assert that any expression that matches patt is an element of the domain dom

Asserting that objects are elements of domains.

This confirms that

is an element of the domain of real numbers:

These numbers are all elements of the domain of algebraic numbers:

The Wolfram Language knows that

is not an algebraic number:

Current mathematics has not established whether

is an algebraic number or not:

This represents the assertion that the symbol x is an element of the domain of real numbers:

Domains supported by the Wolfram Language.

If you say that a variable satisfies an inequality, the Wolfram Language will automatically assume that it is real:

By using Simplify, FullSimplify, and FunctionExpand with assumptions, you can access many of the Wolfram Language's vast collection of mathematical facts.

This uses the periodicity of the tangent function:

The assumption k/2 ∈ Integers implies that k must be even:

The Wolfram Language knows about discrete mathematics and number theory as well as continuous mathematics.

This uses Wilson's theorem to simplify the result:

This uses the multiplicative property of the Euler phi function:

In something like Simplify[expr,assum] or Refine[expr,assum], you explicitly give the assumptions you want to use. But sometimes you may want to specify one set of assumptions to use in a whole collection of operations. You can do this by using Assuming.

Assuming[assum,expr]	use assumptions assum in the evaluation of expr
$Assumptions	the default assumptions to use

Specifying assumptions with larger scopes.

This tells Simplify to use the default assumption x>0:

This combines the two assumptions given:

Functions like Simplify and Refine take the option Assumptions, which specifies what default assumptions they should use. By default, the setting for this option is Assumptions:>$Assumptions. The way Assuming then works is to assign a local value to $Assumptions, much as in Block.

In addition to Simplify and Refine, a number of other functions take Assumptions options, and thus can have assumptions specified for them by Assuming. Examples are FunctionExpand, Integrate, Limit, Series, and LaplaceTransform.

The assumption is automatically used in Integrate: