Printing from Maple

• Xwindows version
  While your worksheet window is active, pull down the File menu on the main Maple window, and select Print ...     If you're in Vincent 314, select   vinp314   from the list of printers. (Or if a printer command is shown in a dialog box, make sure that the command is    lpr -Pvinp314    If working from a remote location, follow the instructions in the remote printing instructions for the Matlab scripts.
   
• Command line version
  
   

Saving your work as a Maple worksheet

Quitting Maple

• Command line version: Type    quit;    at the Maple prompt    >    (Note the semicolon ... )
   
• Xwindows version: Pull down the File menu on the main Maple window, and select    Exit
   

Calculations with polynomials in 1 variable

• gcd    Computes the GCD (greatest common divisor) of 2 polynomials.
  For instance:
  > gcd(x^4 - 1, x^6 - 1);
                                        2
                                       x - 1
  
  (This is what the output actually looks like in the command line version.)
  For info about entering the exponents in the Xwindows version, please see the important note above.
   
  To save the answer for a future calculation:
  > g = gcd(x^4 - 1, x^6 - 1);
                                           2
                                     g := x - 1
  
  Now we'll use it in another calculation:
  gcd(g,x^5 - 1);
                                      x - 1
  
   
  So, we have calculated the GCD of the 3 polynomials x⁴ - 1,   x⁶ - 1,  and  x⁵ - 1.
   
  For further information, type    ?gcd    at the Maple prompt.
    
• rem    Computes the remainder in a polynomial division -- for polynomials in  1  variable.
   
• quo    Computes the quotient in a polynomial division -- for polynomials in  1  variable.
   
  Combined example:
   
  > f := x^10 - 1;
                                         10
                                   f := x   - 1
   
  > g := x^6 - 1;
                                          6
                                    g := x  - 1
  
  > q := quo(f,g);
  Error, (in quo) wrong number (or type) of arguments
  > q := quo(f,g,x);
                                            4
                                      q := x
  > r := rem(f,g,x);
                                              4
                                   r := -1 + x
  
  
  Now, let's try to check our work:
   
  > q*g + r;                   
                                4   6             4
                               x  (x  - 1) - 1 + x
  
  Well, that didn't quite do the trick.
  But we can force Maple to simplify the answer:
   
  > expand(q*g + r);
                                       10
                                      x   - 1
  
   

The Groebner package

• with(Groebner):    This command loads the Groebner package. It ends with a colon, not a semicolon. Maple insists that we spell "Groebner" correctly. Use this command before any of the other commands in this list.
   
• MonomialOrder    (formerly termorder )    Creates a monomial ordering (or a term order) on the polynomials in a specific number of variables. We'll often be able to skip this command, but if you do need it, type    ?termorder    at the Maple prompt   >    to get the appropriate help window. Some of the monomial orderings available in Maple are:
   
  • plex(v_1,...,v_p)    denotes lexicographic order (which the Maple help window calls "pure lexicographic order") in the variables v_1,...,v_p. (If  p = 3,  these could be a permutation of  x, y, z,  for instance.);
  • grlex(v_1,...,v_p)    denotes graded lex order in the variables v_1,...,v_p.
       Here's an example, involving the   Reduce   command, which is discussed below:
       > with(Groebner):
       > Reduce(x^3*y^3*z^3, [x - y^2, x - z^2], grlex(x,y,z));
     
                                            5
                                           x y z
     
    
  • tdeg(v_1,...,v_p)    denotes graded reverse lex order in the variables v_1,...,v_p.
    (The Maple help window calls this "total degree order", but if you read the fine print, it actually explains reverse lex order correctly.)
  • lexdeg([v_1,...,v_p],[w_1,...,w_q])    denotes an elimination order. We'll learn about these when we study Chapter 3.
  • 'matrix'(mat,[v_1,...,v_p])    denotes a matrix-defined term order.
    For instance:
       'matrix'([[1,1,1],[1,0,0],[0,1,0]],[x,y,z])
    defines graded lex order with   x > y > z.   The quotes are both single (forward) quotes. This may be needed in Math 5385 only if you're using an older version of Maple. {There are, however, other applications of matrix-defined term orders.
    Here's another version of the example given just above.
       > with(Groebner):
       > Reduce(x^3*y^3*z^3, [x - y^2, x - z^2], 'matrix'([[1,1,1],[1,0,0],[0,1,0]],[x,y,z]));
     
                                            5
                                           x y z
     
       (The command was entered as a single line in Maple, even if the line appears to be broken in your browser window.)
  • . . .
     
• Reduce    (formerly reduce)    Computes the remainder of a multivariable polynomial under division by a list of polynomials. To use this command, after loading the Groebner package, type:
      Reduce(W,WL,T)
  where   W   is a polynomial,   WL   is a list or set of polynomials, and   T   is a term order description.
  For instance, let's check the result from Example 4 on page 64 of the text, where we are to divide   f = x²y + xy² + y²   by f₁ = y² - 1   and   f₂ = xy - 1:
   
  > with(Groebner):
  > Reduce(x^2*y + x*y^2 + y^2,[y^2 - 1, x*y - 1], plex(x,y));
   
                                         2 x + 1
   
  (Note the use of the square brackets   [   ]   in forming the list.)
  For an example using graded lex order see the discussion of matrix defined term orders above.
  For more information on the Reduce command, type   ?Groebner[Reduce]   at the Maple prompt.
   
• • LeadingMonomial    (formerly leadmon)    Computes the leading monomial a polynomial relative to a given monomial ordering.
  • LeadingCoefficient    (formerly leadcoeff    Computes the leading coefficient . . .
  • LeadingTerm    (formerly leadterm)    Computes the leading term . . .
  Here are the calling sequences:
   
  LeadingMonomial(W,T)
  LeadingCoefficient(W,T)
  LeadingTerm(W,T)
  where   W   is a polynomial, and   T   is a term order description.
  
    For instance, let's check the example from the top of page 57 of the text:
  > with(Groebner):
  > LeadingMonomial(4*x*y^2*z + 4*z^2 -5*x^3 + 7*x^2*z^2, plex(x,y,z));
                                              3
                                         -5, x
   
  > LeadingMonomial(4*x*y^2*z + 4*z^2 -5*x^3 + 7*x^2*z^2, tdeg(x,y,z));
                                              2
                                        4, x y  z
   
  
• Basis    (formerly gbasis)    Computes a Groebner basis for the ideal with a given set of generators.    To use this command, after loading the Groebner package, type:
       Basis(W,WL,T)
  where   W   is a polynomial,   WL   is a list or set of polynomials, and   T   is a term order description.
    For instance, Let's check Example 1 from pp. 86-87 of the text, where we are to find a Groebner basis for the ideal in  k[x,y]  generated by  x³ - 2xy  and  x²y - 2y² + x:
   
    > with(Groebner):
    > Basis([x^3 - 2*x*y, x^2*y - 2*y^2 + x], tdeg(x,y));
                                       _{2            2}
                                   [2 y  - x, x y, x ]
   
  This isn't the same as the answer obtained on page 87 of the text, because the Groebner basis obtained there isn't minimal. If you compare with the reduced Groebner basis for the same example, obtained on page 89 of the text, the comparison should be pretty clear.
  Also note that the term order entered here --   tdeg(x,y)   -- is actually graded reverse lex order; this happens to coincide with graded lex order in the case of 2 variables, and is easier to enter than the matrix description for graded lex order.
   
• SPolynomial    (formerly spoly)   This command is computes the S-polynomial of two given polynomials, with respect to a given term order.
    Here's an example:
   
  > f := x^3 - y*z;
                                         3
                                   f := x  - y z
   
  > g:= x^2*y - z^2;
                                        2      2
                                  g := x  y - z
  
   
  > h := x*z - y^2;
                                               2
                                   h := x z - y
   
  > s := SPolynomial(f,g,plex(x,y,z));
   
                                        2        2
                                 s := -y  z + x z
   
  
  Please note: We began our command with the string   s :=   in order to store the answer for possible further use;
  the reasons will be explained shortly.
   
  Clearly, this answer is correct! But also note: If you're using this in Buchberger's algorithm, then a further step is needed. Namely, you need to reduce this relative to the given ideal basis -- or more likely with respect to whatever part of a Groebner basis has already been computed. The quickest way to do this is by means of the  Reduce  command discussed above. Alternatively, if you want to see what's actually happening, you can implement the division algorithm "by hand", using   expand  appropriately. Here's what it produces in the case of the example that we just did:
   
  > s := Reduce(s,[f,g,h],plex(x,y,z));
                                      s := 0
   
  The answer tells us that  s  is not required if we're starting with  {f, g, h}  and using Buchberger's algorithm to construct a Groebner basis.
   
   
  A variant (needed with older versions of Maple)
  There are two steps to the process:
  1. Enter a command of the form  result:=SPolynomial(poly1,poly2,termorder);    or   result:=spoly((poly1,poly2,termorder); 
     The term order can be something like plex(x,y,z) ,  tdeg(x,y,z) , etc.   The initial answer that we get looks somewhat like "doubletalk", but the next stepwill take care of that.
  2. Enter a command of the form  newresult:=expand(result); , where "result" is the answer that was saved in the previous step. Actually, it's often OK to assign the answer from this step to the same variable name as the previous result,since that one isn't very likely to be needed again.
     Doing the above example by this method, we would enter:
     > s := spoly(f,g,plex(x,y,z));
      
                               3               3        2      2         2
     s := term_order[S-poly]([x  - y z, 3, 1, x , 0], [x  y - z , 3, 1, x  y, 0], term_order)[1]
     
      
     As expected, the answer looks as if Maple has just echoed the question.
     But Maple's  expand  command will turn it into something more useful:
      
     > s:= expand(s);
                                              2        2
                                    s := -y  z + x z
      
     

Other useful commands
 

• expand   Expands an algebraic expression. (Also seems to work with trig and exponential functions, although we don't need those.) If some cancellation can occur, then this can lead to simplification. For instance:
   
     expand((x+1)^3 + (x-1)^3);    gives a polynomial answer with just two nonzero terms.
   
• solve   Solves an equation for the stated variable. If the equation involves two or more variables, then it expresses the chosen variable as a function of the other variables. For instance:
   
     solve(x^2 + y^2 -4, x);    expresses  x  as a function of  y  subject to the equation  x² + y² - 4 = 0.
   
  • Solving a system of equations   You can use the solve command to solve a system of equations, for a named unknown (or unknowns). The list of unknowns is enclosed in curly brackets  {   }  and separated by commas. If there are several unknowns, then the vector of unknowns is enclosed in square brackets  [   ].  For instance:
     
       solve({x^2 - 1, x^3 -1},x);     finds the common roots of the polynomials  x² - 1  and  x³ - 1,    while:
     
       solve({2*x + y = 5, 3*x - y = 4}, [x,y]);     solves the system  2x + y = 5,   3x - y = 4.
     
  • Application to a Groebner basis problem   Let's suppose that we're trying to solve a system of polynomial equations in 2 variables, and that the Basis command in the Groebner package has given us the following kind of Groebner basis for the corresponding ideal:
     
        G := [g₁(y), g₂(x,y), g₃(x,y)]
     
    Then the solution set of our system of equations is the set of all pairs  (x,y)  which satisfy all three equations  g₁(y) = 0,  g₂(x,y) = 0,  and  g₃(x,y) = 0.   We first find the y-values by using the command   solve(g₁(y),y);    or    solve(G[1],y);    which gives us finitely many y-values  Y₁, Y₂, ...    And then, for each of the y-values,  Y_i  both of the equations  g₂(x,Y_i) = 0,  and  g₃(x,Y_i) = 0  must be satisfied. Therefore, for each of the y-values, we find the corresponding x-values by doing the following sequence of Maple commands:
     
        p2:=eval(G[2], y=Y_i);
       p3:=eval(G[3], y=Y_i);
       solve({p2,p3},x);
     
• fsolve   Gives a floating point (i.e., decimal) solution for the stated variable. Even though Maple is able to give floating point values for complex numbers, this command seems to ignore any complex solutions and thus gives floating point values for only the real solutions: For instance:
   
     fsolve(x^3 - 3*x + 1,x);   finds all 3 real roots of  x³ - 3x + 1,   while:
   
     fsolve(x^3 + 3*x + 1,x);   finds the real root of  x³ + 3x + 1, but ignores the other two complex roots, which happen to be non-real.
   
  The   fsolve   command is useful in situations where real solutions are the main -- or only -- objects of interest. For instance, this would be the case in a Lagrange multiplier problem.
   
• eval   Evaluates an expression when a numerical value (or another expression) is substituted for one of the variables. For instance:
   
     eval(x^2 + y^2 -4, y=-1); evaluates  x² + y² -4  when -1 is substituted for  y,   and similarly:
   
     eval(x^2 + y^2 -4, {x=1.5, y=-1.25}); evaluates  x² + y² -4  when 1.5 is substituted for x and -1.25 is substituted for y.
   
• evalf   Gives a floating point {decimal or complex-decimal} value for a real or complex number. Suppose, for example that we have stored the solutions of the equation  x⁵ + x + 1:
   
     S:=solve(x^5 + x + 1);
   
  then the command   evalf(S);   will produce floating point values of all five solutions. On the other hand, if we happen to know that the third solution is the only real one and we only want its decimal value, then we use the command   evalf(S[3]);   or (for instance)   r:=evalf(S[3]);   to store the value for use in later calculations.   (Please note the square brackets for picking a particular item from a list.)
   
• diff   Calculates the derivative of a polynomial (or more general function), or in the case of a function of several variables, it calculates the partial derivative with respect to a particular variable. For instance:
   
     diff(y^2 - x^3 + 3*x - t,x);      and      diff(y^2 - x^3 + 3*x - t,y);
   
  calculate the partial derivatives of  y² - x³ + 3x - t  with respect to x and y respectively.
   
• resultant   Calculates the resultant of 2 polynomials with respect to the named variable. For instance:
   
     resultant(x*y - 1, x^2 + y^2 - 4, x);     calculates the x-resultant of  xy - 1  and  x² + y² - 4.
   
  (The answer will be a polynomial in y.)