The Standard Evaluation Procedure

Here the standard procedure used by Mathematica to evaluate expressions is described. This procedure is the one followed for most kinds of expression. There are, however, some kinds of expressions, such as those used to represent Mathematica programs and control structures, that are evaluated in a nonstandard way.

In the standard evaluation procedure, Mathematica first evaluates the head of an expression and then evaluates each element of the expression. These elements are in general themselves expressions, to which the same evaluation procedure is recursively applied.

The three Print functions are evaluated in turn, each printing its argument, then returning the value Null.
In[1]:=
Click for copyable input
Out[1]=
This assigns the symbol to be Plus.
In[2]:=
Click for copyable input
Out[2]=
The head is evaluated first, so this expression behaves just like a sum of terms.
In[3]:=
Click for copyable input
Out[3]=

As soon as Mathematica has evaluated the head of an expression, it sees whether the head is a symbol that has attributes. If the symbol has the attributes Orderless, Flat, or Listable, then immediately after evaluating the elements of the expression Mathematica performs the transformations associated with these attributes.

The next step in the standard evaluation procedure is to use definitions that Mathematica knows for the expression it is evaluating. Mathematica first tries to use definitions that you have made, and if there are none that apply, it tries built-in definitions.

If Mathematica finds a definition that applies, it performs the corresponding transformation on the expression. The result is another expression, which must then in turn be evaluated according to the standard evaluation procedure.

• Evaluate the head of the expression.
• Evaluate each element in turn.
• Apply transformations associated with the attributes Orderless, Listable, and Flat.
• Apply any definitions that you have given.
• Apply any built-in definitions.
• Evaluate the result.

The standard evaluation procedure.

As discussed in "Principles of Evaluation", Mathematica follows the principle that each expression is evaluated until no further definitions apply. This means that Mathematica must continue reevaluating results until it gets an expression which remains unchanged through the evaluation procedure.

Here is an example that shows how the standard evaluation procedure works on a simple expression. Assume that .

2ax+a^2+1here is the original expression
Plus[Times[2,a,x],Power[a,2],1]this is the internal form
Times[2,a,x]this is evaluated first
Times[2,7,x] is evaluated to give 7
Times[14,x]built-in definitions for Times give this result
Power[a,2]this is evaluated next
Power[7,2]here is the result after evaluating
49built-in definitions for Power give this result
Plus[Times[14,x],49,1]here is the result after the arguments of Plus have been evaluated
Plus[50,Times[14,x]]built-in definitions for Plus give this result
50+14xthe result is printed like this

A simple example of evaluation in Mathematica.

Mathematica provides various ways to "trace" the evaluation process, as discussed in "Tracing Evaluation". The function Trace[expr] gives a nested list showing each subexpression generated during evaluation. (Note that the standard evaluation traverses the expression tree in a depth-first way, so that the smallest subparts of the expression appear first in the results of Trace.)

First set to .
In[4]:=
Click for copyable input
Out[4]=
This gives a nested list of all the subexpressions generated during the evaluation of the expression.
In[5]:=
Click for copyable input
Out[5]=

The order in which Mathematica applies different kinds of definitions is important. The fact that Mathematica applies definitions you have given before it applies built-in definitions means that you can give definitions which override the built-in ones, as discussed in "Modifying Built-in Functions".

This expression is evaluated using the built-in definition for ArcSin.
In[6]:=
Click for copyable input
Out[6]=
You can give your own definitions for ArcSin. You need to remove the protection attribute first.
In[7]:=
Click for copyable input
Your definition is used before the one that is built in.
In[8]:=
Click for copyable input
Out[8]=

As discussed in "Associating Definitions with Different Symbols", you can associate definitions with symbols either as upvalues or downvalues. Mathematica always tries upvalue definitions before downvalue ones.

If you have an expression like , there are, in general, two sets of definitions that could apply: downvalues associated with f and upvalues associated with g. Mathematica tries the definitions associated with g before those associated with f.

This ordering follows the general strategy of trying specific definitions before more general ones. By applying upvalues associated with arguments before applying downvalues associated with a function, Mathematica allows you to make definitions for special arguments which override the general definitions for the function with any arguments.

This defines a rule for , to be associated with .
In[9]:=
Click for copyable input
This defines a rule for , to be associated with .
In[10]:=
Click for copyable input
The rule associated with is tried before the rule associated with .
In[11]:=
Click for copyable input
Out[11]=
If you remove rules associated with , the rule associated with is used.
In[12]:=
Click for copyable input
Out[12]=
• Definitions associated with g are applied before definitions associated with f in the expression .

The order in which definitions are applied.

Most functions such as Plus that are built into Mathematica have downvalues. There are, however, some objects in Mathematica which have built-in upvalues. For example, SeriesData objects, which represent power series, have built-in upvalues with respect to various mathematical operations.

For an expression like , the complete sequence of definitions that are tried in the standard evaluation procedure is:

  • Definitions you have given associated with g;
  • Built-in definitions associated with g;
  • Definitions you have given associated with f;
  • Built-in definitions associated with f.
  • The fact that upvalues are used before downvalues is important in many situations. In a typical case, you might want to define an operation such as composition. If you give upvalues for various objects with respect to composition, these upvalues will be used whenever such objects appear. However, you can also give a general procedure for composition, to be used if no special objects are present. You can give this procedure as a downvalue for composition. Since downvalues are tried after upvalues, the general procedure will be used only if no objects with upvalues are present.

    Here is a definition associated with for composition of " objects".
    In[13]:=
    Click for copyable input
    Here is a general rule for composition, associated with .
    In[14]:=
    Click for copyable input
    If you compose two objects, the rule associated with is used.
    In[15]:=
    Click for copyable input
    Out[15]=
    If you compose objects, the general rule associated with is used.
    In[16]:=
    Click for copyable input
    Out[16]=

    In general, there can be several objects that have upvalues in a particular expression. Mathematica first looks at the head of the expression and tries any upvalues associated with it. Then it successively looks at each element of the expression, trying any upvalues that exist. Mathematica performs this procedure first for upvalues that you have explicitly defined, and then for upvalues that are built-in. The procedure means that in a sequence of elements, upvalues associated with earlier elements take precedence over those associated with later elements.

    This defines an upvalue for with respect to .
    In[17]:=
    Click for copyable input
    This defines an upvalue for .
    In[18]:=
    Click for copyable input
    Which upvalue is used depends on which occurs first in the sequence of arguments to .
    In[19]:=
    Click for copyable input
    Out[19]=
    New to Mathematica? Find your learning path »
    Have a question? Ask support »