When reading through the documentation, you often encounter the phrases DownValues, UpValues, SubValues, and OwnValues. I am trying to understand the distinction between the four of them, and how, for a given Symbol, I can use them. Also, are they processed differently internally?
Answer
In Mathematica, all functions are really just patterns, and there are different kinds of those.
Let's start with OwnValues, which is the pattern type of a variable as you know it from other programming languages. The symbol having the OwnValue has, as the name suggests, intrinsic, "own", value.
In[1] := a = 2; OwnValues[a]
Out[1] := {HoldPattern[a] :> 2}
A DownValue is defined when the variable itself does not have a meaning, but can get one when combined with the proper arguments. This is the case for the most function definitions
f[x_] := x^2
This defines a pattern for f specifying that each time f[...] is encountered, it is to be replaced by ...^2. This pattern is meaningless if there is a lonely f,
In[2] := f
Out[2] := f
However, when encountered with an argument downwards (i.e. down the internal structure of the command you entered), the pattern applies,
In[3] := f[b]
Out[3] := b^2
You can see the generated rule using
In[4] := DownValues[f]
Out[4] := {HoldPattern[f[x_]] :> x^2}
The next type of pattern concerns UpValues. Sometimes, it's convenient not to associate the rule to the outermost symbol. For example, you may want to have a symbol whose value is 2 when it has a subscript of 1, for example to define a special case in a sequence. This would be entered as follows:
c /: Subscript[c, 1] := 2
If the symbol c is encountered, neither of the discussed patterns apply. c on its own has no own hence no OwnValue, and looking down the command tree of c when seeing Subscript[c,1] yields nothing, since c is already on an outermost branch. An UpValue solves this problem: a symbol having an UpValue defines a pattern where not only the children, but also the parents are to be investigated, i.e. Mathematica has to look up the command tree to see whether the pattern is to be applied.
In[5] := UpValues[c]
Out[5] := {HoldPattern[Subscript[c, 1]] :> 2}
The last command is SubValues, which is used for definitions of the type
d[e][f] = x;
This defines neither an OwnValue nor a DownValue for d, since it does not really define the value for the atomic object d itself, but for d[e], which is a composite. Read the definition above as (d[e])[f]=x.
In[6] := SubValues[d]
Out[6] := {HoldPattern[d[e][f]] :> x}
(Intuitively, an OwnValue for d[e] is created, however calling for this results in an error, i.e. OwnValues[d[e]] creates Argument d[e] at position 1 is expected to be a symbol.)
Comments
Post a Comment