CHAPTER 3

Polynomial Divisibility, Interpolation, and Algebraic Extensions

3-1. Commands for Handling Polynomial Expressions

This chapter is about working with polynomials and algebraic extensions. We will study the MATLAB commands that enable you to perform polynomial operations, working with roots, Galois extensions, Gröbner bases, polynomial interpolation, and operations modulo an integer. We will also present the commands that Maple implements to the same effect.

MATLAB enables agile work with polynomials, providing several commands for handling polynomial algebraic expressions. These expressions can also be treated as general algebraic expressions, but MATLAB offers particular tools for polynomial algebraic expressions, including case-specific commands. Let’s take a look at some of these commands:

• conv(a,b) returns the vector whose entries are the coefficients of the polynomial defined as the product of the polynomials whose coefficients are given by the vectors a and b.
• [q,r] = deconv(a,b) gives the vector q of coefficients of the polynomial defined as the quotient of polynomials whose coefficients are given by the vectors a and b, and the vector r of coefficients of the remainder polynomial.
• poly2sym(a) returns the polynomial whose coefficients are those specified by the vector a.
• sym2poly(poly) returns the vector of coefficients of the specified polynomial (the reverse of the previous operation).
• roots(a) gives the roots of the polynomial whose coefficients are given by the vector a.
• poly(v) gives the polynomial whose roots are the components of the vector v.
• poly(A) gives the characteristic polynomial of the matrix A.
• polyder(a) gives the vector whose coefficients are those of the first derivative of the polynomial defined by a.
• polyder(a,b) gives the vector whose coefficients are those of the first derivative of the product of polynomials defined by a and b.
• [q,d] = polyder(a,b) returns the numerator q and denominator d of the derivative of the polynomial quotient a/b (here all arguments are vectors of coefficients of polynomials).
• polyval(p,S) evaluates the polynomial p at S.
• polyvalm(p,S) evaluates the polynomial p at a matrix S.
• [r,p,k] = residue(a,b) gives the column vectors r, p and k such that: b(s)/a(s)=r1/(s-p1)+r2/(s-p2)+...+rn/(s-pn) +k(s).
• [a,b] = residue(r, p, k) performs the reverse of the previous operation.

Now let’s look at some examples of the above defined commands:

Let’s decompose the fraction (-x ^ 2 + 2 x + 1) /(x^2-1) into the sum of its simple fractions:

>> [r,p,k]=residue([-1,2,1],[1,0,-1])

r =

    1.0000
    1.0000

p =

   -1.0000
    1.0000

k =

    -1

So the decomposition will be:

(-x ^ 2 + 2 x + 1) /(x^2-1) = 1 /(-1+x) + 1 / (x + 1) - 1

The same result can be obtained in the following way:

>> pretty(sym(maple('convert((-x^2+2*x+1)/(x^2-1),parfrac,x)')))

                                      1      1
                              -1 + ----- + -----
                                   x - 1   x + 1

Next we will evaluate the polynomial x ^ 4-6 * x ^ 3-x ^ 2 + 10 * x-11 at the point x = 5 and at the unit matrix of order 4.

>> polyval([1,-6,-1,10,-11],5)

ans =

  -111

>> polyvalm([1,-6,-1,10,-11],ones(4))

ans =

   -37 - 26 - 26 - 26
   -26 - 37 - 26 - 26
   -26 – 26 - 37 - 26
   -26 - 26 – 26 - 37

Now let’s find the roots of the polynomial x ^ 3-x:

>> roots([1,0,-1,0])

ans =

         0
   -1.0000
    1.0000

Now we solve the equation -x ^ 5 + 2 * x ^ 4 + x ^ 3 + x ^ 2 = 0:

>> roots([-1,2,1,1,0,0])

ans =
        0
        0
   2.5468
  -0.2734 + 0.5638i
  -0.2734 - 0.5638i

>> pretty(poly2sym(conv(a,b)))

>> syms x y z t a b m n
>> pretty(factor(4*x^2+y^2*t^2+z^4-4*x*y*t+4*x*z^2-2*y*t*z^2))

3-2. Extracting Parts of a Polynomial

The following commands enable MATLAB to extract various parts of a polynomial (after prior use of the maple command):

• coeff(polynomial,var,n) extracts the coefficient of the polynomial in var corresponding to the monomial of power n. Before applying coeff, be sure it is suitable to do so, by first applying collect to group the terms in the variable.
• coeff(polynomial,expression) extracts the coefficient corresponding to the specified expression in the given polynomial.
• coeffs(polynomial,variable) extracts the sequence of all the coefficients of the polynomial in the given variable.
• coeffs(polynomial) extracts the sequence of all the coefficients of all the variables of the specified multivariable polynomial.
• coeffs(polynomial,{var1,...,varn}) or coeffs(polynomial,[var1,...,varn]) extracts the sequence of coefficients of the given multivariate polynomials corresponding to the specified set of variables.
• coeffs(poly,var,name) finds the sequence of polynomial coefficients corresponding to the variable var and assigns to it the specified name.
• sign(poly) returns the sign of the leading coefficient of the given multivariate polynomial. If the polynomial is positive, returns 1, and if it is negative, returns - 1.
• sign(poly,var) gives the sign of the leading coefficient of the polynomial in the variable var.
• sign(poly,[var1,...,varn]) gives the sign of the leading coefficient of the polynomial in the variables var1,..., varn.
• lcoeff(polynomial) finds the leading coefficient of the multivariate polynomial with respect to all variables appearing in the polynomial.
• lcoeff(polynomial,variable) finds the leading coefficient of the polynomial with respect to the given variable.
• lcoeff(polynomial,{var1,...,varn}) or lcoeff(polynomial,[var1,...,varn]) finds the leading coefficient of the polynomial for the given variable set.
• tcoeff(polynomial) finds the trailing coefficient of the polynomial for all its variables.
• tcoeff(polynomial,variable) finds the trailing coefficient of the polynomial output in the given variable.
• tcoeff(polynomial,{var1,...,varn}) or tcoeff(polynomial,[var1,...,varn]) finds the trailing coefficient of the polynomial for the given variables.
• ldegree(polynomial,var) determines the lowest degree of the polynomial in the given variable.
• ldegree(polynomial) determines the lowest degree of the polynomial with respect to all of its variables.
• ldegree(polynomial,{var1,...,varn}) or ldegrace(polynomial, [var1,...,varn]) determines the lowest degree of the polynomial with respect to the given set of variables.
• degree(polynomial,variable) determines the highest degree of the polynomial in the given variable.
• degree(polynomial) determines the highest degree of the polynomial with respect to all of its variables.
• degree(polynomial,{var1,...,varn}) or dgree(polynomial,[var1,...,varn])  determines the highest degree of the polynomial for the given variables.

Here are some examples:

>> pretty (sym (maple('p:= 2*x^2 + 3*y^3-5:'))))
>> pretty(sym(maple('coeff(p,x,2), coeff(p,x^2), coeff(p,x,0) ')))
                                      3
                            2, 2, 3 y - 5
>> pretty (sym (maple ('q: = 3 * a * (x + 1) ^ 2 + sin (a) * x ^ 2 * y - y ^ 2 * x + x - a:')))
>> pretty(sym(maple('coeff(q,x)')))

>> pretty(sym(maple('q := collect(q,x)')))

>> pretty(sym(maple('coeff(q,x)')))

>> pretty(sym(maple('s := 3*v^2*w^3*x^4+1')))

>> pretty(sym(maple('lcoeff(s), tcoeff(s), lcoeff(s, [v,w], t), t')))

>> maple('degree(2/x^2+5+7*x^3,x), ldegree(2/x^2+5+7*x^3,x),degree(x*sin(x),x)')

>> maple('degree(x*sin(x),sin(x)), degree((x+1)/(x+2),x),degree(x*y^3+x^2,[x,y]) ')

>> pretty(sym(maple('degree(x*y^3+x^2,{x,y}), ldegree(x*y^3+x^2,[x,y]) ')))

>> pretty(sym(maple('expr := 3*x^2*y^4 - 2*x*y^5 + x')))
>> pretty(sym(maple('indets(expr), sign(expr), sign(expr, [x,y]), sign(expr, [y,x]),       sign(expr, [y,x], a), a')))
{x, y}, 1, 1, - 1, - 1, x * y ^ 5

3-3. Factorization of Polynomials

This section presents the commands that implement various polynomial factorizations (following prior use of the maple command).

• factor(polynomial) factorizes a multivariate polynomial over the ring determined by its coefficients (integer, real, rational, and so on).
• factor(polynomial,radical) factorizes the polynomial over the algebraic extension Q(radical).
• factor(polynomial,RootOf) factorizes the polynomial over the algebraic extension Q(RootOf).
• factor(polynomial,[radical1,...,radicaln]) factorizes the polynomial over the algebraic extension Q(radical1,...,radicaln).
• factor(polynomial,[RootOf1,..,RootOfn]) factorizes the polynomial over the algebraic extension Q(RootOf1,...,RootOfn).
• factor([polynomial1,..., polynomialn] or factor({polynomial1,...,polynomialn})) factorizes the specified polynomials.
• factors(polynomial) returns a list with the multivariate polynomial factors and their multiplicities.
• factors(polynomial,radical) returns a list with the multivariate polynomial factors and their multiplicities in the algebraic extension Q(radical).
• factors(polynomial,RootOf) returns a list with the multivariate polynomial factors and their multiplicities in the algebraic extension Q(RootOf).
• factors(polynomial,[rad1,...,radn]) or factors(polynomial,{rad1,...,radn}) returns a list with the multivariate polynomial factors and their multiplicities in the algebraic extension Q(radical1,...,radicaln).
• factors(poly,[RootOf1,...,RootOfn]) or factors(poly,{RootOf1,...,RootOfn}) returns a list with the multivariate polynomial factors and their multiplicities in the algebraic extension Q(RootOf1,...,RootOfn).
• Factor(polynomial) performs the inert factorization of the polynomial.
• factor(n) returns a row vector of prime factors of the positive integer n.
• ifactor(n,option) gives the entire factorization of n according to the given option. Possible option values are sqfof (which uses the square free factorization method), pollard (which uses the Pollard method), lenstra (which uses the Lenstra method) and easy (which calculates only the easy factorizations).
• Factor(polynomial) modn performs the inert factorization of the polynomial modulo n.
• grading(Factor(polynomial,expr),option) factorizes the polynomial in the algebraic extension defined by expr according to the method given in the option (lenstra, trager, or linear).
• Factors(polynomial) returns inert form factors and their multiplicities for the given polynomial.
• Factors(polynomial) modn gives the factors and their multiplicities for polynomial modulo n.
• grading(Factors(polynomial,expression),option) gives the list of factors and multiplicities of the polynomial in the given algebraic extension defined by the expression according to the specified option (lenstra, trager, or linear).
• Afactor(polynomial) performs the inert absolute factorization of the polynomial.
• Afactors(polynomial) returns the list of factors of the inert absolute factorization of the polynomial.
• Berlekamp(poly,variable) returns the inert form of the Berlekamp factorization of varying degrees for the polynomial poly with respect to the given variable.
• Berlekamp(poly,var) modn as above, but working modulo n.
• Berlekamp(variable,radical,polynomial) returns the inert form of the Berlekamp factorization of varying degrees for the polynomial over the algebraic extension defined by radical.
• DistDeg(polynomial,var) returns the inert form of the factorization of varying degrees of the polynomial given with respect to the variable var.
• DistDeg(poly,var) mod n gives the factorization of varying degrees of the given polynomial with respect to the variable var modulo n.
• readlib(split):split(polynomial,variable) performs the complete factorization of the polynomial with respect to the variable given over the ring determined by its coefficients.
• readlib(splits):splits(polynomial,variable) returns the factors and their multiplicities for the complete factorization of the polynomial with respect to the given variable.
• sqrfree(polynomial) returns the square-free factors and their multiplicities of a polynomial with rational coefficients.
• sqrfree(polynomial,variable) returns the square-free factors and their multiplicities of a polynomial with rational coefficients in the specified variable.
• Sqrfree(polynomial) returns the inert square-free factors and their multiplicities of a polynomial with rational coefficients.
• Sqrfree(polynomial) modn returns the inert square-free factors and their multiplicities of a polynomial with rational coefficients modulo n.
• with(lattice): mipolys(n,p) gives the number of irreducible univariate monic polynomials of degree n over Z (modp).
• with(lattice): mipolys(n,p,m) gives the number of irreducible univariate monic polynomials of degree n over the Galois field defined by p^m.
• irreduc(polynomial) determines whether the multivariate polynomial is irreducible over the ring defined by its coefficients.
• irreduc(polynomial,radical) determines whether the multivariate polynomial is irreducible over the algebraic extension Q(radical).
• irreduc(polynomial,{rad1,...,radn}) or irreduc(polynomial,[rad1,...,radn]) determines whether the multivariate polynomial is irreducible over the extension Q(radical1,...,radicaln).
• Irreduc(polynomial) represents the inert form of irreduc.
• Irreduc(polynomial) mod n determines whether the multivariate polynomial is irreducible over the ring defined by its coefficients modulo n.

Here are some examples:

>> pretty(sym(maple('factor(x^3+5)')))

>> pretty(sym(maple('factor(x^3+5.0)')))

>> pretty(sym(maple('factor(a^3+a^2+a+1) ')))
                                     2
                           (a + 1) (a + 1)
>> pretty(sym(maple('factor(a^3+a^2+a+1,complex) ')))
                    (a + 1.) (a + 1.) I) (a - 1. I)
>> pretty(sym(maple('readlib(factors):factors(a^10-2*a^5+1) ')))

>> pretty(sym(maple('readlib(factors):factors(a^10-2*a^5+1,real) ')))

>> pretty(sym(maple('Factors(a^10-2*a^5+1) mod 7')))

>> pretty(sym(maple('Factor(a^10-2*a^5+1) mod 7')))

>> pretty(sym(maple('Factor(a^10-2*a^5+1)')))

>> pretty(sym(maple('evala(")')))

>> pretty(sym(maple('readlib(split): split(x^2+x+1,x)')))

>> pretty(sym(maple('readlib(splits): splits(x^2+x+1,x)')))

>> pretty(sym(maple(' f := x^3*y-x^3-x^2*y^2+x^2*y')))

>> pretty(sym(maple('sqrfree(f,x) ')))

>> pretty(sym(maple('sqrfree(f,y)')))

>> pretty(sym(maple('sqrfree(f,[x,y])')))

>> pretty(sym(maple('Sqrfree(4*x^2+4*x+1) mod 7')))

>> pretty(sym(maple('irreduc( x^3+5 )')))

>> pretty(sym(maple('irreduc( x^3+5, 5^(1/3))')))

>> pretty(sym(maple('Irreduc(2*x^2+6*x+6) mod 7,Factor(2*x^2+6*x+6) mod 7')))

>> pretty(sym(maple('Irreduc(x^4+x+1) mod 2,   Factor(x^4+x+1) mod 2')))

As we have already seen many examples and exercises relating to factorization of univariate and multivariate polynomials, we shall present only a pair of exercises.

3-4. Roots of Polynomials

The following group of MATLAB commands, all of which require the prior use of the maple command, may be used to work with roots of polynomials:

• roots(polynomial) gives univariate polynomial roots by offering a list of lists with the roots and their multiplicities. The calculation is performed over the ring defined by the coefficients.
• roots(polynomial,radical) finds the roots of the univariate polynomial over the algebraic extension Q(radical)or Q(RootOf).
• roots(polynomial,[rad1,...,radn]) or roots(polynomial,{rad1,...,radn}) finds the roots of a univariate polynomial over Q(rad1,...,radn) or Q(RootOf1,...,RoofOfn).
• Roots(poly) returns the inert form of the roots of the polynomial poly.
• Roots(poly) modn gives the roots of the polynomial poly modulo n.
• reallib(realroot): realroot(polynomial) finds intervals in which the real roots of a univariate polynomial with integer coefficients are contained.
• reallib(realroot): realroot(polynomial,n) finds intervals with a maximum width of n in which the real roots of a univariate polynomial with integer coefficients are contained.
• reallib(proot): proot(poly,n) calculates the nth root of the given polynomial with rational coefficients.
• reallib(psqrt): psqrt(poly) computes the square root of the given polynomial with rational coefficients.
• with(numtheory): cyclotomic(n,variable) returns the n-th cyclotomic polynomial in the given variable.
• readlib(sturm): sturmseq(polynomial,variable) gives a list of polynomials representing the Sturm sequence for the given polynomial.
• readlib(sturm): sturm(expression,variable,a,b) returns the number of real roots of the polynomial in the interval (a, b] using the Sturm sequence.
• readlib(lattice): minpoly(r,n) returns a polynomial of degree less than or equal to n with small integer coefficients, such that r is one of its roots.
• readlib(lattice): minpoly(r,n,e) returns a polynomial of degree less than or equal to n with small integer coefficients, such that r is one of its approximate roots with an accuracy given by e.

Here are some examples. First, we find the roots and their multiplicities over the field defined by the coefficients of the given polynomials:

>> pretty(sym(maple('roots(2*x^3+11*x^2+12*x-9)')))

>> pretty(sym(maple('roots(x^3+(-6-b-a)*x^2+(6*a+5+5*b+a*b)*x-5*a-5*a*b,x)')))

Next, we find modular integer roots and their multiplicities.

>> pretty(sym(maple('Roots(x^3-x) mod 6')))

>> pretty(sym(maple('Roots(x^3-1) mod 2')))

>> pretty(sym(maple('alias(a=RootOf(x^2+x+1))'))) ;

>> pretty(sym(maple('Roots(x^3-1,a) mod 2')))

Next we solve a third-degree polynomial with integer coefficients that has 1.2324 as an approximate root:

>> pretty(sym(maple('readlib(lattice) : minpoly(1.234,3)')))
                                       2       3
                     109. 61 _X + 5 _X - 22 _X

Next we generate a Sturm sequence for a given polynomial in order to find the number of roots of the polynomial in the specified ranges:

>> pretty(sym(maple('readlib(sturm): sturmseq(expand((x-1)*(x-2)*(x-3)),x)')))

>> pretty(sym(maple('sturm(",x,3/2,4)')))

>> pretty(sym(maple('sturm("",x,1,2)')))

Next we calculate the square and cubic roots of the given polynomials:

>> pretty(sym(maple('readlib(psqrt): psqrt(x^2+2*x*y+y^2)')))

>> pretty(sym(maple('readlib(proot): proot(x^3+3*x^2+3*x+1,3)')))

3-5. Grouping and Ordering Terms

This section presents commands that allow you to group terms into univariate and multivariate polynomials, as well as to manage them according to certain criteria. The syntax of these commands is as follows (after using the maple command):

• collect(polynomial,variable) organizes the multivariate polynomial, taking the specified variable as the main variable and gathering terms with respect to the same.
• collect(polynomial,[var1,...,varn]) or collect(polynomial,{var1,...,varn}) gathers terms in the polynomial with respect to the specified variables.
• sort(polynomial) sorts the univariate polynomial in decreasing order of powers.
• sort(polynomial) or sort(polynomial, tedeg) sorts the polynomial according to the degree of its monomial multivariate components (in descending order).
• sort(polynomial, plex) sorts the multivariate polynomial in lexicographical order.
• sort(poly,[var1,...,varn],option) or sort(poly,{var1,...,varn},option) sorts the polynomial with respect to the specified variable according to the given option (plex or tedeg).

Here are some examples:

>> pretty(sym(maple('collect(x*y+a*x*y+y*x^2-a*y*x^2+x+a*x,[x,y],recursive)')))
                            2
                 (1 - a) y x  + ((1 + a) y + 1 + a) x

>> pretty(sym(maple('collect(x*y+a*x*y+y*x^2-a*y*x^2+x+a*x,[y,x],recursive)')))

                          2
                ((1 - a) x  + (1 + a) x) y + (1 + a) x

>> pretty(sym(maple('collect(x*y+a*x*y+y*x^2-a*y*x^2+x+a*x,[x,y], distributed)')))

                                                     2
                (1 + a) x + (1 + a) x y + (1 - a) y x

>> pretty(sym(maple('collect(x^3*y+x^2*y^3+x+3,y)')))

                          3      2  3
                         x  y + x  y  + x + 3

>> pretty(sym(maple('sort(",y)')))

                          2  3    3
                         x  y  + x  y + x + 3

>> pretty(sym(maple('sort(y^3+y^2*x^2+x^3,[x,y])')))

                            2  2    3    3
                           x  y  + x  + y

>> pretty(sym(maple('sort(y^3+y^2*x^2+x^3,[x,y],plex)')))

                            3    2  2    3
                           x  + x  y  + y

>> pretty(sym(maple('sort(y^3+y^2*x^2+x^3,[x,y],tdeg)')))

                            2  2    3    3
                           x  y  + x  + y

3-6. Handling of Polynomials

This section presents a group of commands that allow you to perform certain manipulations on univariate and multivariate polynomials, such as conversions, compositions, working with their operands, and so on. The syntax of these commands (following prior use of the maple command) is presented below:

• compoly(poly,variable) determines the possible composition of the polynomial in the specified variable. The result is a list whose first element is the polynomial basis polyb, and whose second element is the polynomial equation eqnc such that sub(eqnc,polyb) = poly.
• compoly(poly,{var1,...,varn}) determines the possible composition of the polynomial in the variables var1,...,varn.
• compoly(polynomial) determines the composition of the multivariate polynomial in all its indeterminates.
• indets(polynomial) determines all the indeterminates of the given polynomial.
• readlib(student): completesquare(polynomial) transforms quadratic expressions to completed square form.
• readlib(numaprox): hornerform(polynomial,variable) converts the polynomial in the given variable into Horner form.
• convert(poly,horner,var) converts the polynomial in the variable var to Horner form.
• convert(polynomial,horner,{var1,...,varn}) converts the polynomial in the given variables to Horner form without specifying the order.
• convert(polynomial,horner,[var1,...,varn]) converts the polynomial in the given variables into Horner form in the order specified.
• convert(polynomial,horner) converts the polynomial in all its variables to Horner form.
• convert(poly,mathorner,var)converts the polynomial in the given variable into matrix Horner form.
• convert(poly,sqrfree,var) converts the polynomial in the given variable into a square-free polynomial by factoring it into its square-free factors.
• content(polynomial,variable) determines the greatest common divisor of the coefficients of the polynomial in the given variable.
• content(polynomial,[var1,...,varn]) or content(polynomial,{var1,...,varn}) determines the greatest common divisor of the coefficients of the polynomial with respect to the specified variables.
• content(polynomial) determines the greatest common divisor of the coefficients of the polynomial with respect to all of its variables.
• Content(polynomial,variable) determines the greatest common divisor of the coefficients of the polynomial in the given variable in inert form.
• Content(poly,var) mod n determines the greatest common divisor of the coefficients of the polynomial in the given variable modulo n.
• primpart(polynomial) determines a rational value such that dividing the polynomial by this value yields a primitive polynomial over the integers. If the primitive polynomial is already over the integers, this command is equivalent to content.
• with(combinat): fibonacci(n,variable) gives the nth Fibonacci polynomial in the given variable.
• with(combinat): euler(n, var) gives the nth Euler polynomial in the variable var.
• with(linalg): hermite(M,var) determines the Hermite normal  form of the matrix M of univariate polynomials in the given variable.
• with(linalg): hermite(M,var) mod n determines the Hermite normal  form of the matrix M of univariate polynomials in the given variable modulo n.
• with(linalg): smith(M,var) determines the Smith normal form of the matrix M of univariate polynomials in the given variable.
• with(linalg): smith(M,var) mod n determines the Smith normal form of the matrix M of univariate polynomials in the given variable modulo n.
• readlib(bernstein): bernstein(n,var->exprvar,variable1) finds the degree n Bernstein polynomial in variable1 that approximates the functional operator var - > exprvar in the interval [0,1].
• op(polynomial) returns a string with all the operands (monomials) of the polynomial. Any operand can be substituted using subsop.
• op(n,rationalfunction) gives the first operand (numerator) and the second operand (the inverse of the denominator) of the rational function given as a ratio of two polynomials.

Here are some examples:

>> pretty(sym(maple('compoly( x^2+2*x*y-7*x+y^2-7*y+16 )')))

                                   2
                       16 - 7 y + y , y = y + x

>> pretty(sym(maple('compoly( x^4+4*x^3*y^3+6*x^2*y^6+4*x*y^9+y^12+x+y^3-1, {x,y})')))

                           2      3    4               3
             -1 - 3 y + 6 y  - 4 y  + y , y = x + 1 + y

>> pretty(sym(maple('indets( x*y + z/x )')))

                              {z, y, x}

>> pretty(sym(maple('e:=x^(1/2)+exp(x^2)+ f(9): indets(e), indets(e,function)')))

                            2    1/2                  2
                      {exp(x ), x   , x}, {f(9), exp(x )}

>> pretty(sym(maple('convert(x^2+3*x+4,horner,x)')))

                            4 + (3 + x) x

>> pretty(sym(maple('poly := y^2*x^2 + 2*y^2*x + 2*y*x^2 + 4*y*x + x^2 + 2*x: ')))

>> pretty(sym(maple('convert(poly,horner,x)')))

                    2               2
                (2 y  + 4 y + 2 + (y  + 2 y + 1) x) x

>> pretty(sym(maple('convert(poly,mathorner,x)')))

                       2               2
                    2 y  + 4 y + 2 + (y  + 2 y + 1) x &* x

>> pretty(sym(maple('convert(poly,horner,[x,y])')))

               (2 + (4 + 2 y) y + (1 + (2 + y) y) x) x

>> pretty(sym(maple('convert(x^2+4*x+4,sqrfree,x)')))

                                     2
                               (x + 2)

>> pretty(sym(maple('content(3*x*y+6*y^2,x ), content(3*x*y+6*y^2,[x,y])')))

                                3 y, 3

>> pretty(sym(maple('icontent(3*x*y+6*y^2)')))

                                   3

>> pretty(sym(maple('op(y^2*x^2 + 2*y^2*x + 2*y*x^2 + 4*y*x + x^2 + 2*x)')))

                      2  2     2         2          2
                     y  x , 2 y  x, 2 y x , 4 y x, x , 2 x

3-7. Divisibility and Operations with Polynomials

MATLAB provides various tools for the analysis of divisibility. It can also perform a wide variety of operations on polynomials. We summarize below the commands it provides for these tasks (each of which requires the prior use of the maple command):

• discrim(polynomial,variable) returns the discriminant of the polynomial with respect to the specified variable.
• Discrim(polynomial,variable) returns the inert discriminant of the polynomial with respect to the specified variable.
• Discrim(polynomial,variable) modn returns the inert discriminant of the polynomial with respect to the specified variable modulo n.
• resultant(poly1,poly2,var) returns the resultant of the given polynomials with respect to the specified variable.
• Resultant(poly1,poly2,var) returns the inert resultant of the given polynomials with respect to the specified variable.
• Resultant(poly1,poly2,variable) mod n returns the inert resultant of the given polynomials with respect to the specified variable modulo n.
• divide(poly1,poly2,name) determines whether poly1 is divisible by poly2, and if so assigns the specified name to the ratio.
• Divide(poly1,poly2,name) determines whether poly1 is divisible by poly2, and if so assigns the specified name to the inert ratio.
• Divide(polynomial1,polynomial2,name) mod n determines whether polynomial1 is divisible by polynomial2 modulo n, and if so, assigns the specified name to the inert ratio.
• quo(poly1,poly2,var) returns the quotient polynomial of the ratio poly1/poly2 with respect to the variable var.
• quo(poly1,poly2,var,name) returns the quotient polynomial of the ratio poly1/poly2 with respect to the variable var and gives the remainder the name name.
• Quo(poly1,poly2,var) returns the inert quotient polynomial of the ratio poly1/poly2 with respect to the variable var.
• Quo(poly1,poly2,var) mod n returns the quotient polynomial of the ratio poly1/poly2 modulo n with respect to the variable var.
• rem(poly1,poly2,variable) returns the remainder of the division of two polynomials in the given variable.
• rem(poly1,poly2,var,name) returns the remainder of the division of the two polynomials and gives the quotient polynomial the name name.
• Rem(poly1,poly2,variable) returns the inert remainder of the division of two polynomials with respect to the given variable.
• rem(poly1,poly2,var) mod n returns the remainder of the division of two polynomials with respect to the given variable modulo n.
• readlib(fixdiv): fixdiv(poly,var) computes the fixed divisor of the given polynomial, i.e. the largest integer that divides poly(n) for all integers n.
• gcd(poly1,poly2) returns the greatest common divisor of two polynomials with rational coefficients.
• gcd(poly1,poly2,name1,name2) returns the greatest common divisor of two polynomials with rational coefficients and assigns name1 to poly1/gcd(poly1,poly2) and name2 to poly2/gcd(poly1,poly2).
• gcdex(poly1,poly2,var,name1,name2) returns the greatest common divisor of two polynomials in var with rational coefficients and assigns name1 to poly1/gcd(poly1,poly2) and  name2 to poly2/gcd(poly1,poly2) using the extended Euclidean algorithm.
• gcdex(poly1,poly2,poly3,var,name1,name2) returns the greatest common divisor of two polynomials in var with rational coefficients and assigns to name1 and name2 expressions such as poly3 = name1 * poly1 + name2 * poly2.
• Gcd(poly1,poly2) returns the inert form of the greatest common divisor of two polynomials with rational coefficients.
• Gcd(poly1,poly2) mod n returns the greatest common divisor modulo n of polynomials with rational coefficients.
• Gcdex(poly1,poly2,var,name1,name2) returns the inert form of the greatest common divisor of the polynomials in var with rational coefficients and assigns name1 to poly1/gcd(poly1,poly2) and  name2 to poly2/gcd(poly1,poly2) using the extended Euclidean algorithm.
• Gcdex(poly1,poly2,var,name1,name2) mod n returns the greatest common divisor modulo n of polynomials in var with rational coefficients and assigns name1 to poly1/gcd(poly1,poly2) and name2 poly2/gcd(poly1,poly2) using the extended Euclidean algorithm.
• lcm(poly1,...,polyn) returns the least common multiple of the specified polynomials.
• ispoly(expression,n,variable) determines whether the expression is a polynomial of degree n in the specified variable. n can be replaced by 'linear', 'quadratic', 'cubic' or 'quartic' for n = 1, 2, 3, 4, respectively.
• ispoly(expression,n,name0,...,namen) determines whether the expression is a polynomial of degree n in the specified variable and assigns the coefficient of degree i to namei for i = 1... n.
• norm(polynomial,n,variable) calculates the nth norm of the polynomial, whose value is Σ (abs (c))ⁿ, where c = coeffs(polynomial,variable)^1/n.
• norm(polynomial,n) calculates the nth norm of the polynomial with respect to indets(polynomial).
• norm (poly,infinity,variable) computes the infinity norm of the polynomial in the given variable (the coefficient of the polynomial with greatest absolute value).
• maxnorm(polynomial) calculates the infinity norm of the fully expanded polynomial.
• readlib(maxorder): maxorder(RootOfexpression) returns a basis for the  field extension determined by the RootOf expression.
• readlib (maxorder): maxorder({RootOfexpression1,..., RootOfexpressionn}) returns a basis for the field extension determined by the given set of RootOf expressions.
• minpoly(algebraicnum,n) computes a polynomial of degree n or less with small integer coefficients; the given algebraic number is one of its roots.
• readlib(lattice): minpoly(algebraicnum,n,expression) computes a polynomial of degree n or less with small integer coefficients such that the given algebraic number is one of its roots, up to an accuracy given by expression.
• Nextprime(polynomial,var) the inert command that finds the irreducible polynomial in the variable var, which is the next highest with respect to the given polynomial.
• Nextprime(poly,var,ext) the inert command that finds the irreducible polynomial in the variable var, over the algebraic extension defined by expr, which is the next highest with respect to the given polynomial.
• Nextprime(poly,var) mod n the inert command that finds the irreducible polynomial in the variable var, modulo n, which is the next highest with respect to the given polynomial.
• Prevprime(polynomial,var) the inert command that finds the irreducible polynomial in the variable var which is the next lowest with respect to the given polynomial.
• Prevprime(poly,var,ext) the inert command that finds the irreducible polynomial in the variable var which is the next lowest with respect to the given polynomial over the algebraic extension defined by expr.
• Prevprime(poly,var) mod n the inert command that finds the irreducible polynomial, modulo n, in the variable var which is the next lowest with respect to the given polynomial over the algebraic extension defined by expr.
• modpol(expr,poly,var,p) evaluates the rational expression expr over Q in the variable var with respect to the quotient space Z_p[var]/poly(var), where p is prime and poly is a polynomial in var over Q.
• Power(polynomial,n) returns the nth inert power of the polynomial.
• Power(polynomial,n) mod m returns the nth inert power of the polynomial modulo m.
• Powmod(poly1,n,poly2,var) gives the inert remainder Rem((poly1)n, poly2) with respect to var.
• Powmod(poly1,n,poly2,var) mod n gives the inert remainder ((poly1)n, poly2)with respect to var modulo n.
• prem(poly1,poly2,var) returns the pseudo-remainder of the quotient of polynomials poly1/poly2 with respect to the variable var.
• prem(poly1,poly2,var,namen,nameq) returns the value rem that satisfies the condition namen * poly1 = poly2 * nameq + rem.
• Prem(poly1, poly2,var) gives the inert pseudo-remainder of the quotient of polynomials poly1/poly2 with respect to the variable var.
• Prem(poly1,poly2,var) mod n gives the pseudo-remainder modulo n of the quotient of polynomials poly1/poly2 with respect to the variable var.
• sprem(poly1,poly2,var) returns the sparse pseudo-remainder of the quotient of polynomials poly1/poly2 with respect to the variable var.
• sprem(poly1,poly2,var,namen,nameq) returns the value sprem that fulfills the condition namen* poly1 = poly2 * nameq + sprem.
• Sprem(poly1,poly2,var) gives the inert sparse pseudo-remainder of the quotient of  polynomials poly1/poly2 with respect to the variable var.
• Sprem(poly1,poly2,var) mod n gives the inert sparse pseudo-remainder of the quotient, modulo n, of  polynomials poly1/poly2 with respect to the variable var.
• chrem([poly1,...,polyn],[m1,...,mn]) finds the polynomial p such that p mod mj = polyj j = 1... n.
• primpart(polynomial,variable) gives the primitive part of the polynomial in the given variable. The primitive part is the polynomial divided by the greatest common divisor of its coefficients.
• primpart(polynomial) gives the primitive part of the polynomial with respect to all of its variables.
• primpart(polynomial,{var1,...,varn}) or primpart(polynomial,[var1,...,varn]) gives the primitive part of the polynomial with respect to the specified variables.
• Primpart(polynomial,variable) gives the primitive part of the polynomial in the variable given in inert form.
• Primpart(polynomial,variable) mod n gives the primitive part of the polynomial in the given variable in inert form, modulo n.
• Primitive(polynomial) determines whether the univariate polynomial is primitive.
• Primitive(polynomial) mod n determines whether the univariate polynomial is primitive modulo n.
• Primfield({expr1,...,exprn}) gives the inert form of the algebraic extension given by the RootOf expressions expr1,...,exprn.
• Primfield({expr1,...,expren}) mod n gives the inert form, modulo n, of the algebraic extension given by the RootOf expressions expr1,...,exprn.
• Primfield(expr1,expr2) gives the primitive element of the extension defined by the first set of RootOf expressions over the extension defined by the second set of RootOf expressions.
• randpoly(variable) creates a univariate random polynomial of degree 6 in the specified variable.
• randpoly({variable1,...,variablen}) or randpoly([variable1,...,variablen]) creates a multivariate random polynomial in the variables specified.
• randpoly(variable,coeffs=rand(a..b)) creates a polynomial whose coefficients are random numbers between a and b.
• randpoly(variable,expons=rand(n)) creates a polynomial whose exponents are random numbers between 0 and n-1.
• randpoly(variable,terms=n) creates a random polynomial of n terms.
• randpoly(variable,dense) creates a dense random polynomial.
• randpoly(variable,degree=n) creates a dense random polynomial of degree n. In case of conflict, degree takes precedence over terms.
• Randpoly(n,variable) creates an inert random polynomial of degree n in the given variable.
• Randpoly(n,variable) mod m creates an inert random polynomial of degree n in the given variable, modulo m.
• Randprime(n,variable) creates an inert random irreducible and monic polynomial of degree n.
• Randprime(n,variable) mod p creates an irreducible and monic random polynomial of degree n modulo p (prime).
• Randprime(n,variable,expr) creates a random irreducible monic polynomial of degree n over the algebraic extension defined by expr.
• readlib(ratrecon): ratrecon(poly1,poly2,variable,n1,n2,name1,name2) assigns name1 and name2 such that name1/name2 = poly1 mod poly2. If the allocation can be made, the command returns true, and if it can’t, it returns false. The limits of the assigned values are such that degree(name1)≤ n1 and degree(name2) ≤ n2.
• readlib(iratrecon): iratrecon(m1,m2,n1,n2,name1,name2) assigns name1 and name2 such that name1/name2 = m1 mod m2 with abs(name1)<n1, abs(name2)<n2.
• Ratrecon(poly1,poly2,variable,n1,n2,name1,name2) assigns in inert form name1 and name2 such that name1/name2 = poly1 mod poly2.
• Ratrecon(poly1,poly2,variable,n1,n2,name1,name2) mod n assigns, modulo n, name1 and name2 such that name1/name2 = poly1 mod poly2.
• readlib(recipoly):recipoly(polynomial,variable) determines whether the polynomial is self-reciprocal.
• readlib(recipoly): recipoly(poly,var,name) assigns the specified name to the polynomial p of degree degree(poly,var)/2 that meets the condition  var ^ (degree(poly,var)/2) * p(var+1/var) = poly.
• readlib(translate): translate(polynomial,variable,number) translates the polynomial into the polynomial in the new variable given by variable+number.
• ztrans(expr,var1,var2) finds the z-transform of expr(var1) with respect to var2.
• readlib(ztrans): invztrans(expression,var1,var2) returns the inverse z-transform of the expression given in the old variable var1, with the result being an expression based on the new variable var2.
• Eval(poly,var=exp) evaluates in inert form the polynomial with the given variable replaced by expr.
• Eval(poly,var=exp) mod n evaluates the polynomial with the given variable replaced by expr modulo n.
• Eval(polynomial,{varible1=expr1,...,variablen=exprn}) evaluates in inert form the polynomial with the given variables replaced by expr1,...,exprn.
• grading(Fnc(expr1,...,exprn)) evaluates the inert command or function Fnc, whose parameters are the given expressions, over the minimal algebraic closure of the field defined by their coefficients. This applies to inert commands such as Factor, Factors, Afactor, Afactors, Norm, Content, Gcd, Gcdex, Prem, Primfield, Quo, Rem, Resultant, Sprem, Sqrfree, independence, and so on.
• readlib(evalgf):evalgf(Fnc(expr1,...,exprn),n) evaluates the inert command or function Fnc, whose parameters are the specified expressions, over the minimal algebraic extension of the finite field Z_n.

Here are some examples. First, we find the discriminant of the polynomial ax²+ bx:

>> pretty(sym(maple('p := a*x^2 + b*x + c: discrim(p,x)')))

                                     2
                             -4 c + b

Now we calculate the resultant of several polynomials:

>> pretty(sym(maple('resultant(a*x+b,c*x+d,x),   resultant((x+a)^5,(x+b)^5,x)')))

                                              25
                        -c b + d a,   (-a + b)

>> pretty(sym(maple('Resultant(2*x+1, 3*x+4, x) mod 7')))

                                  5

>> pretty(sym(maple('r := x + RootOf(_Z^2-2): s := RootOf(_Z^2-2)*x + 1:
   evala(Resultant(r,s,x))')))

                                  -1

Next we check divisibility among polynomials, and in the positive case, find the ratios:

>> pretty(sym(maple('divide(x^3-y^3, x-y, q),q')))

                                  2          2
                         true,   x  + x y + y

>> pretty(sym(maple('Divide(x^3+x^2+2*x+3,x+2,q) mod 5,q')))

                                 2
                          true, x  + 4 x + 4

Next we find quotients and remainders of division between polynomials:

>> pretty(sym(maple('rem(x^3+x+1, x^2+x+1, x, q), q')))
                             x + 2, x - 1

>> pretty(sym(maple('quo(x^3+x+1, x^2+x+1, x) ')))
                                x - 1

>> pretty(sym(maple('a := x^4+5*x^3+6: b := x^2+2*x+7: r := Rem(a,b,x,q) mod 13, q')))
>> maple r

ans =

5*x+6, x^2+3*x

3-8. Interpolation and Polynomial Fitting

MATLAB provides several commands for polynomial interpolation and fitting that we will study next:

• polyfit(x,y,n) gives the vector of coefficients of the polynomial p(x) of degree n in x which best fits the data (xi,yi) in the least-squares sense (p(xi) = yi).
• Yi = interp1(X,Y,Xi,'method') gives the vector Yi such that (Xi,Yi) is the total set of points found by interpolation between the given points (X, Y). The option method can take the values linear, spline, or cubic, depending on whether the interpolation is linear (the default option), staggered, or cubic (for xi uniformly separated). One-dimensional interpolation.
• Zi = interp2(X,Y,Z,Xi,Yi,'method') gives the vector Zi such that (Xi,Yi,Zi) is the total set of points found by interpolation between the given points (X,Y,Z). The option method can take the value linear or cubic, depending on whether the interpolation is linear (the default) or cubic (for xi uniformly separated). Two-dimensional interpolation.
• Zi = griddata(X,Y,Z,Xi,Yi) gives the vector Zi that determines the interpolation points (Xi,Yi, Zi) between the given points (X, Y, Z). A method of inverse distance is used to interpolate.
• Y = interpft(X,n) gives the vector Y containing the values of the periodic function X sampled at n equally spaced points. The original vector x is transformed to the domain of Fourier transform frequencies using the Fast Fourier transform (FFT) algorithm. It satisfies  n≥length(X).
• maple('interp([exprx1,...,exprxn+1],[expry1,...,expryn+1],var)') returns a polynomial in the specified variable of degree at least n that represents the interpolated polynomial for points from [exprx1,expry1] to [exprxn+1,expryn+1]. The coordinates of the points must all be different.
• maple('Interp([exprx1,...,exprxn+1], [expry1,...,expryn+1], variable)') returns in inert mode a polynomial in the specified variable of degree at least n that represents the interpolated polynomial for points from [exprx1, expry1] to [exprxn+1,expryn+1]. The coordinates of the points must all be different.
• maple('Interp([exprx1,...,exprxn+1], [expry1,...,expryn+1], variable) mod m') returns a polynomial modulo m in the specified variable of degree at least n that represents the interpolated polynomial for points from [exprx1, expry1] to [exprxn+1,expryn+1]. The coordinates of the points must all be different.
• maple('readlib(thiele): thiele([exprx1,...,exprxn],[expry1,...,expryn],variable)') finds an expression in the given variable that represents the entire function resulting in Thiele interpolation points (exprxi,expryi) i = 1... n.

3-9. Galois Extensions

The Maple program has commands which enable you to work with the Galois theory of finite fields and their extensions. The syntax of these commands is as follows:

• maple('galois(polynomial)') returns the Galois group of the given rational univariate irreducible polynomial of degree less than or equal to 8. It returns a list of three expressions: the first is the name of the Galois group and includes a plus sign (+) as the first character if the group is even and (-) if it is odd; the second is an integer representing the order of the group, and the third is a set of strings representing the group generators.
• maple('readlib(GF):GF(p,n,polynomial)') returns a module of procedures and constants for working in the finite Galois field with pⁿ elements defined by the field extension GF(p)[x]/polynomial. The polynomial is irreducible of degree n modulo p (prime p). Once this has been done one can make use of the operator T to implement various operations in the Galois field.
• T[input] and T[output] convert between an integer in the range 1.. pⁿ and its corresponding polynomial in the Galois field. Alternatively T[ConvertIn] and T[ConvertOut] convert an element of the Galois field to a Maple sum of products. T['+'], T['-'], T['*'], T['^'], T['inverse'] and T['/'] execute the specified operations in the Galois field. T[random] returns a random element of the Galois field. T[0] and T[1] represent the additive and multiplicative inverse, respectively. T[trace], T[norm] and T[order] compute the trace, norm and order for elements of the Galois field. T[PrimitiveElement] returns a primitive element of the Galois field. T[isPrimitiveElement] determines whether an element is primitive. T[extension] returns the polynomial extension used for the Galois field.

3-10. Gröbner Bases

Gröbner bases are used in the solution and analysis of solutions of systems of polynomial equations. The related MATLAB commands are as follows:

• maple('with(groebner)') loads into memory the MATLAB package that contains commands for working with Gröbner bases.
• maple('finduni(variable,[polynomial1,...,polynomin],[var1,...,varn])') finds the univariate polynomial in the given variable of least degree in the ideal generated by the specified set of polynomials for the given variables.
• maple('finduni(variable,[variable],[poly1,...,polym])') constructs the Gröbner basis for the given polynomials in all of their variables.
• maple('finite([polynomial1,...,polynomialm],[variable1,...,variablen])') determines whether the specified set of polynomials has a finite number of solutions for the set of specified variables. If the answer is True, one can apply the command finduni.
• maple('finite([poly1,..,polyn])') determines whether the specified set of polynomials has a finite number of solutions with regard to all its variables.
• maple('solvable([poly1,...,polym],[var1,...,varn])') determines whether the given system of polynomials is solvable (algebraically consistent) with respect to the given set of variables.
• maple('solvable([poly1,...,polym])') determines whether the given system of polynomials is solvable with respect to all of its variables.
• maple('solvable([poly1,...,polym,],[var1,...,varn],tdeg)') determines whether the given system of polynomials is solvable with respect to the set of variables using total degree.
• maple('gsolve([poly1,..., polym])') or maple('gsolve({poly1,...,polym})')) gives a reduced Gröbner basis for the given set of polynomials with respect to all of the variables. Returns a list of lists where each list is a small subsystem of polynomials identical to the original system roots. It can be applied to each reduced basis solve. Essentially, gsolve prepares the algebraic system for solution.
• maple('gsolve([poly1,...,polym],{polyr1,...,polyrn})') prevents the roots of the second set of polynomials from being considered in the computation of Gröbner bases.
• maple('gsolve([poly1,...,polyn],[var1,...,varn],{polyr1,...,polyrn})') specifies that the presentation of the specified variables will be used in the computation of Gröbner bases.
• maple('gbasis([poly1,...,polym],[var1,...,varn])') returns a minimal reduced Gröbner basis for the specified polynomials in the given variables. The result is a list of polynomials.
• maple('gbasis([poly1,...,polym],[var1,...,varn],plex)') gives a Gröbner basis in which the polynomial terms are sorted lexicographically.
• maple('gbasis([poly1,...,polym],[var1,...,varn],tdeg)') gives a Gröbner basis in which the polynomial terms are arranged by total degree.
• maple('normalf(polynomial,[poly1,...,polym],[var1,...,varn])') gives the full reduced form of the given polynomial with respect to the Gröbner basis represented by the given polynomials in the specified variables. You can use the plex option to sort the results into lexicographic order.
• maple('leadmon(polynomial,[var1,...,varn])') returns the leading monomial of the given polynomial with respect to the specified variables. It produces a list of two elements. The first element is the coefficient of the monomial and the second is the rest of the monomial. You can use the Plex option to sort the results into lexicographic order.
• maple('spoly(poly1,poly2,[var1,...,varn])') returns the s-polynomial of poly1 and poly2 with respect to the given variables.

3-11. The mod Operator: Modular Operations with Polynomials

The operator mod evaluates an expression modulo m for a non-zero natural number m. MATLAB uses two representations for an integer modulo m. The positive  mod m representation is an integer between 0 and m-1. The symmetric mod m representation is an integer between -floor((abs(m)-1)/2) and floor(abs(m)/2). The first operand of the mod operator generally tends to be an expression that will be evaluated by MATLAB over the ring of integers modulo n. For polynomials, MATLAB reduces the coefficients modulo m. When the first operand is a power, MATLAB uses the inert representation of the power, for example, i & ^ j mod m is calculated as i^j mod m. Among the commands that use the mod operator with polynomials are, in addition to those we’ve already seen, the following (all require the prior use of the maple command):

• 'mod'(expr,m) is equivalent to expr mod m (expr can be a polynomial).
• modp1(Fnc(expr1,...,exprn),m) (m is a positive integer) uses efficient arithmetic methods to calculate the inert command or function Fnc modulo m. The n given expressions are univariate polynomials expressed in modp1 format. To express any standard polynomial in the form modp1 modulo m it is necessary to use the command modp1(convertIn). Here  modp1 refers to univariate polynomials with the operator mod in its positive representation.
• modp1(Add(polyp11,...,polyp1n),m) adds polynomials in the form modp1.
• modp1(Coeff(polyp1,n),m) returns the coefficient of  xⁿ of the polynomial,  in the form modp1.
• modp1(Degree(polyp1),m) returns the degree of the polynomial, in the form modp1.
• modp1(Det(M),m) returns the determinant of the matrix M whose elements are polynomials, in the form modp1.
• modp1(Gausselimin(M),m) applies Gauss elimination to the matrix M whose elements are polynomials, in the form modp1.
• modp1(Gaussjord(M),m) returns the reduced Gauss-Jordan form for the matrix M whose elements are polynomials, in the form modp1.
• modp1(Lcoeff(polyp1),m) returns the leading coefficient of the polynomial polyp1 in the form modp1.
• modp1(Lcm(polyp1,polyp2),m) finds the least common multiple of the polynomials polyp1 and polyp2, in the form modp1.
• modp1(Subtract(polyp1,polyp2),m) finds the difference polyp1-polyp2 of the given polynomials , in the form modp1.
• modp1(Multiply(polyp1,poly2),m) finds the product polyp1*polyp2 of the polynomials in the form modp1.
• modp1(Ldegree(polyp1),m) returns the smallest degree of the polynomial polyp1 in modp1 form.
• modp1(Power(polyp1,n),m) returns the n th power of the polynomial polyp1 in the form modp1. With modp1 you can also use inert commands such as Tcoeff, Chrem, Diff, divided, Embedded, Eval, Factors, Gcd, Gcdex, Interp, Irreduc, Powmod, Prem, Quo, Rem, spot, Root, Smith, Sgrfr, Vnormal, and so on.
• modp1(ConvertIn(polynomial,variable),m) converts the given univariate polynomial with integer coefficients in the given variable to the format modp1 modulo m. This operation takes precedence over any of the operating commands modp1. Any polynomial that is an argument of any operational function modp1 should be previously transformed with modp1(ConvertIn).
• modp1(ConvertOut(polynomial1,variable),m) converts the specified polynomial in the form modp1 to standard format.
• modp1(ConvertOut(poly1),m) gives the list of coefficients of the polynomial converted to standard format.
• modp1(Constant(expr),m) represents the constant expression as a polynomial modulo m in the format modp1.
• modp1(One(),m) represents the polynomial 1 modulo m in modp1 format.
• modp1(Zero(),m) represents the polynomial 0 modulo m in modp1 format.
• modp1(Randpoly(n),m) creates a random polynomial modulo m of degree n in modp1 format.
• modp2(Fnc(expr1,..,exprn),m) (positive whole m) uses efficient arithmetic methods to calculate the inert command or function Fnc modulo m. The n expressions specified as arguments of the command Fnc are bivariate polynomials expressed in modp2 format modulo m. The term modp2 indicates bivariate polynomials with the operator mod in its finite representation. To express any standard polynomial in the form modp2 it is necessary to use the command modp2(ConvertIn). Such a transformation must be done prior to the application of Fnc to any polynomial.
• modp2(Add(polyp21,...,polyp2n),m) adds polynomials in the form modp2.
• modp2(Degree(polyp2,i),m) returns the degree of the specified bivariate polynomial modulo m in format modp2 and with reference to its ith variable.
• modp2(Diff(polyp2,i),m) returns the derivative of the bivariate polynomial modulo m specified in the format modp2 and with reference to its i th variable.
• modp2(FielMultiply(polyp2,k),m) returns the product of the scalar k and the specified polynomial in the format modp2.
• modp2(Lcm(polyp21,polyp22),m) finds the least common multiple of polynomials in the form modp2.
• modp2(Multiply(polyp21,polyp22),m) returns the product of the polynomials in the form modp2.
• modp2(Power(polyp2,n),m) returns the nth power of the polynomial in the form modp2.
• modp2(TotalDegree(polyp2),m) returns the total degree of the polynomial modulo m in the format modp2 in both variables. The inert commands can also be used with modp2, including Coeff, Content, divided, Eval, Factors, Gcd, Prim, Primport, RingMultiply, Sqrfree, Unit, Var-Swap, and so on.
• modp2(ConvertIn(polynomial,var1,var2),m) converts the given polynomial with integer coefficients in the variables var1, var2 into standard polynomial format modp2 modulo m. This conversion must be applied to any polynomial that will be an argument of any modp2command.
• modp2(ConvertOut(polyp2,var1,var2),m) converts the polynomial modulo m in format modp2 to its standard format.
• modp2(ConvertOut(polyp2),m) returns the list of coefficients of the polynomial into its standard format.
• modp2(Constant(expr),m) represents the constant expression as a bivariate polynomial modp2 modulo m.
• modp2(One(),m) gives 1 modulo the polynomial m in format modp2.
• modp2(Zero(),m) gives  the  polynomial  0  modulo  m  in  modp2 format.
• modp2(Rootpoly(r,s),m) creates a random bivariate polynomial in the format modp2 modulo m of degree r and s for its respective variables.

Here are some examples:

>> pretty(sym(maple('p:= 11: a:= x^4-1')))
>> pretty(sym(maple('a := modp1(ConvertIn(a,x),p)')))
>> pretty(sym(maple('a')))

>> pretty(sym(maple('modp1(ConvertOut(a,x),p),modp1(ConvertOut(a),p)')))

                        4
                      x  + 10, [10, 0, 0, 0, 1]

>> pretty(sym(maple('b:=modp1(Randpoly(3),p):c:=modp1(Rem(a,b),p):
   d:=modp1(Roots(a),p)')))
>> pretty(sym(maple('b,c,d')))

 7000400010008, 400050001, [[1, 1], [10, 1]]

>> pretty(sym(maple('modp1(Factors(a),p)')))

  [1, [[1000000001, 1], [1000000010, 1], [1000000000000000001, 1]]]

>> pretty(sym(maple('a:=x^4*y^2-1:b := modp2(ConvertIn(a,x,y),p)')))
>> pretty(sym(maple('b')))