@@ -1,1629 +1,1629 @@
-\section{Declarations}
-
-\begin{Command}{ALGEBRAIC}
-\index{evaluation}
-The \name{algebraic} command changes REDUCE's mode of operation to
-algebraic.  When \name{algebraic} is used as an operator (with an
-argument inside parentheses) that argument is evaluated in algebraic
-mode, but REDUCE's mode is not changed.
-
-\begin{Examples}
-algebraic; \\
-symbolic;                  &      NIL \\
-algebraic(x**2);           &      X^{2} \\
-x**2;                      &      \begin{multilineoutput}{6cm}
-  ***** The symbol X has no value.
-\end{multilineoutput}
-\end{Examples}
-
-\begin{Comments}
-REDUCE's symbolic mode does not know about most algebraic commands.
-Error messages in this mode may also depend on the particular Lisp
-used for the REDUCE implementation.
-% You can tell that you are in algebraic mode if the numbered prompt
-% contains a colon rather than an asterisk.
-\end{Comments}
-\end{Command}
-
-
-\begin{Declaration}{ANTISYMMETRIC}
-When an operator is declared \name{antisymmetric}, its arguments are
-reordered to conform to the internal ordering of the system.  If an odd
-number of argument interchanges are required to do this ordering,
-the sign of the expression is changed.
-
-\begin{Syntax}
-\name{antisymmetric} \meta{identifier}\{\name{,}\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} is an identifier that has been declared as an operator.
-
-\begin{Examples}
-operator m,n; \\
-antisymmetric m,n; \\
-m(x,n(1,2));               &         - M( - N(2,1),X) \\
-operator p; \\
-antisymmetric p; \\
-p(a,b,c);                  &           P(A,B,C) \\
-p(b,a,c);                  &         - P(A,B,C)
-\end{Examples}
-
-\begin{Comments}
-If \meta{identifier} has not been declared an operator, the flag
-\name{antisymmetric} is still attached to it.  When \meta{identifier} is
-subsequently used as an operator, the message \name{Declare} \meta{identifier}
- \name{operator? (Y or N)} is printed.  If the user replies \name{y}, the
-antisymmetric property of the operator is used.
-
-Note in the first example, identifiers are customarily ordered
-alphabetically, while numbers are ordered from largest to smallest.
-The operators may have any desired number of arguments (less than 128).
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{ARRAY}
-The \name{array} declaration declares a list of identifiers to be of type
-\name{array}, and sets all their entries to 0.
-\begin{Syntax}
-\name{array}
-\meta{identifier}\(\meta{dimensions}\)
-              \{\name{,}\meta{identifier}\(\meta{dimensions}\)\}\optional
-\end{Syntax}
-
-\meta{identifier} may be any valid REDUCE identifier.  If the identifier
-was already an array, a warning message is given that the array has been
-redefined.  \meta{dimensions} are of form
- \meta{integer}\{,\meta{integer}\}\optional.
-
-\begin{Examples}
-array a(2,5),b(3,3,3),c(200);  \\
-array a(3,5);              &     *** ARRAY A REDEFINED \\
-a(3,4);                    &     0 \\
-length a;                  &     {4,6}
-\end{Examples}
-
-\begin{Comments}
-Arrays are always global, even if defined inside a procedure or block
-statement.  Their status as an array remains until the variable is
-reset by \nameref{clear}.  Arrays may not have the same names as operators,
-procedures or scalar variables.
-
-Array elements are referred to by the usual notation: \name{a(i,j)}
-returns the jth element of the ith row.  The \nameref{assign}ment operator
-\name{:=} is used to put values into the array.  Arrays as a whole
-cannot be subject to assignment by \nameref{let} or \name{:=} ; the
-assignment operator \name{:=} is only valid for individual elements.
-
-When you use \nameref{let} on an array element, the contents of that
-element become the argument to \name{let}.  Thus, if the element
-contains a number or some other expression that is not a valid argument
-for this command, you get an error message.  If the element contains an
-identifier, the identifier has the substitution rule attached to it
-globally.  The same behavior occurs with \nameref{clear}.  If the array
-element contains an identifier or simple\_expression, it is cleared.  Do
-\meta{not} use \name{clear} to try to set an array element to 0.  Because
-of the side effects of either \name{let} or \name{clear}, it is unwise
-to apply either of these to array elements.
-
-Array indices always start with 0, so that the declaration \name{array a(5)}
-sets aside 6 units of space, indexed from 0 through 5, and initializes
-them to 0.  The \nameref{length} command returns a list of the true number of
-elements in each dimension.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{CLEAR}
-The \name{clear} command is used to remove assignments or remove substitution
-rules from any expression.
-
-\begin{Syntax}
-\name{clear} \meta{identifier}\{,\meta{identifier}\}\repeated \ or \\
-\meta{let-type statement} \name{clear} \meta{identifier}
-\end{Syntax}
-
-\meta{identifier} can be any \name{scalar}, \nameref{matrix}, 
-or \nameref{array} variable or
-\nameref{procedure} name.  \meta{let-type statement} can be any general 
-or specific \nameref{let} statement (see below in Comments).
-
-\begin{Examples}
-array a(2,3); \\
-a(2,2) := 15;                &             A(2,2) := 15 \\
-clear a;                     \\
-a(2,2);                      &             Declare A operator? (Y or N) \\
-let x = y + z; \\
-sin(x);                      &             SIN(Y + Z) \\
-clear x; \\
-sin(x);                      &             SIN(X) \\
-let x**5 = 7; \\
-clear x; \\
-x**5;                        &             7 \\
-clear x**5; \\
-x**5;                        &             X^{5}
-\end{Examples}
-\begin{Comments}
-
-Although it is not a good idea, operators of the same name but taking
-different numbers of arguments can be defined.  Using a \name{clear} statement
-on any of these operators clears every one with the same name, even if the
-number of arguments is different.
-
-The \name{clear} command is used to ``forget" matrices, arrays, operators
-and scalar variables, returning their identifiers to the pristine state
-to be used for other purposes.  When \name{clear} is applied to array
-elements, the contents of the array element becomes the argument for
-\name{clear}.  Thus, you get an error message if the element contains a
-number, or some other expression that is not a legal argument to
-\name{clear}.  If the element contains an identifier, it is cleared.
-When clear is applied to matrix elements, an error message is returned
-if the element evaluates to a number, otherwise there is no effect.  Do
-{\em not} try to use \name{clear} to set array or matrix elements to 0.
-You will not be pleased with the results.
-
-If you are trying to clear power or product substitution rules made with
-either \nameref{let} or \nameref{forall}\ldots\name{let}, you must
-reproduce the rule, exactly as you typed it with the same arguments, up to
-but not including the equal sign, using the word \name{clear} instead of
-the word \name{let}.  This is shown in the last example.  Any other type of
-\name{let} or \name{forall}\ldots\name{let} substitution can be cleared
-with just the variable or operator name.  \nameref{match} behaves the same as
-\nameref{let} in this situation.  There is a more complicated example under
-\nameref{forall}.
-
-\end{Comments}
-\end{Command}
-
-
-\begin{Command}{CLEARRULES}
-\index{rule}
-\begin{Syntax}
-\name{clearrules} \meta{list}\{,\meta{list}\}\repeated
-\end{Syntax}
-
-The operator \name{clearrules} is used to remove previously defined
-\nameref{rule} lists from the system.  \meta{list} can be an explicit rule
-list, or evaluate to a rule list.
-
-\begin{Examples}
-trig1 := {cos(~x)*cos(~y) => (cos(x+y)+cos(x-y))/2,
-	  cos(~x)*sin(~y) => (sin(x+y)-sin(x-y))/2,
-	  sin(~x)*sin(~y) => (cos(x-y)-cos(x+y))/2,
-	  cos(~x)^2       => (1+cos(2*x))/2,
-	  sin(~x)^2       => (1-cos(2*x))/2}$ \\
-let trig1;
-cos(a)*cos(b); &
-\rfrac{COS(A - B) + COS(A + B)}{2} \\
-clearrules trig1;
-cos(a)*cos(b); &  COS(A)*COS(B)
-\end{Examples}
-
-\end{Command}
-
-
-\begin{Command}{DEFINE}
-The command \name{define} allows you to supply a new name for an identifier
-or replace it by any valid REDUCE expression.
-
-\begin{Syntax}
-\name{define} \meta{identifier}\name{=}\meta{substitution}
-      \{\name{,}\meta{identifier}\name{=}\meta{substitution}\}\optional
-\end{Syntax}
-
-
-\meta{identifier} is any valid REDUCE identifier, \meta{substitution} can be a
-number, an identifier, an operator, a reserved word, or an expression.
-
-\begin{Examples}
-
-define is= :=, xx=y+z; \\
-
-a is 10;                     &            A := 10 \\
-
-xx**2;                       &            Y^{2}  + 2*Y*Z + Z^{2} \\
-
-xx := 10;                    &            Y + Z := 10
-\end{Examples}
-
-\begin{Comments}
-The renaming is done at the input level, and therefore takes precedence
-over any other replacement or substitution declared for the same identifier.
-It remains in effect until the end of the REDUCE session.  Be careful with
-it, since you cannot easily undo it without ending the session.
-\end{Comments}
-\end{Command}
-
-
-\begin{Declaration}{DEPEND}
-\index{dependency}
-\name{depend} declares that its first argument depends on the rest of its
-arguments.
-
-\begin{Syntax}
-\name{depend} \meta{kernel}\{\name{,}\meta{kernel}\}\repeated
-\end{Syntax}
-
-\meta{kernel} must be a legal variable name or a prefix operator (see
-\nameref{kernel}).
-
-\begin{Examples}
-
-depend y,x; \\
-
-df(y**2,x);                 &            2*DF(Y,X)*Y \\
-
-depend z,cos(x),y; \\
-
-df(sin(z),cos(x));          &            COS(Z)*DF(Z,COS(X)) \\
-
-df(z**2,x);                 &            2*DF(Z,X)*Z \\
-
-nodepend z,y; \\
-
-df(z**2,x);                 &            2*DF(Z,X)*Z \\
-
-cc := df(y**2,x);           &            CC := 2*DF(Y,X)*Y \\
-
-y := tan x;                 &            Y := TAN(X); \\
-
-cc;                         &            2*TAN(X)*(TAN(X)^{2}  + 1)
-\end{Examples}
-\begin{Comments}
-Dependencies can be removed by using the declaration \nameref{nodepend}.
-The differentiation operator uses this information, as shown in the
-examples above.  Linear operators also use knowledge of dependencies
-(see \nameref{linear}).  Note that dependencies can be nested:  Having
-declared \IFTEX{$y$}{y} to depend on \IFTEX{$x$}{x}, and \IFTEX{$z$}{z}
-to depend on \IFTEX{$y$}{y}, we
-see that the chain rule was applied to the derivative of a function of
-\IFTEX{$z$}{z} with respect to \IFTEX{$x$}{x}.   If the explicit function of the
-dependency is later entered into the system, terms with \name{DF(Y,X)},
-for example, are expanded when they are displayed again, as shown in the
-last example.  The boolean operator \nameref{freeof} allows you to
-check the dependency between two algebraic objects.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{EVEN}
-\begin{Syntax}
-\name{even} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-This declaration is used to declare an operator {\em even} in its first
-argument.  Expressions involving an operator declared in this manner are
-transformed if the first argument contains a minus sign.  Any other
-arguments are not affected.
-\begin{Examples}
-	even f; \\
-	f(-a)    &    F(A) \\
-	f(-a,-b) &    F(A,-B)
-\end{Examples}
-\end{Declaration}
-
-
-\begin{Declaration}{FACTOR}
-\index{output}
-When a kernel is declared by \name{factor}, all terms involving fixed
-powers of that kernel are printed as a product of the fixed powers and
-the rest of the terms. 
-\begin{Syntax}
-\name{factor} \meta{kernel} \{\name{,}\meta{kernel}\}\optional
-\end{Syntax}
-
-\meta{kernel} must be a \nameref{kernel} or a \nameref{list} of
-\name{kernel}s.
-
-\begin{Examples}
-a := (x + y + z)**2;         &
-     A := X^{2} + 2*X*Y + 2*X*Z + Y^{2} + 2*Y*Z + Z^{2} \\
-factor y; \\
-a;                           &
-     Y^{2} + 2*Y*(X + Z) + X^{2} + 2*X*Z + Z^{2} \\
-factor sin(x); \\
-c := df(sin(x)**4*x**2*z,x); &
-     C := 2*SIN(X)^{4}*X*Z + 4*SIN(X)^{3}*COS(X)*X^{2}*Z \\
-remfac sin(x); \\
-c;                           &
-     2*SIN(X)^{3}*X*Z*(2*COS(X)*X + SIN(X))
-\end{Examples}
-
-\begin{Comments}
-Use the \name{factor} declaration to display variables of interest so that
-you can see their powers more clearly, as shown in the example.  Remove
-this special treatment with the declaration \nameref{remfac}.  The
-\name{factor} declaration is only effective when the switch \nameref{pri} 
-is on.
-
-The \name{factor} declaration is not a factoring command; to factor
-expressions use the \nameref{factor} switch or the \nameref{factorize} command.
-
-The \name{factor} declaration is helpful in such cases as Taylor polynomials
-where the explicit powers of the variable are expected at the top level, not
-buried in various factored forms.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{FORALL}
-\index{substitution}
-The \name{forall} or (preferably) \name{for all} command is used as a
-modifier for \nameref{let} statements, indicating the universal applicability
-of the rule, with possible qualifications.
-\begin{Syntax}
-\name{for all} \meta{identifier}\{,\meta{identifier}\}\optional\ \name{let}
-\meta{let statement}
-
-{\em or}
-
-\name{for all} \meta{identifier}\{,\meta{identifier}\}\optional
-\ \name{such that} \meta{condition} \name{let} \meta{let statement}
-\end{Syntax}
-
-
-\meta{identifier} may be any valid REDUCE identifier, \meta{let statement}
-can be an operator, a product or power, or a group or block statement.
-\meta{condition} must be a logical or comparison operator returning true or
-false.
-
-\begin{Examples}
-for all x let f(x) = sin(x**2);
-			     &     Declare F operator ? (Y or N) \\
-y \\
-f(a);                        &     SIN(A^{2}) \\
-operator pos; \\
-for all x such that x>=0 let pos(x) = sqrt(x + 1); \\
-pos(5);                      &     SQRT(6) \\
-pos(-5);                     &     POS(-5) \\
-clear pos; \\
-pos(5);                      &     Declare POS operator ? (Y or N) \\
-for all a such that numberp a let x**a = 1; \\
-x**4;                        &     1 \\
-clear x**a;                  &     *** X**A not found \\
-for all a  clear x**a; \\
-x**4;                        &     1 \\
-for all a such that numberp a clear x**a; \\
-x**4;                        &     X^{4}
-\end{Examples}
-
-\begin{Comments}
-Substitution rules defined by \name{for all} or \name{for
-all}\ldots\name{such that} commands that involve products or powers are
-cleared by reproducing the command, with exactly the same variable names
-used, up to but not including the equal sign, with \nameref{clear}
-replacing \name{let}, as shown in the last example.  Other substitutions
-involving variables or operator names can be cleared with just the name,
-like any other variable.
-
-The \nameref{match} command can also be used in product and power substitutions.
-The syntax of its use and clearing is exactly like \name{let}.  A \name{match}
-substitution only replaces the term if it is exactly like the pattern, for
-example \name{match x**5 = 1} replaces only terms of \name{x**5} and not
-terms of higher powers.
-
-It is easier to declare your potential operator before defining the 
-\name{for all} rule, since the system will ask you to declare it an
-operator anyway.  Names of declared arrays or matrices or scalar
-variables are invalid as operator names, to avoid ambiguity.  Either
-\name{for all}\ldots\name{let} statements or procedures are often used to define
-operators.  One difference is that procedures implement ``call by value"
-meaning that assignments involving their formal parameters do not change
-the calling variables that replace them.  If you use assignment statements
-on the formal parameters in a \name{for all}\ldots\name{let} statement, the
-effects are seen in the calling variables.  Be careful not to redefine a
-system operator unless you mean it: the statement \name{for all x let
-sin(x)=0;} has exactly that effect, and the usual definition for sin(x) has
-been lost for the remainder of the REDUCE session. \end{Comments}
-\end{Command}
-
-\begin{Declaration}{INFIX}
-\index{operator}
-\name{infix} declares identifiers to be infix operators.
-\begin{Syntax}
-\name{infix} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} can be any valid REDUCE identifier, which has not already
-been declared an operator, array or matrix, and is not reserved by the
-system.
-
-\begin{Examples}
-infix aa; \\
-for all x,y let aa(x,y) = cos(x)*cos(y) - sin(x)*sin(y); \\
-x aa y;                      &       COS(X)*COS(Y) - SIN(X)*SIN(Y) \\
-pi/3 aa pi/2;                &        - \rfrac{SQRT(3)}{2} \\
-aa(pi,pi);                   &           1
-\end{Examples}
-
-\begin{Comments}
-A \nameref{let} statement must be used to attach functionality to 
-the operator. Note that the operator is defined in prefix form in 
-the \name{let} statement.
-After its definition, the operator may be used in either prefix or infix
-mode.  The above operator \IFTEX{$aa$}{aa} finds the cosine of the sum 
-of two angles by the formula 
-\begin{TEX}
-\begin{displaymath}
-\cos(x+y) = \cos x \cos y  - \sin x \sin y.
-\end{displaymath}
-\end{TEX}
-\begin{INFO}
-cos(x+y) = cos(x)*cos(y) - sin(x)*sin(y).
-\end{INFO}
-Precedence may be attached to infix operators with the
-\nameref{precedence} declaration.
-
-User-defined infix operators may be used in prefix form.  If they are used
-in infix form, a space must be left on each side of the operator to avoid
-ambiguity.  Infix operators are always binary.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{INTEGER}
-The \name{integer} declaration must be made immediately after a
-\nameref{begin} (or other variable declaration such as \nameref{real}
-and \nameref{scalar}) and declares local integer variables.  They are
-initialized to 0.
-\begin{Syntax}
-\name{integer} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} may be any valid REDUCE identifier, except
-\name{t} or \name{nil}.
-
-\begin{Comments}
-Integer variables remain local, and do not share values with variables of
-the same name outside the \nameref{begin}\ldots\name{end} block.  When the
-block is finished, the variables are removed.  You may use the words
-\nameref{real} or \nameref{scalar} in the place of \name{integer}.
-\name{integer} does not indicate typechecking by the
-current REDUCE; it is only for your own information.  Declaration
-statements must immediately follow the \name{begin}, without a semicolon
-between \name{begin} and the first variable declaration.
-
-Any variables used inside \name{begin}\ldots\name{end} blocks that were not
-declared \name{scalar}, \name{real} or \name{integer} are global, and any
-change made to them inside the block affects their global value.  Any
-\ref{array} or \ref{matrix} declared inside a block is always global.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{KORDER}
-\index{kernel order}\index{variable order}\index{order}
-The \name{korder} declaration changes the internal canonical ordering of
-kernels.
-\begin{Syntax}
-\name{korder} \meta{kernel}\{\name{,}\meta{kernel}\}\optional
-\end{Syntax}
-
-\meta{kernel} must be a REDUCE \nameref{kernel} or a \nameref{list} of
-\name{kernel}s.
-
-\begin{Comments}
-The declaration \name{korder} changes the internal ordering, but not the print
-ordering, so the effects cannot be seen on output.  However, in some 
-calculations, the order of the variables can have significant effects on the 
-time and space demands of a calculation.  If you are doing a demanding 
-calculation with several kernels, you can experiment with changing the 
-canonical ordering to improve behavior.
-
-The first kernel in the argument list is given the highest priority, the
-second gets the next highest, and so on.  Kernels not named in a
-\name{korder} ordering otherwise.  A new \name{korder} declaration replaces 
-the previous one.  To return to canonical ordering, use the command 
-\name{korder nil}.
-
-To change the print ordering, use the declaration \nameref{order}.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{LET}
-\index{substitution}\index{rule}
-The \name{let} command defines general or specific substitution rules.
-\begin{Syntax}
-\name{let} \meta{identifier} \name{=} \meta{expression}\{,\meta{identifier}
-\name{=} \meta{expression}\}\optional
-\end{Syntax}
-
-
-\meta{identifier} can be any valid REDUCE identifier except an array, and in
-some cases can be an expression; \meta{expression} can be any valid REDUCE
-expression.   
-
-\begin{Examples}
-let a = sin(x); \\
-b := a;                      &          B := SIN X; \\
-let c = a;  \\
-exp(a);                      &          E^{SIN(X)} \\
-a := x**2;                   &          A := X^{2} \\
-exp(a);                      &          E^{X^{2}} \\
-exp(b);                      &          E^{SIN(X)} \\
-exp(c);                      &          E^{X^{2}} \\
-let m + n = p; \\
-(m + n)**5;                  &          P^{5} \\
-%%%let z**6 = 0; \\
-%%%z**3*(z + 1)**4;             &          Z^{3}*(6*Z^{2}  + 4*Z + 1) \\
-operator h; \\
-let h(u,v) = u - v; \\
-h(u,v);                      &          U - V \\
-h(x,y);                      &          H(X,Y) \\
-array q(10); \\
-let q(1) = 15;               &   ***** Substitution for 0 not allowed
-\end{Examples}
-
-The \name{let} command is also used to activate a \name{rule sets}.
-\begin{Syntax}
-\name{let} \meta{list}\{,\meta{list}\}\repeated
-\end{Syntax}
-
-\meta{list} can be an explicit \nameref{rule} \name{list}, or evaluate 
-to a rule list.
-
-\begin{Examples}
-trig1 := {cos(~x)*cos(~y) => (cos(x+y)+cos(x-y))/2,
-	  cos(~x)*sin(~y) => (sin(x+y)-sin(x-y))/2,
-	  sin(~x)*sin(~y) => (cos(x-y)-cos(x+y))/2,
-	  cos(~x)^2       => (1+cos(2*x))/2,
-	  sin(~x)^2       => (1-cos(2*x))/2}$ \\
-let trig1;
-cos(a)*cos(b); &
-\rfrac{COS(A - B) + COS(A + B)}{2}
-\end{Examples}
-
-\begin{Comments}
-A \name{let} command returns no value, though the substitution rule is
-entered.  Assignment rules made by \nameref{assign} and \name{let} 
-rules are at the
-same level, and cancel each other.  There is a difference in their
-operation, however, as shown in the first example:  a \name{let} assignment
-tracks the changes in what it is assigned to, while a \name{:=} assignment
-is fixed at the value it originally had.  
-
-The use of expressions as left-hand sides of \name{let} statements is a 
-little complicated.  The rules of operation are:
-\begin{itemize}
-
-\item[(i)]
-Expressions of the form A*B = C do not change A, B or C, but set A*B to C.
-
-\item[(ii)]
-Expressions of the form A+B = C substitute C - B for A, but do not change
-B or C.
-
-\item[(iii)]
-Expressions of the form A-B = C substitute B + C for A, but do not change
-B or C.
-
-\item[(iv)]
-Expressions of the form A/B = C substitute B*C for A, but do not change B or
-C.
-
-\item[(v)]
-Expressions of the form A**N = C substitute C for A**N in every expression of
-a power of A to N or greater.  An asymptotic command such as A**N = 0 sets
-all terms involving A to powers greater than or equal to N to 0.  Finite
-fields may be generated by requiring modular arithmetic (the \nameref{modular}
-switch) and defining the primitive polynomial via a \name{let} statement.
-
-\end{itemize}
-\name{let} substitutions involving expressions are cleared by using
-the \nameref{clear} command with exactly the same expression.
-
-Note when a simple \name{let} statement is used to assign functionality to an
-operator, it is valid only for the exact identifiers used.  For the use of the 
-\name{let} command to attach more general functionality to an operator,
-see \nameref{forall}.
-
-Arrays as a whole cannot be arguments to \name{let} statements, but
-matrices as a whole can be legal arguments, provided both arguments are
-matrices.  However, it is important to note that the two matrices are then
-linked.  Any change to an element of one matrix changes the corresponding
-value in the other.  Unless you want this behavior, you should not use
-\name{let} for matrices.  The assignment operator \nameref{assign} can be used
-for non-tracking assignments, avoiding the side effects.  Matrices are
-redimensioned as needed in \name{let} statements.
-
-When array or matrix elements are used as the left-hand side of \name{let}
-statements, the contents of that element is used as the argument.  When the 
-contents is a number or some other expression that is not a valid left-hand 
-side for \name{let}, you get an error message.  If the contents is an
-identifier or simple expression, the \name{let} rule is globally attached 
-to that identifier, and is in effect not only inside the array or matrix, 
-but everywhere.  Because of such unwanted side effects, you should not 
-use \name{let} with array or matrix elements.  The assignment operator 
-\name{:=} can be used to put values into array or matrix elements without 
-the side effects.
-
-Local variables declared inside \name{begin}\ldots\name{end} blocks cannot
-be used as the left-hand side of \name{let} statements.  However,
-\nameref{begin}\ldots\name{end} blocks themselves can be used as the
-right-hand side of \name{let} statements.  The construction:
-\begin{Syntax}
-        \name{for all} \meta{vars}
-        \name{let}\meta{operator}\(\meta{vars}\)\name{=}\meta{block}
-\end{Syntax}
-is an alternative to the 
-\begin{Syntax}
-        \name{procedure} \meta{name}\(\meta{vars}\)\name{;}\meta{block}
-\end{Syntax}
-construction.  One important difference between the two constructions is that
-the \meta{vars} as formal parameters to a procedure have their global values
-protected against change by the procedure, while the \meta{vars} of a 
-\name{let} statement are changed globally by its actions. 
-
-Be careful in using a construction such as \name{let x = x + 1} except inside
-a controlled loop statement.  The process of resubstitution continues until 
-a stack overflow message is given.  
-
-The \name{let} statement may be used to make global changes to variables from
-inside procedures.  If \name{x} is a formal parameter to a procedure, the 
-command \name{let x = }\ldots makes the change to the calling variable.  
-For example, if a procedure was defined by 
-\begin{verbatim}
-        procedure f(x,y);
-        let x = 15;
-\end{verbatim}
-and the procedure was called as
-\begin{verbatim}
-        f(a,b);
-\end{verbatim}
-\name{a} would have its value changed to 15.  Be careful when using \name{let}
-statements inside procedures to avoid unwanted side effects.
-
-It is also important to be careful when replacing \name{let} statements with
-other \name{let} statements.  The overlapping of these substitutions can be
-unpredictable.  Ordinarily the latest-entered rule is the first to be applied.
-Sometimes the previous rule is superseded completely; other times it stays
-around as a special case.  The order of entering a set of related \name{let}
-expressions is very important to their eventual behavior.  The best
-approach is to assume that the rules will be applied in an arbitrary order.
-%%%Be sure to research this subject carefully when you are programming
-%%%mathematical operations using related \name{let} substitutions.
-\end{Comments}
-\end{Command}
-
-
-\begin{Declaration}{LINEAR}
-\index{operator}
-An operator can be declared linear in its first argument over powers of
-its second argument by the declaration \name{linear.}
-\begin{Syntax}
- \name{linear} \meta{operator}\{\name{,}\meta{operator}\}\optional
-\end{Syntax}
-\meta{operator} must have been declared to be an operator.  Be careful not
-to use a system operator name, because this command may change its definition.
-The operator being declared must have at least two arguments, and the
-second one must be a \nameref{kernel}.
-
-\begin{Examples}
-operator f; \\
-linear f; \\
-f(0,x);                      &        0 \\
-f(-y,x);                     &        - F(1,X)*Y \\
-f(y+z,x);                    &        F(1,X)*(Y + Z) \\
-f(y*z,x);                    &        F(1,X)*Y*Z \\
-depend z,x; \\
-f(y*z,x);                    &        F(Z,X)*Y \\
-f(y/z,x);                    &        F(\rfrac{1}{Z},X)*Y \\
-depend y,x;  \\
-f(y/z,x);                    &        F(\rfrac{Y}{Z},X) \\
-nodepend z,x; \\
-f(y/z,x);                    &        \rfrac{F(Y,X)}{Z} \\
-f(2*e**sin(x),x);            &        2*F(E^{SIN(X)},X)
-\end{Examples}
-
-\begin{Comments}
-Even when the operator has not had its functionality attached, it exhibits
-linear properties as shown in the examples.  Notice the difference when
-dependencies are added.  Dependencies are also in effect when the operator's
-first argument contains its second, as in the last line above.
-
-For a fully-developed example of the use of linear operators, refer to the
-article in the \meta{Journal of Computational Physics}, Vol. 14 (1974), pp.
-301-317, ``Analytic Computation of Some Integrals in Fourth Order Quantum
-Electrodynamics," by J.A. Fox and A.C. Hearn.  The article includes the
-complete listing of REDUCE procedures used for this work.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{LINELENGTH}
-\index{output}
-The \name{linelength} declaration sets the length of the output line. Default
-is 80.
-\begin{Syntax}
-\name{linelength} \meta{expression}
-\end{Syntax}
-
-To change the linelength,
-\meta{expression} must evaluate to a positive integer less than 128
-(although this varies from system to system), and should not be less than
-20 or so for proper operation.
-
-\begin{Comments}
-% If you want to use a thin window to set beside another window,
-% reset the linelength shorter to avoid problems with raised exponents.
-\name{linelength} returns the previous linelength.  If you want the current
-linelength value, but not change it, say \name{linelength nil}.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{LISP}
-The \name{lisp} command changes REDUCE's mode of operation to symbolic.  When
-\name{lisp} is followed by an expression, that expression is evaluated in
-symbolic mode, but REDUCE's mode is not changed.  This command is
-equivalent to \nameref{symbolic}.
-
-\begin{Examples}
-lisp;                       &            NIL \\
-car '(a b c d e);           &            A  \\
-algebraic; \\
-c := (lisp car '(first second))**2; \\
-			    &           C := FIRST^{2}
-
-\end{Examples}
-
-\end{Command}
-
-
-\begin{Declaration}{LISTARGP}
-\index{list}\index{argument}
-\begin{Syntax}
-\name{listargp} \meta{operator}\{\name{,}\meta{operator}\}\optional
-\end{Syntax}
-If an operator other than those specifically defined for lists is given a
-single argument that is a \nameref{list}, then the result of this 
-operation will be a list in which that operator is applied to each element 
-of the list.
-This process can be inhibited for a specific operator, or list of operators,
-by using the declaration \name{listargp}.
-
-\begin{Examples}
-log {a,b,c}; & {LOG(A),LOG(B),LOG(C)} \\
-listargp log; \\
-log {a,b,c}; & LOG({A,B,C})
-\end{Examples}
-
-\begin{Comments}
-It is possible to inhibit such distribution globally by turning on the
-switch \nameref{listargs}.  In addition, if an operator has more than one
-argument, no such distribution occurs, so \name{listargp} has no effect.
-\end{Comments}
-
-\end{Declaration}
-
-
-\begin{Declaration}{NODEPEND}
-\index{depend}
-The \name{nodepend} declaration removes the dependency declared with
-\nameref{depend}.
-\begin{Syntax}
-\name{nodepend} \meta{dep-kernel}\{,\meta{kernel}\}\repeated
-
-\end{Syntax}
-
-
-\meta{dep-kernel} must be a kernel that has had a dependency declared upon the 
-one or more other kernels that are its other arguments.  
-
-\begin{Examples}
-depend y,x,z; \\
-df(sin y,x);                 &        COS(Y)*DF(Y,X) \\
-df(sin y,x,z);               &  COS(Y)*DF(Y,X,Z) - DF(Y,X)*DF(Y,Z)*SIN(Y) \\
-nodepend y,z; \\
-df(sin y,x);                 &        COS(Y)*DF(Y,X) \\
-df(sin y,x,z);               &        0
-\end{Examples}
-
-\begin{Comments}
-A warning message is printed if the dependency had not been declared by
-\name{depend}.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{MATCH}
-\index{substitution}
-The \name{match} command is similar to the \nameref{let} command, except
-that it matches only explicit powers in substitution.
-\begin{Syntax}
-\name{match} \meta{expr} \name{=} \meta{expression}\{,\meta{expr}
- \name{=}\meta{expression}\}\optional
-\end{Syntax}
-
-\meta{expr} is generally a term involving powers, and is limited by
-the rules for the \nameref{let} command.  \meta{expression} may be
-any valid REDUCE scalar expression.
-
-
-\begin{Examples}
-match c**2*a**2 = d;
-(a+c)**4;                    &      
-            A^{4}  + 4*A^{3}*C + 4*A*C^{3} + C^{4} + 6*D \\
-match a+b = c; \\
-a + 2*b;                     &       B + C \\
-(a + b + c)**2;              &       
-            A^{2}  - B^{2}  + 2*B*C + 3*C^{2} \\
-clear a+b; \\
-(a + b + c)**2;              &       
-            A ^{2} + 2*A*B + 2*A*C + B^{2} + 2*B*C + C^{2} \\
-let p*r = s; \\
-match p*q = ss; \\
-(a + p*r)**2;                &       A^{2} + 2*A*S + S^{2} \\
-(a + p*q)**2;                &       A^{2}  + 2*A*SS + P^{2}*Q^{2}
-\end{Examples}
-
-\begin{Comments}
-Note in the last example that \name{a + b} has been explicitly matched
-after the squaring was done, replacing each single power of \name{a} by
-\name{c - b}.  This kind of substitution, although following the rules, is
-confusing and could lead to unrecognizable results.  It is better to use
-\name{match} with explicit powers or products only.  \name{match} should
-not be used inside procedures for the same reasons that \name{let} should
-not be.
-
-Unlike \nameref{let} substitutions, \name{match} substitutions are executed
-after all other operations are complete.  The last example shows the
-difference. \name{match} commands can be cleared by using \nameref{clear},
-with exactly the expression that the original \name{match} took.
-\name{match} commands can also be done more generally with \name{for all}
-or \nameref{forall}\ldots\name{such that} commands.
-\end{Comments}
-\end{Command}
-
-
-\begin{Declaration}{NONCOM}
-\index{commutative}\index{non commutative}\index{operator}
-\name{noncom} declares that already-declared operators are noncommutative
-under multiplication.
-\begin{Syntax}
-\name{noncom} \meta{operator}\{,\meta{operator}\}\optional
-\end{Syntax}
-
-\meta{operator} must have been declared an \nameref{operator}, or a warning
-message is given.
-
-\begin{Examples}
-operator f,h; \\
-noncom f; \\
-f(a)*f(b) - f(b)*f(a);       &         F(A)*F(B) - F(B)*F(A) \\
-h(a)*h(b) - h(b)*h(a);       &         0 \\
-operator comm; \\
-\begin{multilineinput}
-for all x,y such that x neq y and ordp(x,y)
-        let f(x)*f(y) = f(y)*f(x) + comm(x,y);
-\end{multilineinput}\\
-f(1)*f(2);                   &         F(1)*F(2) \\
-f(2)*f(1);                   &         COMM(2,1) + F(1)*F(2)
-\end{Examples}
-
-\begin{Comments}
-The last example introduces the commutator of $f(x)$ and $f(y)$
-for all x and y.  The equality check is to prevent an infinite loop.  The 
-operator {\it f} can have other functionality attached to it if desired, or it 
-can remain an indeterminate operator.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{NONZERO}
-\index{operator}
-\begin{Syntax}
-\name{nonzero} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-If an \ref{operator} \name{f} is declared \nameref{odd}, then \name{f(0)}
-is replaced by zero unless \name{f} is also declared {\em non zero} by the
-declaration \name{nonzero}.
-\begin{Examples}
-	odd f; \\
-	f(0)    &   0 \\
-	nonzero f; \\
-	f(0) &   F(0)
-\end{Examples}
-\end{Declaration}
-
-
-\begin{Declaration}{ODD}
-\index{operator}
-
-\begin{Syntax}
-\name{odd} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-This declaration is used to declare an operator {\em odd} in its first
-argument.  Expressions involving an operator declared in this manner are
-transformed if the first argument contains a minus sign.  Any other
-arguments are not affected.
-\begin{Examples}
-	odd f; \\
-	f(-a)    &   -F(A) \\
-	f(-a,-b) &   -F(A,-B) \\
-	f(a,-b)  &    F(A,-B)
-\end{Examples}
-
-\begin{Comments}
-
-If say \name{f} is declared odd, then \name{f(0)} is replaced by zero
-unless \name{f} is also declared {\em non zero} by the declaration
-\nameref{nonzero}.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{OFF}
-\index{switch}
-The \name{off} command is used to turn switches off.
-\begin{Syntax}
-\name{off} \meta{switch}\{,\meta{switch}\}\optional
-\end{Syntax}
-
-\meta{switch} can be any \name{switch} name.  There is no problem if the
-switch is already off.  If the switch name is mistyped, an error message is
-given.
-\end{Command}
-
-
-\begin{Command}{ON}
-\index{switch}
-The \name{on} command is used to turn switches on.
-\begin{Syntax}
-\name{on} \meta{switch}\{,\meta{switch}\}\optional
-\end{Syntax}
-
-\meta{switch} can be any \name{switch} name.  There is no problem if the
-switch is already on.  If the switch name is mistyped, an error message is
-given.
-\end{Command}
-
-
-\begin{Declaration}{OPERATOR}
-Use the \name{operator} declaration to declare your own operators.
-\begin{Syntax}
-\name{operator} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} can be any valid REDUCE identifier, which is not the name
-of a \nameref{matrix}, \nameref{array}, scalar variable or previously-defined
-operator.  
-
-\begin{Examples}
-operator dis,fac; \\
-let dis(~x,~y) = sqrt(x^2 + y^2); \\
-dis(1,2);                   &       SQRT(5) \\
-dis(a,10);                  &       SQRT(A^{2} + 100) \\
-on rounded; \\
-dis(1.5,7.2);               &       7.35459040329\\
-\begin{multilineinput}
-let fac(~n) = if n=0 then 1
-               else if not(fixp n and n>0)
-                then rederr "choose non-negative integer"
-               else for i := 1:n product i;
-\end{multilineinput} \\
-fac(5);                     &      120 \\
-fac(-2);                    &      ***** choose non-negative integer
-\end{Examples}
- 
-\begin{Comments}
-The first operator is the Euclidean distance metric, the distance of point
-$(x,y)$ from the origin.  The second operator is the factorial.
-
-Operators can have various properties assigned to them; they can be
-declared \nameref{infix}, \nameref{linear}, \nameref{symmetric}, 
-\nameref{antisymmetric}, or \nameref{noncom}\name{mutative}.
-The default operator is prefix, nonlinear, and commutative.
-Precedence can also be assigned to operators using the declaration
-\nameref{precedence}.
-
-Functionality is assigned to an operator by a \nameref{let} statement or
-a \nameref{forall}\ldots\name{let} statement, 
-(or possibly by a procedure with the name
-of the operator). Be careful not to redefine a system operator by
-accident. REDUCE permits you to redefine system operators, giving you a 
-warning message that the operator was already defined.  This flexibility 
-allows you to add mathematical rules that do what you want them to do, but 
-can produce odd or erroneous behavior if you are not careful. 
-
-You can declare operators from inside \nameref{procedure}s, as long as they 
-are not local variables.  Operators defined inside procedures are global. 
-A formal parameter may be declared as an operator, and has the effect of 
-declaring the calling variable as the operator.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{ORDER}
-\index{order}\index{variable order}\index{output}
-The \name{order} declaration changes the order of precedence of kernels for
-display purposes only.
-\begin{Syntax}
-\name{order} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-\meta{kernel} must be a valid \nameref{kernel} or \nameref{operator} name
-complete with argument or a \nameref{list} of such objects.
-
-\begin{Examples}
-x + y + z + cos(a);         &         COS(A) + X + Y + Z \\
-order z,y,x,cos(a); \\
-x + y + z + cos(a);         &         Z + Y + X + COS(A) \\
-(x + y)**2;                 &         Y^{2} + 2*Y*X + X^{2} \\
-order nil; \\
-(z + cos(z))**2;            &         COS(Z)^{2} + 2*COS(Z)*Z + Z^{2}
-\end{Examples}
-
-\begin{Comments}
-\name{order} affects the printing order of the identifiers only; internal
-order is unchanged.  Change internal order of evaluation with the
-declaration \nameref{korder}.  You can use \name{order} to feature variables
-or functions you are particularly interested in.
-
-Declarations made with \name{order} are cumulative:  kernels in new order
-declarations are ordered behind those in previous declarations, and
-previous declarations retain their relative order.  Of course, specific
-kernels named in new declarations are removed from previous ones and given
-the new priority.  Return to the standard canonical printing order with the 
-statement \name{order nil}.
-
-The print order specified by \name{order} commands is not in effect if the
-switch \nameref{pri} is off.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{PRECEDENCE}
-\index{operator}
-The \name{precedence} declaration attaches a precedence to an infix operator.
-\begin{Syntax}
-\name{precedence} \meta{operator},\meta{known\_operator}
-\end{Syntax}
-
-\meta{operator} should have been declared an operator but may be a REDUCE
-identifier that is not already an operator, array, or matrix.
-\meta{known\_operator} must be a system infix operator or have had its
-precedence already declared.
-
-\begin{Examples}
-operator f,h; \\
-precedence f,+; \\
-precedence h,*;  \\
-a + f(1,2)*c;                &         (1 F 2)*C + A \\
-a + h(1,2)*c;                &         1 H 2*C + A \\
-a*1 f 2*c;                   &         A F 2*C \\
-a*1 h 2*c;                   &         1 H 2*A*C
-%%%symbolic;                    &         NIL \\
-%%%preclis!*;                  &
-%%%   (IREM IEQUAL OVER ADD MULT TO OR AND NOT MEMBER MEMQ EQUAL NEQ EQ GEQ
-%%%   GREATERP IGREATERP LEQ LESSP ILESSP FREEOF PLUS F IPLUS DIFFERENCE
-%%%   IDIFFERENCE TIMES H ITIMES QUOTIENT IQUOTIENT EXPT CONS)
-\end{Examples}
-
-\begin{Comments}
-The operator whose precedence is being declared is inserted into the infix
-operator precedence list at the next higher place than \meta{known\_operator}.
-
-Attaching a precedence to an operator has the side effect of declaring the
-operator to be infix.  If the identifier argument for \name{precedence} has
-not been declared to be an operator, an attempt to use it causes an error
-message.  After declaring it to be an operator, it becomes an infix operator
-with the precedence previously given.  Infix operators may be used in prefix
-form; if they are used in infix form, a space must be left on each side of
-the operator to avoid ambiguity.  Declared infix operators are always binary.
-
-To see the infix operator precedence list, enter symbolic mode and type
-\name{preclis!*;}.  The lowest precedence operator is listed first.
-
-All prefix operators have precedence higher than infix operators.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{PRECISION}
-\index{rounded}\index{floating point}
-The \name{precision} declaration sets the number of decimal places used when
-\nameref{rounded} is on.  Default is system dependent, and normally about 12.
-\begin{Syntax}
-\name{precision}(\meta{integer}) or \name{precision} \meta{integer}
-\end{Syntax}
-
-\meta{integer} must be a positive integer.  When \meta{integer} is 0, the
-current precision is displayed, but not changed.  There is no upper limit,
-but precision of greater than several hundred causes unpleasantly slow
-operation on numeric calculations.
-
-\begin{Examples}
-on rounded; \\
-7/9;                         &       0.777777777778 \\
-precision 20;                &       20 \\
-7/9;                         &       0.77777777777777777778 \\
-sin(pi/4);                   &       0.7071067811865475244
-\end{Examples}
-
-\begin{Comments}
-Trailing zeroes are dropped, so sometimes fewer than 20 decimal places are
-printed as in the last example.  Turn on the switch \nameref{fullprec} if
-you want to print all significant digits.  The \nameref{rounded} mode
-carries calculations to two more places than given by \name{precision}, and
-rounds off.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{PRINT\_PRECISION}
-\index{output}\index{floating point}\index{rounded}
-
-\begin{Syntax}
-\name{print\_precision}(\meta{integer})
-   or \name{print\_precision} \meta{integer}
-\end{Syntax}
-
-In \nameref{rounded} mode, numbers are normally printed to the specified
-precision.  If the user wishes to print such numbers with less precision,
-the printing precision can be set by the declaration \name{print\_precision}.
-
-\begin{Examples}
-on rounded; \\
-1/3; & 0.333333333333 \\
-print_precision 5; \\
-1/3 & 0.33333
-\end{Examples}
-\end{Declaration}
-
-
-\begin{Declaration}{REAL}
-The \name{real} declaration must be made immediately after a
-\nameref{begin} (or other variable declaration such as \nameref{integer}
-and \nameref{scalar}) and declares local integer variables.  They are
-initialized to zero.
-\begin{Syntax}
-\name{real} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} may be any valid REDUCE identifier, except
-\name{t} or \name{nil}.
-
-\begin{Comments}
-Real variables remain local, and do not share values with variables of the
-same name outside the \nameref{begin}\ldots\name{end} block.  When the
-block is finished, the variables are removed.  You may use the words
-\nameref{integer} or \nameref{scalar} in the place of \name{real}.
-\name{real} does not indicate typechecking by the current REDUCE; it is
-only for your own information.  Declaration statements must immediately
-follow the \name{begin}, without a semicolon between \name{begin} and the
-first variable declaration.
-
-Any variables used inside a \name{begin}\ldots\name{end} \nameref{block}
-that were not declared \name{scalar}, \name{real} or \name{integer} are
-global, and any change made to them inside the block affects their global
-value.  Any \ref{array} or \ref{matrix} declared inside a block is always
-global.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{REMFAC}
-\index{factor}\index{output}
-The \name{remfac} declaration removes the special factoring treatment of its
-arguments that was declared with \nameref{factor}.
-\begin{Syntax}
-\name{remfac} \meta{kernel}\{,\meta{kernel}\}\repeated
-\end{Syntax}
-
-\meta{kernel} must be a \nameref{kernel} or \nameref{operator} name that
-was declared as special with the \nameref{factor} declaration.
-\end{Declaration}
-
-
-\begin{Declaration}{SCALAR}
-The \name{scalar} declaration must be made immediately after a
-\nameref{begin} (or other variable declaration such as \nameref{integer}
-and \nameref{real}) and declares local scalar variables.  They are
-initialized to 0.
-\begin{Syntax}
-\name{scalar} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} may be any valid REDUCE identifier, except \name{t} or
-\name{nil}.
-
-\begin{Comments}
-Scalar variables remain local, and do not share values with variables of
-the same name outside the \nameref{begin}\ldots\name{end} \nameref{block}.
-When the block is finished, the variables are removed.  You may use the
-words \nameref{real} or \nameref{integer} in the place of \name{scalar}.
-\name{real} and \name{integer} do not indicate typechecking by the current
-REDUCE; they are only for your own information.  Declaration statements
-must immediately follow the \name{begin}, without a semicolon between
-\name{begin} and the first variable declaration.
-
-Any variables used inside \name{begin}\ldots\name{end} blocks that were not
-declared \name{scalar}, \name{real} or \name{integer} are global, and any
-change made to them inside the block affects their global value.  Arrays
-declared inside a block are always global.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{SCIENTIFIC\_NOTATION}
-\index{output}\index{floating point}\index{rounded}
-\begin{Syntax}
-\name{scientific\_notation}(\meta{m}) or
-\name{scientific\_notation}(\{\meta{m},\meta{n}\})
-\end{Syntax}
-
-\meta{m} and \meta{n} are positive integers.
-\name{scientific\_notation} controls the output format of floating point
-numbers.  At the default settings, any number with five or less digits
-before the decimal point is printed in a fixed-point notation, e.g., 
-{\tt 12345.6}.  Numbers with more than five digits are printed in scientific
-notation, e.g., {\tt 1.234567E+5}.  Similarly, by default, any number with
-eleven or more zeros after the decimal point is printed in scientific
-notation.
-
-When \name{scientific\_notation} is called with the numerical argument
-{\em m} a number with more than {\em m} digits before the decimal point,
-or {\em m} or more zeros after the decimal point, is printed in scientific
-notation.  When \name{scientific\_notation} is called with a list
-\{\meta{m},\meta{n}\}, a number with more than {\em m} digits before the
-decimal point, or {\em n} or more zeros after the decimal point is
-printed in scientific notation.
-
-\begin{Examples}
-
-on rounded;\\
-
-12345.6;&
-
-12345.6\\
-
-123456.5;&1.234565e+5\\
-
-0.00000000000000012;&
-
-1.2e-16\\
-
-scientific_notation 20;&
-
-{5,11}\\
-
-5: 123456.7;&
-
-123456.7\\
-
-0.00000000000000012;&
-
-0.00000000000000012\\
-
-\end{Examples}
-\end{Declaration}
-
-
-\begin{Declaration}{SHARE}
-The \name{share} declaration allows access to its arguments by both
-algebraic and symbolic modes.
-\begin{Syntax}
-\name{share} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} can be any valid REDUCE identifier.
-
-\begin{Comments}
-Programming in \nameref{symbolic} as well as algebraic mode allows 
-you a wider range
-of techniques than just algebraic mode alone.  Expressions do not cross the
-boundary since they have different representations, unless the \name{share}
-declaration is used.  For more information on using symbolic mode, see
-the \meta{REDUCE User's Manual}, and the \meta{Standard Lisp Report}.
-
-You should be aware that a previously-declared array is destroyed by the
-\name{share} declaration.  Scalar variables retain their values.  You can
-share a declared \nameref{matrix} that has not yet 
-been dimensioned so that it can be
-used by both modes.  Values that are later put into the matrix are
-accessible from symbolic mode too, but not by the usual matrix reference
-mechanism.  In symbolic mode, a matrix is stored as a list whose first
-element is \nameref{MAT}, and whose next elements are the rows of the matrix
-stored as lists of the individual elements.  Access in symbolic mode is by
-the operators \nameref{first}, \nameref{second}, \nameref{third} and
-\nameref{rest}.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{SYMBOLIC}
-The \name{symbolic} command changes REDUCE's mode of operation to symbolic.
-When \name{symbolic} is followed by an expression, that expression is
-evaluated in symbolic mode, but REDUCE's mode is not changed.  It is
-equivalent to the \nameref{lisp} command.
-
-\begin{Examples}
-symbolic;                    &       NIL \\
-cdr '(a b c);                &       (B C) \\
-algebraic; \\
-x + symbolic car '(y z);     &       X + Y
-\end{Examples}
-% \begin{Comments}
-% You can tell when you are in symbolic mode by noting that the numbered
-% prompt contains an asterisk (\name{*}) rather than a colon.
-% \end{Comments}
-\end{Command}
-
-
-\begin{Declaration}{SYMMETRIC}
-\index{operator}
-When an operator is declared \name{symmetric}, its arguments are reordered
-to conform to the internal ordering of the system.  
-\begin{Syntax}
-\name{symmetric} \meta{identifier}\{,\meta{identifier}\}\optional
-\end{Syntax}
-
-\meta{identifier} is an identifier that has been declared an operator.
-
-\begin{Examples}
-operator m,n; \\
-symmetric m,n; \\
-m(y,a,sin(x));               &           M(SIN(X),A,Y) \\
-n(z,m(b,a,q));               &           N(M(A,B,Q),Z)
-\end{Examples}
-
-\begin{Comments}
-If \meta{identifier} has not been declared to be an operator, the flag
-\name{symmetric} is still attached to it.  When \meta{identifier} is
-subsequently used as an operator, the message \name{Declare}\meta{identifier}
- \name{operator ? (Y or N)} is printed.  If the user replies \name{y}, the
-symmetric property of the operator is used.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{TR}
-\index{trace}
-The \name{tr} declaration is used to trace system or user-written procedures.
-It is only useful to those with a good knowledge of both Lisp and the
-internal formats used by REDUCE.
-
-\begin{Syntax}
-\name{tr} \meta{name}\{,\meta{name}\}\optional
-\end{Syntax}
-
-\meta{name} is the name of a REDUCE system procedure or one of your own
-procedures.
-
-\begin{Examples}
-\explanation{The system procedure \name{prepsq} is traced,
-	     which prepares REDUCE standard
-forms for printing by converting them to a Lisp prefix form.} \\
-tr prepsq;               &      (PREPSQ) \\
-x**2 + y;                &
-\begin{multilineoutput}{6cm}
-PREPSQ entry:
-  Arg 1: (((((X . 2) . 1) ((Y . 1) . 1)) . 1)
-PREPSQ return value = (PLUS (EXPT X 2) Y)
-PREPSQ entry:
-  Arg 1: (1 . 1)
-PREPSQ return value = 1
-X^{2} + Y
-\end{multilineoutput}\\
-untr prepsq;             &       (PREPSQ)
-\end{Examples}
-
-\begin{Comments}
-This example is for a PSL-based system; the above format will vary if
-other Lisp systems are used.
-
-When a procedure is traced, the first lines show entry to the procedure and
-the arguments it is given.  The value returned by the procedure is printed
-upon exit.  If you are tracing several procedures, with a call to one of
-them inside the other, the inner trace will be indented showing procedure
-nesting.  There are no trace options. However, the format of the trace
-depends on the underlying Lisp system used.  The trace can be removed with
-the command \nameref{untr}.  Note that \name{trace}, below, is a matrix
-operator, while \name{tr} does procedure tracing.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Declaration}{UNTR}
-\index{trace}
-The \name{untr} declaration is used to remove a trace from system or
-user-written procedures declared with \nameref{tr}.  It is only useful to
-those with a good knowledge of both Lisp and the internal formats used by
-REDUCE.
-
-\begin{Syntax}
-\name{untr} \meta{name}\{,\meta{name}\}\optional
-\end{Syntax}
-
-\meta{name} is the name of a REDUCE system procedure or one of your own
-procedures that has previously been the argument of a \name{tr}
-declaration.
-\end{Declaration}
-
-
-\begin{Declaration}{VARNAME}
-The declaration \name{varname} instructs REDUCE to use its argument as the
-default Fortran (when \nameref{fort} is on) or \nameref{structr} identifier
-and identifier stem, rather than using \name{ANS}.
-\begin{Syntax}
-\name{varname} \meta{identifier}
-\end{Syntax}
-
-\meta{identifier} can be any combination of one or more alphanumeric
-characters.  Try to avoid REDUCE reserved words.
-
-\begin{Examples}
-varname ident;               &         IDENT \\
-on fort; \\
-x**2 + 1;                    &         IDENT=X**2+1. \\
-off fort,exp; \\
-structr(((x+y)**2 + z)**3);  &\begin{multilineoutput}{6cm}
-IDENT2^{3}
-    where
-       IDENT2 := IDENT1^{2} + Z
-IDENT1 := X + Y
-\end{multilineoutput}
-\end{Examples}
-\begin{Comments}
-\nameref{exp} was turned off so that \nameref{structr} could show the
-structure.  If \name{exp} had been on, the expression would have been
-expanded into a polynomial.
-\end{Comments}
-\end{Declaration}
-
-
-\begin{Command}{WEIGHT}
-The \name{weight} command is used to attach weights to kernels for asymptotic
-constraints.
-\begin{Syntax}
-\name{weight} \meta{kernel} \name{=}\meta{number}
-\end{Syntax}
-
-\meta{kernel} must be a REDUCE \nameref{kernel}, \meta{number} must be a
-positive integer, not 0.
-
-\begin{Examples}
-a := (x+y)**4;               & 
-     A := X^{4} + 4*X^{3}*Y + 6*X^{2}*Y^{2} + 4*X*Y^{3} + Y^{4} \\
-weight x=2,y=3; \\
-wtlevel 8; \\
-a;                           &     X^{4} \\
-wtlevel 10; \\
-a;                           &      X^{2}*(6*Y^{2} + 4*X*Y  + X^{2}) \\
-int(x**2,x);                 &     ***** X invalid as KERNEL
-\end{Examples}
-\begin{Comments}
-Weights and \nameref{wtlevel} are used for asymptotic constraints, where
-higher-order terms are considered insignificant.  
-
-Weights are originally equivalent to 0 until set by a \name{weight}
-command.  To remove a weight from a kernel, use the \nameref{clear}
-command.  Weights once assigned cannot be changed without clearing the
-identifier.  Once a weight is assigned to a kernel, it is no longer a
-kernel and cannot be used in any REDUCE commands or operators that require
-kernels, until the weight is cleared.  Note that terms are ordered by
-greatest weight.
-
-The weight level of the system is set by \nameref{wtlevel}, initially at
-2.  Since no kernels have weights, no effect from \name{wtlevel} can be
-seen.  Once you assign weights to kernels, you must set \name{wtlevel}
-correctly for the desired operation.  When weighted variables appear in a
-term, their weights are summed for the total weight of the term (powers of
-variables multiply their weights).  When a term exceeds the weight level
-of the system, it is discarded from the result expression.
-\end{Comments}
-\end{Command}
-
-
-\begin{Operator}{WHERE}
-\index{substitution}
-The \name{where} operator provides an infix notation for one-time
-substitutions for kernels in expressions.
-\begin{Syntax}
-\meta{expression} \name{where} \meta{kernel} 
-       \name{=}\meta{expression}\
-	 \{,\meta{kernel} \name{=}\meta{expression}\}\optional
-\end{Syntax}
-
-\meta{expression} can be any REDUCE scalar expression, \meta{kernel} must
-be a \nameref{kernel}. Alternatively a \nameref{rule} or a \name{rule list}
-can be a member of the right-hand part of a \name{where} expression. 
-
-\begin{Examples}
-x**2 + 17*x*y + 4*y**2 where x=1,y=2;          &      51 \\
-for i := 1:5 collect x**i*q where q= for j := 1:i product j;
-			     & \{X,2*X^{2},6*X^{3},24*X^{4},120*X^{5}\} \\
-x**2 + y + z where z=y**3,y=3;                 &      X^{2} + Y^{3} + 3
-\end{Examples}
-
-\begin{Comments}
-Substitution inside a \name{where} expression has no effect upon the values
-of the kernels outside the expression.  The \name{where} operator has the
-lowest precedence of all the infix operators, which are lower than prefix
-operators, so that the substitutions apply to the entire expression
-preceding the \name{where} operator.  However, \name{where} is applied
-before command keywords such as \name{then}, \name{repeat}, or \name{do}.
-
-A \nameref{rule} or a \name{rule set} in the right-hand part of the
-\name{where} expression act as if the rules were activated by \nameref{let}
-immediately before the evaluation of the expression and deactivated
-by \nameref{clearrules} immediately afterwards.
-
-\name{where} gives you a natural notation for auxiliary variables in
-expressions.  As the second example shows, the substitute expression can be
-a command to be evaluated.  The substitute assignments are made in
-parallel, rather than sequentially, as the last example shows.   The
-expression resulting from the first round of substitutions is not
-reexamined to see if any further such substitutions can be made.
-\name{where} can also be used to define auxiliary variables in
-\nameref{procedure} definitions.
-\end{Comments}
-\end{Operator}
-
-
-\begin{Command}{WHILE}
-\index{loop}
-The \name{while} command causes a statement to be repeatedly executed until a
-given condition is true.  If the condition is initially false, the statement
-is not executed at all.
-\begin{Syntax}
-\name{while} \meta{condition} \name{do} \meta{statement}
-\end{Syntax}
-
-\meta{condition} is given by a logical operator, \meta{statement} must be a
-single REDUCE statement, or a \nameref{group} (\name{<<}\ldots\name{>>}) or
-\nameref{begin}\ldots\name{end} \nameref{block}.
-
-\begin{Examples}
-a := 10;                     &           A := 10 \\
-while a <= 12 do <<write a; a := a + 1>>;
-			     &           10 \\
-                                          11 \\
-                                          12 \\
-while a < 5 do <<write a; a := a + 1>>;
-			     &           {\it nothing is printed}
-\end{Examples}
-
-\end{Command}
-
-
-\begin{Command}{WTLEVEL}
-In conjunction with \nameref{weight}, \name{wtlevel} is used to implement
-asymptotic constraints.  Its default value is 2.
-\begin{Syntax}
-\name{wtlevel} \meta{expression}
-\end{Syntax}
-
-To change the weight level, \meta{expression} must evaluate to a positive
-integer that is the greatest weight term to be retained in expressions
-involving kernels with weight assignments. \name{wtlevel} returns the
-new weight level.  If you want the current weight level, but not
-change it, say \name{wtlevel nil}.
-
-\begin{Examples}
-(x+y)**4;          
-        & X^{4} + 4*X^{3}*Y + 6*X^{2}*Y^{2} + 4*X*Y^{3} + Y^{4} \\
-weight x=2,y=3; \\
-wtlevel 8; \\
-(x+y)**4;          & X^{4} \\
-wtlevel 10; \\
-(x+y)**4;          & X^{2}*(6*Y^{2} + 4*X*Y + X^{2}) \\
-int(x**2,x);       & ***** X invalid as KERNEL
-\end{Examples}
-\begin{Comments}
-\name{wtlevel} is used in conjunction with the command \nameref{weight} to
-enable asymptotic constraints.  Weight of a term is computed by multiplying
-the weights of each variable in it by the power to which it has been
-raised, and adding the resulting weights for each variable.  If the weight
-of the term is greater than \name{wtlevel}, the term is dropped from the
-expression, and not used in any further computation involving the
-expression.
-
-Once a weight has been attached to a \nameref{kernel}, it is no longer
-recognized by the system as a kernel, though still a variable.  It cannot
-be used in REDUCE commands and operators that need kernels.  The weight
-attachment can be undone with a \nameref{clear} command. \name{wtlevel} can
-be changed as desired.
-\end{Comments}
-\end{Command}
-
+\section{Declarations}
+
+\begin{Command}{ALGEBRAIC}
+\index{evaluation}
+The \name{algebraic} command changes REDUCE's mode of operation to
+algebraic.  When \name{algebraic} is used as an operator (with an
+argument inside parentheses) that argument is evaluated in algebraic
+mode, but REDUCE's mode is not changed.
+
+\begin{Examples}
+algebraic; \\
+symbolic;                  &      NIL \\
+algebraic(x**2);           &      X^{2} \\
+x**2;                      &      \begin{multilineoutput}{6cm}
+  ***** The symbol X has no value.
+\end{multilineoutput}
+\end{Examples}
+
+\begin{Comments}
+REDUCE's symbolic mode does not know about most algebraic commands.
+Error messages in this mode may also depend on the particular Lisp
+used for the REDUCE implementation.
+% You can tell that you are in algebraic mode if the numbered prompt
+% contains a colon rather than an asterisk.
+\end{Comments}
+\end{Command}
+
+
+\begin{Declaration}{ANTISYMMETRIC}
+When an operator is declared \name{antisymmetric}, its arguments are
+reordered to conform to the internal ordering of the system.  If an odd
+number of argument interchanges are required to do this ordering,
+the sign of the expression is changed.
+
+\begin{Syntax}
+\name{antisymmetric} \meta{identifier}\{\name{,}\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} is an identifier that has been declared as an operator.
+
+\begin{Examples}
+operator m,n; \\
+antisymmetric m,n; \\
+m(x,n(1,2));               &         - M( - N(2,1),X) \\
+operator p; \\
+antisymmetric p; \\
+p(a,b,c);                  &           P(A,B,C) \\
+p(b,a,c);                  &         - P(A,B,C)
+\end{Examples}
+
+\begin{Comments}
+If \meta{identifier} has not been declared an operator, the flag
+\name{antisymmetric} is still attached to it.  When \meta{identifier} is
+subsequently used as an operator, the message \name{Declare} \meta{identifier}
+ \name{operator? (Y or N)} is printed.  If the user replies \name{y}, the
+antisymmetric property of the operator is used.
+
+Note in the first example, identifiers are customarily ordered
+alphabetically, while numbers are ordered from largest to smallest.
+The operators may have any desired number of arguments (less than 128).
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{ARRAY}
+The \name{array} declaration declares a list of identifiers to be of type
+\name{array}, and sets all their entries to 0.
+\begin{Syntax}
+\name{array}
+\meta{identifier}\(\meta{dimensions}\)
+              \{\name{,}\meta{identifier}\(\meta{dimensions}\)\}\optional
+\end{Syntax}
+
+\meta{identifier} may be any valid REDUCE identifier.  If the identifier
+was already an array, a warning message is given that the array has been
+redefined.  \meta{dimensions} are of form
+ \meta{integer}\{,\meta{integer}\}\optional.
+
+\begin{Examples}
+array a(2,5),b(3,3,3),c(200);  \\
+array a(3,5);              &     *** ARRAY A REDEFINED \\
+a(3,4);                    &     0 \\
+length a;                  &     {4,6}
+\end{Examples}
+
+\begin{Comments}
+Arrays are always global, even if defined inside a procedure or block
+statement.  Their status as an array remains until the variable is
+reset by \nameref{clear}.  Arrays may not have the same names as operators,
+procedures or scalar variables.
+
+Array elements are referred to by the usual notation: \name{a(i,j)}
+returns the jth element of the ith row.  The \nameref{assign}ment operator
+\name{:=} is used to put values into the array.  Arrays as a whole
+cannot be subject to assignment by \nameref{let} or \name{:=} ; the
+assignment operator \name{:=} is only valid for individual elements.
+
+When you use \nameref{let} on an array element, the contents of that
+element become the argument to \name{let}.  Thus, if the element
+contains a number or some other expression that is not a valid argument
+for this command, you get an error message.  If the element contains an
+identifier, the identifier has the substitution rule attached to it
+globally.  The same behavior occurs with \nameref{clear}.  If the array
+element contains an identifier or simple\_expression, it is cleared.  Do
+\meta{not} use \name{clear} to try to set an array element to 0.  Because
+of the side effects of either \name{let} or \name{clear}, it is unwise
+to apply either of these to array elements.
+
+Array indices always start with 0, so that the declaration \name{array a(5)}
+sets aside 6 units of space, indexed from 0 through 5, and initializes
+them to 0.  The \nameref{length} command returns a list of the true number of
+elements in each dimension.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{CLEAR}
+The \name{clear} command is used to remove assignments or remove substitution
+rules from any expression.
+
+\begin{Syntax}
+\name{clear} \meta{identifier}\{,\meta{identifier}\}\repeated \ or \\
+\meta{let-type statement} \name{clear} \meta{identifier}
+\end{Syntax}
+
+\meta{identifier} can be any \name{scalar}, \nameref{matrix}, 
+or \nameref{array} variable or
+\nameref{procedure} name.  \meta{let-type statement} can be any general 
+or specific \nameref{let} statement (see below in Comments).
+
+\begin{Examples}
+array a(2,3); \\
+a(2,2) := 15;                &             A(2,2) := 15 \\
+clear a;                     \\
+a(2,2);                      &             Declare A operator? (Y or N) \\
+let x = y + z; \\
+sin(x);                      &             SIN(Y + Z) \\
+clear x; \\
+sin(x);                      &             SIN(X) \\
+let x**5 = 7; \\
+clear x; \\
+x**5;                        &             7 \\
+clear x**5; \\
+x**5;                        &             X^{5}
+\end{Examples}
+\begin{Comments}
+
+Although it is not a good idea, operators of the same name but taking
+different numbers of arguments can be defined.  Using a \name{clear} statement
+on any of these operators clears every one with the same name, even if the
+number of arguments is different.
+
+The \name{clear} command is used to ``forget" matrices, arrays, operators
+and scalar variables, returning their identifiers to the pristine state
+to be used for other purposes.  When \name{clear} is applied to array
+elements, the contents of the array element becomes the argument for
+\name{clear}.  Thus, you get an error message if the element contains a
+number, or some other expression that is not a legal argument to
+\name{clear}.  If the element contains an identifier, it is cleared.
+When clear is applied to matrix elements, an error message is returned
+if the element evaluates to a number, otherwise there is no effect.  Do
+{\em not} try to use \name{clear} to set array or matrix elements to 0.
+You will not be pleased with the results.
+
+If you are trying to clear power or product substitution rules made with
+either \nameref{let} or \nameref{forall}\ldots\name{let}, you must
+reproduce the rule, exactly as you typed it with the same arguments, up to
+but not including the equal sign, using the word \name{clear} instead of
+the word \name{let}.  This is shown in the last example.  Any other type of
+\name{let} or \name{forall}\ldots\name{let} substitution can be cleared
+with just the variable or operator name.  \nameref{match} behaves the same as
+\nameref{let} in this situation.  There is a more complicated example under
+\nameref{forall}.
+
+\end{Comments}
+\end{Command}
+
+
+\begin{Command}{CLEARRULES}
+\index{rule}
+\begin{Syntax}
+\name{clearrules} \meta{list}\{,\meta{list}\}\repeated
+\end{Syntax}
+
+The operator \name{clearrules} is used to remove previously defined
+\nameref{rule} lists from the system.  \meta{list} can be an explicit rule
+list, or evaluate to a rule list.
+
+\begin{Examples}
+trig1 := {cos(~x)*cos(~y) => (cos(x+y)+cos(x-y))/2,
+	  cos(~x)*sin(~y) => (sin(x+y)-sin(x-y))/2,
+	  sin(~x)*sin(~y) => (cos(x-y)-cos(x+y))/2,
+	  cos(~x)^2       => (1+cos(2*x))/2,
+	  sin(~x)^2       => (1-cos(2*x))/2}$ \\
+let trig1;
+cos(a)*cos(b); &
+\rfrac{COS(A - B) + COS(A + B)}{2} \\
+clearrules trig1;
+cos(a)*cos(b); &  COS(A)*COS(B)
+\end{Examples}
+
+\end{Command}
+
+
+\begin{Command}{DEFINE}
+The command \name{define} allows you to supply a new name for an identifier
+or replace it by any valid REDUCE expression.
+
+\begin{Syntax}
+\name{define} \meta{identifier}\name{=}\meta{substitution}
+      \{\name{,}\meta{identifier}\name{=}\meta{substitution}\}\optional
+\end{Syntax}
+
+
+\meta{identifier} is any valid REDUCE identifier, \meta{substitution} can be a
+number, an identifier, an operator, a reserved word, or an expression.
+
+\begin{Examples}
+
+define is= :=, xx=y+z; \\
+
+a is 10;                     &            A := 10 \\
+
+xx**2;                       &            Y^{2}  + 2*Y*Z + Z^{2} \\
+
+xx := 10;                    &            Y + Z := 10
+\end{Examples}
+
+\begin{Comments}
+The renaming is done at the input level, and therefore takes precedence
+over any other replacement or substitution declared for the same identifier.
+It remains in effect until the end of the REDUCE session.  Be careful with
+it, since you cannot easily undo it without ending the session.
+\end{Comments}
+\end{Command}
+
+
+\begin{Declaration}{DEPEND}
+\index{dependency}
+\name{depend} declares that its first argument depends on the rest of its
+arguments.
+
+\begin{Syntax}
+\name{depend} \meta{kernel}\{\name{,}\meta{kernel}\}\repeated
+\end{Syntax}
+
+\meta{kernel} must be a legal variable name or a prefix operator (see
+\nameref{kernel}).
+
+\begin{Examples}
+
+depend y,x; \\
+
+df(y**2,x);                 &            2*DF(Y,X)*Y \\
+
+depend z,cos(x),y; \\
+
+df(sin(z),cos(x));          &            COS(Z)*DF(Z,COS(X)) \\
+
+df(z**2,x);                 &            2*DF(Z,X)*Z \\
+
+nodepend z,y; \\
+
+df(z**2,x);                 &            2*DF(Z,X)*Z \\
+
+cc := df(y**2,x);           &            CC := 2*DF(Y,X)*Y \\
+
+y := tan x;                 &            Y := TAN(X); \\
+
+cc;                         &            2*TAN(X)*(TAN(X)^{2}  + 1)
+\end{Examples}
+\begin{Comments}
+Dependencies can be removed by using the declaration \nameref{nodepend}.
+The differentiation operator uses this information, as shown in the
+examples above.  Linear operators also use knowledge of dependencies
+(see \nameref{linear}).  Note that dependencies can be nested:  Having
+declared \IFTEX{$y$}{y} to depend on \IFTEX{$x$}{x}, and \IFTEX{$z$}{z}
+to depend on \IFTEX{$y$}{y}, we
+see that the chain rule was applied to the derivative of a function of
+\IFTEX{$z$}{z} with respect to \IFTEX{$x$}{x}.   If the explicit function of the
+dependency is later entered into the system, terms with \name{DF(Y,X)},
+for example, are expanded when they are displayed again, as shown in the
+last example.  The boolean operator \nameref{freeof} allows you to
+check the dependency between two algebraic objects.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{EVEN}
+\begin{Syntax}
+\name{even} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+This declaration is used to declare an operator {\em even} in its first
+argument.  Expressions involving an operator declared in this manner are
+transformed if the first argument contains a minus sign.  Any other
+arguments are not affected.
+\begin{Examples}
+	even f; \\
+	f(-a)    &    F(A) \\
+	f(-a,-b) &    F(A,-B)
+\end{Examples}
+\end{Declaration}
+
+
+\begin{Declaration}{FACTOR}
+\index{output}
+When a kernel is declared by \name{factor}, all terms involving fixed
+powers of that kernel are printed as a product of the fixed powers and
+the rest of the terms. 
+\begin{Syntax}
+\name{factor} \meta{kernel} \{\name{,}\meta{kernel}\}\optional
+\end{Syntax}
+
+\meta{kernel} must be a \nameref{kernel} or a \nameref{list} of
+\name{kernel}s.
+
+\begin{Examples}
+a := (x + y + z)**2;         &
+     A := X^{2} + 2*X*Y + 2*X*Z + Y^{2} + 2*Y*Z + Z^{2} \\
+factor y; \\
+a;                           &
+     Y^{2} + 2*Y*(X + Z) + X^{2} + 2*X*Z + Z^{2} \\
+factor sin(x); \\
+c := df(sin(x)**4*x**2*z,x); &
+     C := 2*SIN(X)^{4}*X*Z + 4*SIN(X)^{3}*COS(X)*X^{2}*Z \\
+remfac sin(x); \\
+c;                           &
+     2*SIN(X)^{3}*X*Z*(2*COS(X)*X + SIN(X))
+\end{Examples}
+
+\begin{Comments}
+Use the \name{factor} declaration to display variables of interest so that
+you can see their powers more clearly, as shown in the example.  Remove
+this special treatment with the declaration \nameref{remfac}.  The
+\name{factor} declaration is only effective when the switch \nameref{pri} 
+is on.
+
+The \name{factor} declaration is not a factoring command; to factor
+expressions use the \nameref{factor} switch or the \nameref{factorize} command.
+
+The \name{factor} declaration is helpful in such cases as Taylor polynomials
+where the explicit powers of the variable are expected at the top level, not
+buried in various factored forms.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{FORALL}
+\index{substitution}
+The \name{forall} or (preferably) \name{for all} command is used as a
+modifier for \nameref{let} statements, indicating the universal applicability
+of the rule, with possible qualifications.
+\begin{Syntax}
+\name{for all} \meta{identifier}\{,\meta{identifier}\}\optional\ \name{let}
+\meta{let statement}
+
+{\em or}
+
+\name{for all} \meta{identifier}\{,\meta{identifier}\}\optional
+\ \name{such that} \meta{condition} \name{let} \meta{let statement}
+\end{Syntax}
+
+
+\meta{identifier} may be any valid REDUCE identifier, \meta{let statement}
+can be an operator, a product or power, or a group or block statement.
+\meta{condition} must be a logical or comparison operator returning true or
+false.
+
+\begin{Examples}
+for all x let f(x) = sin(x**2);
+			     &     Declare F operator ? (Y or N) \\
+y \\
+f(a);                        &     SIN(A^{2}) \\
+operator pos; \\
+for all x such that x>=0 let pos(x) = sqrt(x + 1); \\
+pos(5);                      &     SQRT(6) \\
+pos(-5);                     &     POS(-5) \\
+clear pos; \\
+pos(5);                      &     Declare POS operator ? (Y or N) \\
+for all a such that numberp a let x**a = 1; \\
+x**4;                        &     1 \\
+clear x**a;                  &     *** X**A not found \\
+for all a  clear x**a; \\
+x**4;                        &     1 \\
+for all a such that numberp a clear x**a; \\
+x**4;                        &     X^{4}
+\end{Examples}
+
+\begin{Comments}
+Substitution rules defined by \name{for all} or \name{for
+all}\ldots\name{such that} commands that involve products or powers are
+cleared by reproducing the command, with exactly the same variable names
+used, up to but not including the equal sign, with \nameref{clear}
+replacing \name{let}, as shown in the last example.  Other substitutions
+involving variables or operator names can be cleared with just the name,
+like any other variable.
+
+The \nameref{match} command can also be used in product and power substitutions.
+The syntax of its use and clearing is exactly like \name{let}.  A \name{match}
+substitution only replaces the term if it is exactly like the pattern, for
+example \name{match x**5 = 1} replaces only terms of \name{x**5} and not
+terms of higher powers.
+
+It is easier to declare your potential operator before defining the 
+\name{for all} rule, since the system will ask you to declare it an
+operator anyway.  Names of declared arrays or matrices or scalar
+variables are invalid as operator names, to avoid ambiguity.  Either
+\name{for all}\ldots\name{let} statements or procedures are often used to define
+operators.  One difference is that procedures implement ``call by value"
+meaning that assignments involving their formal parameters do not change
+the calling variables that replace them.  If you use assignment statements
+on the formal parameters in a \name{for all}\ldots\name{let} statement, the
+effects are seen in the calling variables.  Be careful not to redefine a
+system operator unless you mean it: the statement \name{for all x let
+sin(x)=0;} has exactly that effect, and the usual definition for sin(x) has
+been lost for the remainder of the REDUCE session. \end{Comments}
+\end{Command}
+
+\begin{Declaration}{INFIX}
+\index{operator}
+\name{infix} declares identifiers to be infix operators.
+\begin{Syntax}
+\name{infix} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} can be any valid REDUCE identifier, which has not already
+been declared an operator, array or matrix, and is not reserved by the
+system.
+
+\begin{Examples}
+infix aa; \\
+for all x,y let aa(x,y) = cos(x)*cos(y) - sin(x)*sin(y); \\
+x aa y;                      &       COS(X)*COS(Y) - SIN(X)*SIN(Y) \\
+pi/3 aa pi/2;                &        - \rfrac{SQRT(3)}{2} \\
+aa(pi,pi);                   &           1
+\end{Examples}
+
+\begin{Comments}
+A \nameref{let} statement must be used to attach functionality to 
+the operator. Note that the operator is defined in prefix form in 
+the \name{let} statement.
+After its definition, the operator may be used in either prefix or infix
+mode.  The above operator \IFTEX{$aa$}{aa} finds the cosine of the sum 
+of two angles by the formula 
+\begin{TEX}
+\begin{displaymath}
+\cos(x+y) = \cos x \cos y  - \sin x \sin y.
+\end{displaymath}
+\end{TEX}
+\begin{INFO}
+cos(x+y) = cos(x)*cos(y) - sin(x)*sin(y).
+\end{INFO}
+Precedence may be attached to infix operators with the
+\nameref{precedence} declaration.
+
+User-defined infix operators may be used in prefix form.  If they are used
+in infix form, a space must be left on each side of the operator to avoid
+ambiguity.  Infix operators are always binary.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{INTEGER}
+The \name{integer} declaration must be made immediately after a
+\nameref{begin} (or other variable declaration such as \nameref{real}
+and \nameref{scalar}) and declares local integer variables.  They are
+initialized to 0.
+\begin{Syntax}
+\name{integer} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} may be any valid REDUCE identifier, except
+\name{t} or \name{nil}.
+
+\begin{Comments}
+Integer variables remain local, and do not share values with variables of
+the same name outside the \nameref{begin}\ldots\name{end} block.  When the
+block is finished, the variables are removed.  You may use the words
+\nameref{real} or \nameref{scalar} in the place of \name{integer}.
+\name{integer} does not indicate typechecking by the
+current REDUCE; it is only for your own information.  Declaration
+statements must immediately follow the \name{begin}, without a semicolon
+between \name{begin} and the first variable declaration.
+
+Any variables used inside \name{begin}\ldots\name{end} blocks that were not
+declared \name{scalar}, \name{real} or \name{integer} are global, and any
+change made to them inside the block affects their global value.  Any
+\ref{array} or \ref{matrix} declared inside a block is always global.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{KORDER}
+\index{kernel order}\index{variable order}\index{order}
+The \name{korder} declaration changes the internal canonical ordering of
+kernels.
+\begin{Syntax}
+\name{korder} \meta{kernel}\{\name{,}\meta{kernel}\}\optional
+\end{Syntax}
+
+\meta{kernel} must be a REDUCE \nameref{kernel} or a \nameref{list} of
+\name{kernel}s.
+
+\begin{Comments}
+The declaration \name{korder} changes the internal ordering, but not the print
+ordering, so the effects cannot be seen on output.  However, in some 
+calculations, the order of the variables can have significant effects on the 
+time and space demands of a calculation.  If you are doing a demanding 
+calculation with several kernels, you can experiment with changing the 
+canonical ordering to improve behavior.
+
+The first kernel in the argument list is given the highest priority, the
+second gets the next highest, and so on.  Kernels not named in a
+\name{korder} ordering otherwise.  A new \name{korder} declaration replaces 
+the previous one.  To return to canonical ordering, use the command 
+\name{korder nil}.
+
+To change the print ordering, use the declaration \nameref{order}.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{LET}
+\index{substitution}\index{rule}
+The \name{let} command defines general or specific substitution rules.
+\begin{Syntax}
+\name{let} \meta{identifier} \name{=} \meta{expression}\{,\meta{identifier}
+\name{=} \meta{expression}\}\optional
+\end{Syntax}
+
+
+\meta{identifier} can be any valid REDUCE identifier except an array, and in
+some cases can be an expression; \meta{expression} can be any valid REDUCE
+expression.   
+
+\begin{Examples}
+let a = sin(x); \\
+b := a;                      &          B := SIN X; \\
+let c = a;  \\
+exp(a);                      &          E^{SIN(X)} \\
+a := x**2;                   &          A := X^{2} \\
+exp(a);                      &          E^{X^{2}} \\
+exp(b);                      &          E^{SIN(X)} \\
+exp(c);                      &          E^{X^{2}} \\
+let m + n = p; \\
+(m + n)**5;                  &          P^{5} \\
+%%%let z**6 = 0; \\
+%%%z**3*(z + 1)**4;             &          Z^{3}*(6*Z^{2}  + 4*Z + 1) \\
+operator h; \\
+let h(u,v) = u - v; \\
+h(u,v);                      &          U - V \\
+h(x,y);                      &          H(X,Y) \\
+array q(10); \\
+let q(1) = 15;               &   ***** Substitution for 0 not allowed
+\end{Examples}
+
+The \name{let} command is also used to activate a \name{rule sets}.
+\begin{Syntax}
+\name{let} \meta{list}\{,\meta{list}\}\repeated
+\end{Syntax}
+
+\meta{list} can be an explicit \nameref{rule} \name{list}, or evaluate 
+to a rule list.
+
+\begin{Examples}
+trig1 := {cos(~x)*cos(~y) => (cos(x+y)+cos(x-y))/2,
+	  cos(~x)*sin(~y) => (sin(x+y)-sin(x-y))/2,
+	  sin(~x)*sin(~y) => (cos(x-y)-cos(x+y))/2,
+	  cos(~x)^2       => (1+cos(2*x))/2,
+	  sin(~x)^2       => (1-cos(2*x))/2}$ \\
+let trig1;
+cos(a)*cos(b); &
+\rfrac{COS(A - B) + COS(A + B)}{2}
+\end{Examples}
+
+\begin{Comments}
+A \name{let} command returns no value, though the substitution rule is
+entered.  Assignment rules made by \nameref{assign} and \name{let} 
+rules are at the
+same level, and cancel each other.  There is a difference in their
+operation, however, as shown in the first example:  a \name{let} assignment
+tracks the changes in what it is assigned to, while a \name{:=} assignment
+is fixed at the value it originally had.  
+
+The use of expressions as left-hand sides of \name{let} statements is a 
+little complicated.  The rules of operation are:
+\begin{itemize}
+
+\item[(i)]
+Expressions of the form A*B = C do not change A, B or C, but set A*B to C.
+
+\item[(ii)]
+Expressions of the form A+B = C substitute C - B for A, but do not change
+B or C.
+
+\item[(iii)]
+Expressions of the form A-B = C substitute B + C for A, but do not change
+B or C.
+
+\item[(iv)]
+Expressions of the form A/B = C substitute B*C for A, but do not change B or
+C.
+
+\item[(v)]
+Expressions of the form A**N = C substitute C for A**N in every expression of
+a power of A to N or greater.  An asymptotic command such as A**N = 0 sets
+all terms involving A to powers greater than or equal to N to 0.  Finite
+fields may be generated by requiring modular arithmetic (the \nameref{modular}
+switch) and defining the primitive polynomial via a \name{let} statement.
+
+\end{itemize}
+\name{let} substitutions involving expressions are cleared by using
+the \nameref{clear} command with exactly the same expression.
+
+Note when a simple \name{let} statement is used to assign functionality to an
+operator, it is valid only for the exact identifiers used.  For the use of the 
+\name{let} command to attach more general functionality to an operator,
+see \nameref{forall}.
+
+Arrays as a whole cannot be arguments to \name{let} statements, but
+matrices as a whole can be legal arguments, provided both arguments are
+matrices.  However, it is important to note that the two matrices are then
+linked.  Any change to an element of one matrix changes the corresponding
+value in the other.  Unless you want this behavior, you should not use
+\name{let} for matrices.  The assignment operator \nameref{assign} can be used
+for non-tracking assignments, avoiding the side effects.  Matrices are
+redimensioned as needed in \name{let} statements.
+
+When array or matrix elements are used as the left-hand side of \name{let}
+statements, the contents of that element is used as the argument.  When the 
+contents is a number or some other expression that is not a valid left-hand 
+side for \name{let}, you get an error message.  If the contents is an
+identifier or simple expression, the \name{let} rule is globally attached 
+to that identifier, and is in effect not only inside the array or matrix, 
+but everywhere.  Because of such unwanted side effects, you should not 
+use \name{let} with array or matrix elements.  The assignment operator 
+\name{:=} can be used to put values into array or matrix elements without 
+the side effects.
+
+Local variables declared inside \name{begin}\ldots\name{end} blocks cannot
+be used as the left-hand side of \name{let} statements.  However,
+\nameref{begin}\ldots\name{end} blocks themselves can be used as the
+right-hand side of \name{let} statements.  The construction:
+\begin{Syntax}
+        \name{for all} \meta{vars}
+        \name{let}\meta{operator}\(\meta{vars}\)\name{=}\meta{block}
+\end{Syntax}
+is an alternative to the 
+\begin{Syntax}
+        \name{procedure} \meta{name}\(\meta{vars}\)\name{;}\meta{block}
+\end{Syntax}
+construction.  One important difference between the two constructions is that
+the \meta{vars} as formal parameters to a procedure have their global values
+protected against change by the procedure, while the \meta{vars} of a 
+\name{let} statement are changed globally by its actions. 
+
+Be careful in using a construction such as \name{let x = x + 1} except inside
+a controlled loop statement.  The process of resubstitution continues until 
+a stack overflow message is given.  
+
+The \name{let} statement may be used to make global changes to variables from
+inside procedures.  If \name{x} is a formal parameter to a procedure, the 
+command \name{let x = }\ldots makes the change to the calling variable.  
+For example, if a procedure was defined by 
+\begin{verbatim}
+        procedure f(x,y);
+        let x = 15;
+\end{verbatim}
+and the procedure was called as
+\begin{verbatim}
+        f(a,b);
+\end{verbatim}
+\name{a} would have its value changed to 15.  Be careful when using \name{let}
+statements inside procedures to avoid unwanted side effects.
+
+It is also important to be careful when replacing \name{let} statements with
+other \name{let} statements.  The overlapping of these substitutions can be
+unpredictable.  Ordinarily the latest-entered rule is the first to be applied.
+Sometimes the previous rule is superseded completely; other times it stays
+around as a special case.  The order of entering a set of related \name{let}
+expressions is very important to their eventual behavior.  The best
+approach is to assume that the rules will be applied in an arbitrary order.
+%%%Be sure to research this subject carefully when you are programming
+%%%mathematical operations using related \name{let} substitutions.
+\end{Comments}
+\end{Command}
+
+
+\begin{Declaration}{LINEAR}
+\index{operator}
+An operator can be declared linear in its first argument over powers of
+its second argument by the declaration \name{linear.}
+\begin{Syntax}
+ \name{linear} \meta{operator}\{\name{,}\meta{operator}\}\optional
+\end{Syntax}
+\meta{operator} must have been declared to be an operator.  Be careful not
+to use a system operator name, because this command may change its definition.
+The operator being declared must have at least two arguments, and the
+second one must be a \nameref{kernel}.
+
+\begin{Examples}
+operator f; \\
+linear f; \\
+f(0,x);                      &        0 \\
+f(-y,x);                     &        - F(1,X)*Y \\
+f(y+z,x);                    &        F(1,X)*(Y + Z) \\
+f(y*z,x);                    &        F(1,X)*Y*Z \\
+depend z,x; \\
+f(y*z,x);                    &        F(Z,X)*Y \\
+f(y/z,x);                    &        F(\rfrac{1}{Z},X)*Y \\
+depend y,x;  \\
+f(y/z,x);                    &        F(\rfrac{Y}{Z},X) \\
+nodepend z,x; \\
+f(y/z,x);                    &        \rfrac{F(Y,X)}{Z} \\
+f(2*e**sin(x),x);            &        2*F(E^{SIN(X)},X)
+\end{Examples}
+
+\begin{Comments}
+Even when the operator has not had its functionality attached, it exhibits
+linear properties as shown in the examples.  Notice the difference when
+dependencies are added.  Dependencies are also in effect when the operator's
+first argument contains its second, as in the last line above.
+
+For a fully-developed example of the use of linear operators, refer to the
+article in the \meta{Journal of Computational Physics}, Vol. 14 (1974), pp.
+301-317, ``Analytic Computation of Some Integrals in Fourth Order Quantum
+Electrodynamics," by J.A. Fox and A.C. Hearn.  The article includes the
+complete listing of REDUCE procedures used for this work.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{LINELENGTH}
+\index{output}
+The \name{linelength} declaration sets the length of the output line. Default
+is 80.
+\begin{Syntax}
+\name{linelength} \meta{expression}
+\end{Syntax}
+
+To change the linelength,
+\meta{expression} must evaluate to a positive integer less than 128
+(although this varies from system to system), and should not be less than
+20 or so for proper operation.
+
+\begin{Comments}
+% If you want to use a thin window to set beside another window,
+% reset the linelength shorter to avoid problems with raised exponents.
+\name{linelength} returns the previous linelength.  If you want the current
+linelength value, but not change it, say \name{linelength nil}.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{LISP}
+The \name{lisp} command changes REDUCE's mode of operation to symbolic.  When
+\name{lisp} is followed by an expression, that expression is evaluated in
+symbolic mode, but REDUCE's mode is not changed.  This command is
+equivalent to \nameref{symbolic}.
+
+\begin{Examples}
+lisp;                       &            NIL \\
+car '(a b c d e);           &            A  \\
+algebraic; \\
+c := (lisp car '(first second))**2; \\
+			    &           C := FIRST^{2}
+
+\end{Examples}
+
+\end{Command}
+
+
+\begin{Declaration}{LISTARGP}
+\index{list}\index{argument}
+\begin{Syntax}
+\name{listargp} \meta{operator}\{\name{,}\meta{operator}\}\optional
+\end{Syntax}
+If an operator other than those specifically defined for lists is given a
+single argument that is a \nameref{list}, then the result of this 
+operation will be a list in which that operator is applied to each element 
+of the list.
+This process can be inhibited for a specific operator, or list of operators,
+by using the declaration \name{listargp}.
+
+\begin{Examples}
+log {a,b,c}; & {LOG(A),LOG(B),LOG(C)} \\
+listargp log; \\
+log {a,b,c}; & LOG({A,B,C})
+\end{Examples}
+
+\begin{Comments}
+It is possible to inhibit such distribution globally by turning on the
+switch \nameref{listargs}.  In addition, if an operator has more than one
+argument, no such distribution occurs, so \name{listargp} has no effect.
+\end{Comments}
+
+\end{Declaration}
+
+
+\begin{Declaration}{NODEPEND}
+\index{depend}
+The \name{nodepend} declaration removes the dependency declared with
+\nameref{depend}.
+\begin{Syntax}
+\name{nodepend} \meta{dep-kernel}\{,\meta{kernel}\}\repeated
+
+\end{Syntax}
+
+
+\meta{dep-kernel} must be a kernel that has had a dependency declared upon the 
+one or more other kernels that are its other arguments.  
+
+\begin{Examples}
+depend y,x,z; \\
+df(sin y,x);                 &        COS(Y)*DF(Y,X) \\
+df(sin y,x,z);               &  COS(Y)*DF(Y,X,Z) - DF(Y,X)*DF(Y,Z)*SIN(Y) \\
+nodepend y,z; \\
+df(sin y,x);                 &        COS(Y)*DF(Y,X) \\
+df(sin y,x,z);               &        0
+\end{Examples}
+
+\begin{Comments}
+A warning message is printed if the dependency had not been declared by
+\name{depend}.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{MATCH}
+\index{substitution}
+The \name{match} command is similar to the \nameref{let} command, except
+that it matches only explicit powers in substitution.
+\begin{Syntax}
+\name{match} \meta{expr} \name{=} \meta{expression}\{,\meta{expr}
+ \name{=}\meta{expression}\}\optional
+\end{Syntax}
+
+\meta{expr} is generally a term involving powers, and is limited by
+the rules for the \nameref{let} command.  \meta{expression} may be
+any valid REDUCE scalar expression.
+
+
+\begin{Examples}
+match c**2*a**2 = d;
+(a+c)**4;                    &      
+            A^{4}  + 4*A^{3}*C + 4*A*C^{3} + C^{4} + 6*D \\
+match a+b = c; \\
+a + 2*b;                     &       B + C \\
+(a + b + c)**2;              &       
+            A^{2}  - B^{2}  + 2*B*C + 3*C^{2} \\
+clear a+b; \\
+(a + b + c)**2;              &       
+            A ^{2} + 2*A*B + 2*A*C + B^{2} + 2*B*C + C^{2} \\
+let p*r = s; \\
+match p*q = ss; \\
+(a + p*r)**2;                &       A^{2} + 2*A*S + S^{2} \\
+(a + p*q)**2;                &       A^{2}  + 2*A*SS + P^{2}*Q^{2}
+\end{Examples}
+
+\begin{Comments}
+Note in the last example that \name{a + b} has been explicitly matched
+after the squaring was done, replacing each single power of \name{a} by
+\name{c - b}.  This kind of substitution, although following the rules, is
+confusing and could lead to unrecognizable results.  It is better to use
+\name{match} with explicit powers or products only.  \name{match} should
+not be used inside procedures for the same reasons that \name{let} should
+not be.
+
+Unlike \nameref{let} substitutions, \name{match} substitutions are executed
+after all other operations are complete.  The last example shows the
+difference. \name{match} commands can be cleared by using \nameref{clear},
+with exactly the expression that the original \name{match} took.
+\name{match} commands can also be done more generally with \name{for all}
+or \nameref{forall}\ldots\name{such that} commands.
+\end{Comments}
+\end{Command}
+
+
+\begin{Declaration}{NONCOM}
+\index{commutative}\index{non commutative}\index{operator}
+\name{noncom} declares that already-declared operators are noncommutative
+under multiplication.
+\begin{Syntax}
+\name{noncom} \meta{operator}\{,\meta{operator}\}\optional
+\end{Syntax}
+
+\meta{operator} must have been declared an \nameref{operator}, or a warning
+message is given.
+
+\begin{Examples}
+operator f,h; \\
+noncom f; \\
+f(a)*f(b) - f(b)*f(a);       &         F(A)*F(B) - F(B)*F(A) \\
+h(a)*h(b) - h(b)*h(a);       &         0 \\
+operator comm; \\
+\begin{multilineinput}
+for all x,y such that x neq y and ordp(x,y)
+        let f(x)*f(y) = f(y)*f(x) + comm(x,y);
+\end{multilineinput}\\
+f(1)*f(2);                   &         F(1)*F(2) \\
+f(2)*f(1);                   &         COMM(2,1) + F(1)*F(2)
+\end{Examples}
+
+\begin{Comments}
+The last example introduces the commutator of $f(x)$ and $f(y)$
+for all x and y.  The equality check is to prevent an infinite loop.  The 
+operator {\it f} can have other functionality attached to it if desired, or it 
+can remain an indeterminate operator.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{NONZERO}
+\index{operator}
+\begin{Syntax}
+\name{nonzero} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+If an \ref{operator} \name{f} is declared \nameref{odd}, then \name{f(0)}
+is replaced by zero unless \name{f} is also declared {\em non zero} by the
+declaration \name{nonzero}.
+\begin{Examples}
+	odd f; \\
+	f(0)    &   0 \\
+	nonzero f; \\
+	f(0) &   F(0)
+\end{Examples}
+\end{Declaration}
+
+
+\begin{Declaration}{ODD}
+\index{operator}
+
+\begin{Syntax}
+\name{odd} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+This declaration is used to declare an operator {\em odd} in its first
+argument.  Expressions involving an operator declared in this manner are
+transformed if the first argument contains a minus sign.  Any other
+arguments are not affected.
+\begin{Examples}
+	odd f; \\
+	f(-a)    &   -F(A) \\
+	f(-a,-b) &   -F(A,-B) \\
+	f(a,-b)  &    F(A,-B)
+\end{Examples}
+
+\begin{Comments}
+
+If say \name{f} is declared odd, then \name{f(0)} is replaced by zero
+unless \name{f} is also declared {\em non zero} by the declaration
+\nameref{nonzero}.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{OFF}
+\index{switch}
+The \name{off} command is used to turn switches off.
+\begin{Syntax}
+\name{off} \meta{switch}\{,\meta{switch}\}\optional
+\end{Syntax}
+
+\meta{switch} can be any \name{switch} name.  There is no problem if the
+switch is already off.  If the switch name is mistyped, an error message is
+given.
+\end{Command}
+
+
+\begin{Command}{ON}
+\index{switch}
+The \name{on} command is used to turn switches on.
+\begin{Syntax}
+\name{on} \meta{switch}\{,\meta{switch}\}\optional
+\end{Syntax}
+
+\meta{switch} can be any \name{switch} name.  There is no problem if the
+switch is already on.  If the switch name is mistyped, an error message is
+given.
+\end{Command}
+
+
+\begin{Declaration}{OPERATOR}
+Use the \name{operator} declaration to declare your own operators.
+\begin{Syntax}
+\name{operator} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} can be any valid REDUCE identifier, which is not the name
+of a \nameref{matrix}, \nameref{array}, scalar variable or previously-defined
+operator.  
+
+\begin{Examples}
+operator dis,fac; \\
+let dis(~x,~y) = sqrt(x^2 + y^2); \\
+dis(1,2);                   &       SQRT(5) \\
+dis(a,10);                  &       SQRT(A^{2} + 100) \\
+on rounded; \\
+dis(1.5,7.2);               &       7.35459040329\\
+\begin{multilineinput}
+let fac(~n) = if n=0 then 1
+               else if not(fixp n and n>0)
+                then rederr "choose non-negative integer"
+               else for i := 1:n product i;
+\end{multilineinput} \\
+fac(5);                     &      120 \\
+fac(-2);                    &      ***** choose non-negative integer
+\end{Examples}
+ 
+\begin{Comments}
+The first operator is the Euclidean distance metric, the distance of point
+$(x,y)$ from the origin.  The second operator is the factorial.
+
+Operators can have various properties assigned to them; they can be
+declared \nameref{infix}, \nameref{linear}, \nameref{symmetric}, 
+\nameref{antisymmetric}, or \nameref{noncom}\name{mutative}.
+The default operator is prefix, nonlinear, and commutative.
+Precedence can also be assigned to operators using the declaration
+\nameref{precedence}.
+
+Functionality is assigned to an operator by a \nameref{let} statement or
+a \nameref{forall}\ldots\name{let} statement, 
+(or possibly by a procedure with the name
+of the operator). Be careful not to redefine a system operator by
+accident. REDUCE permits you to redefine system operators, giving you a 
+warning message that the operator was already defined.  This flexibility 
+allows you to add mathematical rules that do what you want them to do, but 
+can produce odd or erroneous behavior if you are not careful. 
+
+You can declare operators from inside \nameref{procedure}s, as long as they 
+are not local variables.  Operators defined inside procedures are global. 
+A formal parameter may be declared as an operator, and has the effect of 
+declaring the calling variable as the operator.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{ORDER}
+\index{order}\index{variable order}\index{output}
+The \name{order} declaration changes the order of precedence of kernels for
+display purposes only.
+\begin{Syntax}
+\name{order} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+\meta{kernel} must be a valid \nameref{kernel} or \nameref{operator} name
+complete with argument or a \nameref{list} of such objects.
+
+\begin{Examples}
+x + y + z + cos(a);         &         COS(A) + X + Y + Z \\
+order z,y,x,cos(a); \\
+x + y + z + cos(a);         &         Z + Y + X + COS(A) \\
+(x + y)**2;                 &         Y^{2} + 2*Y*X + X^{2} \\
+order nil; \\
+(z + cos(z))**2;            &         COS(Z)^{2} + 2*COS(Z)*Z + Z^{2}
+\end{Examples}
+
+\begin{Comments}
+\name{order} affects the printing order of the identifiers only; internal
+order is unchanged.  Change internal order of evaluation with the
+declaration \nameref{korder}.  You can use \name{order} to feature variables
+or functions you are particularly interested in.
+
+Declarations made with \name{order} are cumulative:  kernels in new order
+declarations are ordered behind those in previous declarations, and
+previous declarations retain their relative order.  Of course, specific
+kernels named in new declarations are removed from previous ones and given
+the new priority.  Return to the standard canonical printing order with the 
+statement \name{order nil}.
+
+The print order specified by \name{order} commands is not in effect if the
+switch \nameref{pri} is off.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{PRECEDENCE}
+\index{operator}
+The \name{precedence} declaration attaches a precedence to an infix operator.
+\begin{Syntax}
+\name{precedence} \meta{operator},\meta{known\_operator}
+\end{Syntax}
+
+\meta{operator} should have been declared an operator but may be a REDUCE
+identifier that is not already an operator, array, or matrix.
+\meta{known\_operator} must be a system infix operator or have had its
+precedence already declared.
+
+\begin{Examples}
+operator f,h; \\
+precedence f,+; \\
+precedence h,*;  \\
+a + f(1,2)*c;                &         (1 F 2)*C + A \\
+a + h(1,2)*c;                &         1 H 2*C + A \\
+a*1 f 2*c;                   &         A F 2*C \\
+a*1 h 2*c;                   &         1 H 2*A*C
+%%%symbolic;                    &         NIL \\
+%%%preclis!*;                  &
+%%%   (IREM IEQUAL OVER ADD MULT TO OR AND NOT MEMBER MEMQ EQUAL NEQ EQ GEQ
+%%%   GREATERP IGREATERP LEQ LESSP ILESSP FREEOF PLUS F IPLUS DIFFERENCE
+%%%   IDIFFERENCE TIMES H ITIMES QUOTIENT IQUOTIENT EXPT CONS)
+\end{Examples}
+
+\begin{Comments}
+The operator whose precedence is being declared is inserted into the infix
+operator precedence list at the next higher place than \meta{known\_operator}.
+
+Attaching a precedence to an operator has the side effect of declaring the
+operator to be infix.  If the identifier argument for \name{precedence} has
+not been declared to be an operator, an attempt to use it causes an error
+message.  After declaring it to be an operator, it becomes an infix operator
+with the precedence previously given.  Infix operators may be used in prefix
+form; if they are used in infix form, a space must be left on each side of
+the operator to avoid ambiguity.  Declared infix operators are always binary.
+
+To see the infix operator precedence list, enter symbolic mode and type
+\name{preclis!*;}.  The lowest precedence operator is listed first.
+
+All prefix operators have precedence higher than infix operators.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{PRECISION}
+\index{rounded}\index{floating point}
+The \name{precision} declaration sets the number of decimal places used when
+\nameref{rounded} is on.  Default is system dependent, and normally about 12.
+\begin{Syntax}
+\name{precision}(\meta{integer}) or \name{precision} \meta{integer}
+\end{Syntax}
+
+\meta{integer} must be a positive integer.  When \meta{integer} is 0, the
+current precision is displayed, but not changed.  There is no upper limit,
+but precision of greater than several hundred causes unpleasantly slow
+operation on numeric calculations.
+
+\begin{Examples}
+on rounded; \\
+7/9;                         &       0.777777777778 \\
+precision 20;                &       20 \\
+7/9;                         &       0.77777777777777777778 \\
+sin(pi/4);                   &       0.7071067811865475244
+\end{Examples}
+
+\begin{Comments}
+Trailing zeroes are dropped, so sometimes fewer than 20 decimal places are
+printed as in the last example.  Turn on the switch \nameref{fullprec} if
+you want to print all significant digits.  The \nameref{rounded} mode
+carries calculations to two more places than given by \name{precision}, and
+rounds off.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{PRINT\_PRECISION}
+\index{output}\index{floating point}\index{rounded}
+
+\begin{Syntax}
+\name{print\_precision}(\meta{integer})
+   or \name{print\_precision} \meta{integer}
+\end{Syntax}
+
+In \nameref{rounded} mode, numbers are normally printed to the specified
+precision.  If the user wishes to print such numbers with less precision,
+the printing precision can be set by the declaration \name{print\_precision}.
+
+\begin{Examples}
+on rounded; \\
+1/3; & 0.333333333333 \\
+print_precision 5; \\
+1/3 & 0.33333
+\end{Examples}
+\end{Declaration}
+
+
+\begin{Declaration}{REAL}
+The \name{real} declaration must be made immediately after a
+\nameref{begin} (or other variable declaration such as \nameref{integer}
+and \nameref{scalar}) and declares local integer variables.  They are
+initialized to zero.
+\begin{Syntax}
+\name{real} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} may be any valid REDUCE identifier, except
+\name{t} or \name{nil}.
+
+\begin{Comments}
+Real variables remain local, and do not share values with variables of the
+same name outside the \nameref{begin}\ldots\name{end} block.  When the
+block is finished, the variables are removed.  You may use the words
+\nameref{integer} or \nameref{scalar} in the place of \name{real}.
+\name{real} does not indicate typechecking by the current REDUCE; it is
+only for your own information.  Declaration statements must immediately
+follow the \name{begin}, without a semicolon between \name{begin} and the
+first variable declaration.
+
+Any variables used inside a \name{begin}\ldots\name{end} \nameref{block}
+that were not declared \name{scalar}, \name{real} or \name{integer} are
+global, and any change made to them inside the block affects their global
+value.  Any \ref{array} or \ref{matrix} declared inside a block is always
+global.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{REMFAC}
+\index{factor}\index{output}
+The \name{remfac} declaration removes the special factoring treatment of its
+arguments that was declared with \nameref{factor}.
+\begin{Syntax}
+\name{remfac} \meta{kernel}\{,\meta{kernel}\}\repeated
+\end{Syntax}
+
+\meta{kernel} must be a \nameref{kernel} or \nameref{operator} name that
+was declared as special with the \nameref{factor} declaration.
+\end{Declaration}
+
+
+\begin{Declaration}{SCALAR}
+The \name{scalar} declaration must be made immediately after a
+\nameref{begin} (or other variable declaration such as \nameref{integer}
+and \nameref{real}) and declares local scalar variables.  They are
+initialized to 0.
+\begin{Syntax}
+\name{scalar} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} may be any valid REDUCE identifier, except \name{t} or
+\name{nil}.
+
+\begin{Comments}
+Scalar variables remain local, and do not share values with variables of
+the same name outside the \nameref{begin}\ldots\name{end} \nameref{block}.
+When the block is finished, the variables are removed.  You may use the
+words \nameref{real} or \nameref{integer} in the place of \name{scalar}.
+\name{real} and \name{integer} do not indicate typechecking by the current
+REDUCE; they are only for your own information.  Declaration statements
+must immediately follow the \name{begin}, without a semicolon between
+\name{begin} and the first variable declaration.
+
+Any variables used inside \name{begin}\ldots\name{end} blocks that were not
+declared \name{scalar}, \name{real} or \name{integer} are global, and any
+change made to them inside the block affects their global value.  Arrays
+declared inside a block are always global.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{SCIENTIFIC\_NOTATION}
+\index{output}\index{floating point}\index{rounded}
+\begin{Syntax}
+\name{scientific\_notation}(\meta{m}) or
+\name{scientific\_notation}(\{\meta{m},\meta{n}\})
+\end{Syntax}
+
+\meta{m} and \meta{n} are positive integers.
+\name{scientific\_notation} controls the output format of floating point
+numbers.  At the default settings, any number with five or less digits
+before the decimal point is printed in a fixed-point notation, e.g., 
+{\tt 12345.6}.  Numbers with more than five digits are printed in scientific
+notation, e.g., {\tt 1.234567E+5}.  Similarly, by default, any number with
+eleven or more zeros after the decimal point is printed in scientific
+notation.
+
+When \name{scientific\_notation} is called with the numerical argument
+{\em m} a number with more than {\em m} digits before the decimal point,
+or {\em m} or more zeros after the decimal point, is printed in scientific
+notation.  When \name{scientific\_notation} is called with a list
+\{\meta{m},\meta{n}\}, a number with more than {\em m} digits before the
+decimal point, or {\em n} or more zeros after the decimal point is
+printed in scientific notation.
+
+\begin{Examples}
+
+on rounded;\\
+
+12345.6;&
+
+12345.6\\
+
+123456.5;&1.234565e+5\\
+
+0.00000000000000012;&
+
+1.2e-16\\
+
+scientific_notation 20;&
+
+{5,11}\\
+
+5: 123456.7;&
+
+123456.7\\
+
+0.00000000000000012;&
+
+0.00000000000000012\\
+
+\end{Examples}
+\end{Declaration}
+
+
+\begin{Declaration}{SHARE}
+The \name{share} declaration allows access to its arguments by both
+algebraic and symbolic modes.
+\begin{Syntax}
+\name{share} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} can be any valid REDUCE identifier.
+
+\begin{Comments}
+Programming in \nameref{symbolic} as well as algebraic mode allows 
+you a wider range
+of techniques than just algebraic mode alone.  Expressions do not cross the
+boundary since they have different representations, unless the \name{share}
+declaration is used.  For more information on using symbolic mode, see
+the \meta{REDUCE User's Manual}, and the \meta{Standard Lisp Report}.
+
+You should be aware that a previously-declared array is destroyed by the
+\name{share} declaration.  Scalar variables retain their values.  You can
+share a declared \nameref{matrix} that has not yet 
+been dimensioned so that it can be
+used by both modes.  Values that are later put into the matrix are
+accessible from symbolic mode too, but not by the usual matrix reference
+mechanism.  In symbolic mode, a matrix is stored as a list whose first
+element is \nameref{MAT}, and whose next elements are the rows of the matrix
+stored as lists of the individual elements.  Access in symbolic mode is by
+the operators \nameref{first}, \nameref{second}, \nameref{third} and
+\nameref{rest}.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{SYMBOLIC}
+The \name{symbolic} command changes REDUCE's mode of operation to symbolic.
+When \name{symbolic} is followed by an expression, that expression is
+evaluated in symbolic mode, but REDUCE's mode is not changed.  It is
+equivalent to the \nameref{lisp} command.
+
+\begin{Examples}
+symbolic;                    &       NIL \\
+cdr '(a b c);                &       (B C) \\
+algebraic; \\
+x + symbolic car '(y z);     &       X + Y
+\end{Examples}
+% \begin{Comments}
+% You can tell when you are in symbolic mode by noting that the numbered
+% prompt contains an asterisk (\name{*}) rather than a colon.
+% \end{Comments}
+\end{Command}
+
+
+\begin{Declaration}{SYMMETRIC}
+\index{operator}
+When an operator is declared \name{symmetric}, its arguments are reordered
+to conform to the internal ordering of the system.  
+\begin{Syntax}
+\name{symmetric} \meta{identifier}\{,\meta{identifier}\}\optional
+\end{Syntax}
+
+\meta{identifier} is an identifier that has been declared an operator.
+
+\begin{Examples}
+operator m,n; \\
+symmetric m,n; \\
+m(y,a,sin(x));               &           M(SIN(X),A,Y) \\
+n(z,m(b,a,q));               &           N(M(A,B,Q),Z)
+\end{Examples}
+
+\begin{Comments}
+If \meta{identifier} has not been declared to be an operator, the flag
+\name{symmetric} is still attached to it.  When \meta{identifier} is
+subsequently used as an operator, the message \name{Declare}\meta{identifier}
+ \name{operator ? (Y or N)} is printed.  If the user replies \name{y}, the
+symmetric property of the operator is used.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{TR}
+\index{trace}
+The \name{tr} declaration is used to trace system or user-written procedures.
+It is only useful to those with a good knowledge of both Lisp and the
+internal formats used by REDUCE.
+
+\begin{Syntax}
+\name{tr} \meta{name}\{,\meta{name}\}\optional
+\end{Syntax}
+
+\meta{name} is the name of a REDUCE system procedure or one of your own
+procedures.
+
+\begin{Examples}
+\explanation{The system procedure \name{prepsq} is traced,
+	     which prepares REDUCE standard
+forms for printing by converting them to a Lisp prefix form.} \\
+tr prepsq;               &      (PREPSQ) \\
+x**2 + y;                &
+\begin{multilineoutput}{6cm}
+PREPSQ entry:
+  Arg 1: (((((X . 2) . 1) ((Y . 1) . 1)) . 1)
+PREPSQ return value = (PLUS (EXPT X 2) Y)
+PREPSQ entry:
+  Arg 1: (1 . 1)
+PREPSQ return value = 1
+X^{2} + Y
+\end{multilineoutput}\\
+untr prepsq;             &       (PREPSQ)
+\end{Examples}
+
+\begin{Comments}
+This example is for a PSL-based system; the above format will vary if
+other Lisp systems are used.
+
+When a procedure is traced, the first lines show entry to the procedure and
+the arguments it is given.  The value returned by the procedure is printed
+upon exit.  If you are tracing several procedures, with a call to one of
+them inside the other, the inner trace will be indented showing procedure
+nesting.  There are no trace options. However, the format of the trace
+depends on the underlying Lisp system used.  The trace can be removed with
+the command \nameref{untr}.  Note that \name{trace}, below, is a matrix
+operator, while \name{tr} does procedure tracing.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Declaration}{UNTR}
+\index{trace}
+The \name{untr} declaration is used to remove a trace from system or
+user-written procedures declared with \nameref{tr}.  It is only useful to
+those with a good knowledge of both Lisp and the internal formats used by
+REDUCE.
+
+\begin{Syntax}
+\name{untr} \meta{name}\{,\meta{name}\}\optional
+\end{Syntax}
+
+\meta{name} is the name of a REDUCE system procedure or one of your own
+procedures that has previously been the argument of a \name{tr}
+declaration.
+\end{Declaration}
+
+
+\begin{Declaration}{VARNAME}
+The declaration \name{varname} instructs REDUCE to use its argument as the
+default Fortran (when \nameref{fort} is on) or \nameref{structr} identifier
+and identifier stem, rather than using \name{ANS}.
+\begin{Syntax}
+\name{varname} \meta{identifier}
+\end{Syntax}
+
+\meta{identifier} can be any combination of one or more alphanumeric
+characters.  Try to avoid REDUCE reserved words.
+
+\begin{Examples}
+varname ident;               &         IDENT \\
+on fort; \\
+x**2 + 1;                    &         IDENT=X**2+1. \\
+off fort,exp; \\
+structr(((x+y)**2 + z)**3);  &\begin{multilineoutput}{6cm}
+IDENT2^{3}
+    where
+       IDENT2 := IDENT1^{2} + Z
+IDENT1 := X + Y
+\end{multilineoutput}
+\end{Examples}
+\begin{Comments}
+\nameref{exp} was turned off so that \nameref{structr} could show the
+structure.  If \name{exp} had been on, the expression would have been
+expanded into a polynomial.
+\end{Comments}
+\end{Declaration}
+
+
+\begin{Command}{WEIGHT}
+The \name{weight} command is used to attach weights to kernels for asymptotic
+constraints.
+\begin{Syntax}
+\name{weight} \meta{kernel} \name{=}\meta{number}
+\end{Syntax}
+
+\meta{kernel} must be a REDUCE \nameref{kernel}, \meta{number} must be a
+positive integer, not 0.
+
+\begin{Examples}
+a := (x+y)**4;               & 
+     A := X^{4} + 4*X^{3}*Y + 6*X^{2}*Y^{2} + 4*X*Y^{3} + Y^{4} \\
+weight x=2,y=3; \\
+wtlevel 8; \\
+a;                           &     X^{4} \\
+wtlevel 10; \\
+a;                           &      X^{2}*(6*Y^{2} + 4*X*Y  + X^{2}) \\
+int(x**2,x);                 &     ***** X invalid as KERNEL
+\end{Examples}
+\begin{Comments}
+Weights and \nameref{wtlevel} are used for asymptotic constraints, where
+higher-order terms are considered insignificant.  
+
+Weights are originally equivalent to 0 until set by a \name{weight}
+command.  To remove a weight from a kernel, use the \nameref{clear}
+command.  Weights once assigned cannot be changed without clearing the
+identifier.  Once a weight is assigned to a kernel, it is no longer a
+kernel and cannot be used in any REDUCE commands or operators that require
+kernels, until the weight is cleared.  Note that terms are ordered by
+greatest weight.
+
+The weight level of the system is set by \nameref{wtlevel}, initially at
+2.  Since no kernels have weights, no effect from \name{wtlevel} can be
+seen.  Once you assign weights to kernels, you must set \name{wtlevel}
+correctly for the desired operation.  When weighted variables appear in a
+term, their weights are summed for the total weight of the term (powers of
+variables multiply their weights).  When a term exceeds the weight level
+of the system, it is discarded from the result expression.
+\end{Comments}
+\end{Command}
+
+
+\begin{Operator}{WHERE}
+\index{substitution}
+The \name{where} operator provides an infix notation for one-time
+substitutions for kernels in expressions.
+\begin{Syntax}
+\meta{expression} \name{where} \meta{kernel} 
+       \name{=}\meta{expression}\
+	 \{,\meta{kernel} \name{=}\meta{expression}\}\optional
+\end{Syntax}
+
+\meta{expression} can be any REDUCE scalar expression, \meta{kernel} must
+be a \nameref{kernel}. Alternatively a \nameref{rule} or a \name{rule list}
+can be a member of the right-hand part of a \name{where} expression. 
+
+\begin{Examples}
+x**2 + 17*x*y + 4*y**2 where x=1,y=2;          &      51 \\
+for i := 1:5 collect x**i*q where q= for j := 1:i product j;
+			     & \{X,2*X^{2},6*X^{3},24*X^{4},120*X^{5}\} \\
+x**2 + y + z where z=y**3,y=3;                 &      X^{2} + Y^{3} + 3
+\end{Examples}
+
+\begin{Comments}
+Substitution inside a \name{where} expression has no effect upon the values
+of the kernels outside the expression.  The \name{where} operator has the
+lowest precedence of all the infix operators, which are lower than prefix
+operators, so that the substitutions apply to the entire expression
+preceding the \name{where} operator.  However, \name{where} is applied
+before command keywords such as \name{then}, \name{repeat}, or \name{do}.
+
+A \nameref{rule} or a \name{rule set} in the right-hand part of the
+\name{where} expression act as if the rules were activated by \nameref{let}
+immediately before the evaluation of the expression and deactivated
+by \nameref{clearrules} immediately afterwards.
+
+\name{where} gives you a natural notation for auxiliary variables in
+expressions.  As the second example shows, the substitute expression can be
+a command to be evaluated.  The substitute assignments are made in
+parallel, rather than sequentially, as the last example shows.   The
+expression resulting from the first round of substitutions is not
+reexamined to see if any further such substitutions can be made.
+\name{where} can also be used to define auxiliary variables in
+\nameref{procedure} definitions.
+\end{Comments}
+\end{Operator}
+
+
+\begin{Command}{WHILE}
+\index{loop}
+The \name{while} command causes a statement to be repeatedly executed until a
+given condition is true.  If the condition is initially false, the statement
+is not executed at all.
+\begin{Syntax}
+\name{while} \meta{condition} \name{do} \meta{statement}
+\end{Syntax}
+
+\meta{condition} is given by a logical operator, \meta{statement} must be a
+single REDUCE statement, or a \nameref{group} (\name{<<}\ldots\name{>>}) or
+\nameref{begin}\ldots\name{end} \nameref{block}.
+
+\begin{Examples}
+a := 10;                     &           A := 10 \\
+while a <= 12 do <<write a; a := a + 1>>;
+			     &           10 \\
+                                          11 \\
+                                          12 \\
+while a < 5 do <<write a; a := a + 1>>;
+			     &           {\it nothing is printed}
+\end{Examples}
+
+\end{Command}
+
+
+\begin{Command}{WTLEVEL}
+In conjunction with \nameref{weight}, \name{wtlevel} is used to implement
+asymptotic constraints.  Its default value is 2.
+\begin{Syntax}
+\name{wtlevel} \meta{expression}
+\end{Syntax}
+
+To change the weight level, \meta{expression} must evaluate to a positive
+integer that is the greatest weight term to be retained in expressions
+involving kernels with weight assignments. \name{wtlevel} returns the
+new weight level.  If you want the current weight level, but not
+change it, say \name{wtlevel nil}.
+
+\begin{Examples}
+(x+y)**4;          
+        & X^{4} + 4*X^{3}*Y + 6*X^{2}*Y^{2} + 4*X*Y^{3} + Y^{4} \\
+weight x=2,y=3; \\
+wtlevel 8; \\
+(x+y)**4;          & X^{4} \\
+wtlevel 10; \\
+(x+y)**4;          & X^{2}*(6*Y^{2} + 4*X*Y + X^{2}) \\
+int(x**2,x);       & ***** X invalid as KERNEL
+\end{Examples}
+\begin{Comments}
+\name{wtlevel} is used in conjunction with the command \nameref{weight} to
+enable asymptotic constraints.  Weight of a term is computed by multiplying
+the weights of each variable in it by the power to which it has been
+raised, and adding the resulting weights for each variable.  If the weight
+of the term is greater than \name{wtlevel}, the term is dropped from the
+expression, and not used in any further computation involving the
+expression.
+
+Once a weight has been attached to a \nameref{kernel}, it is no longer
+recognized by the system as a kernel, though still a variable.  It cannot
+be used in REDUCE commands and operators that need kernels.  The weight
+attachment can be undone with a \nameref{clear} command. \name{wtlevel} can
+be changed as desired.
+\end{Comments}
+\end{Command}
+