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.

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.

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

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.

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.

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.

By default, the monomials are sorted lexicographically and given in the decreasing order. In the previous example, {5,4,1} (corresponding to ) is taken to precede {5,3,2} (corresponding to ) by the second element.

An order is described by defining how two vectors of exponents and are sorted. For the lexicographic order,

.

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.

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.

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

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

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.

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

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.

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.

Given two polynomials and , one can always uniquely write , where the degree of is less than the degree of . PolynomialQuotient gives the quotient , and PolynomialRemainder gives the remainder .

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.

The function Resultant[poly₁,poly₂,x] is used in a number of classical algebraic algorithms. The resultant of two polynomials and , both with leading coefficient one, is given by the product of all the differences between the roots of the polynomials. It turns out that for any pair of polynomials, the resultant is always a polynomial in their coefficients. By looking at when the resultant is zero, you can tell for what values of their parameters two polynomials have a common root. Two polynomials with leading coefficient one have common roots if exactly the first elements in the list Subresultants[poly₁,poly₂,x] are zero.

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.

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.

PolynomialReduce[poly,{p₁,p₂,…},{x₁,x₂,…}] yields a list of polynomials with the property that is minimal and is exactly poly.

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.

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.

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.

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

Cyclotomic polynomials arise as "elementary polynomials" in various algebraic algorithms. The cyclotomic polynomials are defined by , where runs over all positive integers less than that are relatively prime to .

Factorization is one important way of breaking down polynomials into simpler parts. Another, quite different, way is decomposition. When you factor a polynomial , you write it as a product of polynomials . Decomposing a polynomial consists of writing it as a composition of polynomials of the form .

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.

Unlike factoring, the decomposition of polynomials is not completely unique. For example, the two sets of polynomials and , related by and give the same result on composition, so that . The Wolfram Language follows the convention of absorbing any constant terms into the first polynomial in the list produced by Decompose.

The Wolfram Language can work with polynomials whose coefficients are in the finite field of integers modulo a prime .

A symmetric polynomial in variables is a polynomial that is invariant under arbitrary permutations of . Polynomials

are called elementary symmetric polynomials in variables .

The fundamental theorem of symmetric polynomials says that every symmetric polynomial in can be represented as a polynomial in elementary symmetric polynomials in .

When the ordering of variables is fixed, an arbitrary polynomial can be uniquely represented as a sum of a symmetric polynomial , called the symmetric part of , and a remainder that does not contain descending monomials. A monomial is called descending iff .

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.

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.

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

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.

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.

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

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

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

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.

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.

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.

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.

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.

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.

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

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.

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].

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

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

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.

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.