Introduction to Patterns

Patterns are used throughout the Wolfram Language to represent classes of expressions. A simple example of a pattern is the expression f[x_]. This pattern represents the class of expressions with the form f[anything].

The main power of patterns comes from the fact that many operations in the Wolfram Language can be done not only with single expressions, but also with patterns that represent whole classes of expressions.

You can use patterns in transformation rules to specify how classes of expressions should be transformed:

f[a]+f[b]/.f[x_]->x^2

You can use patterns to find the positions of all expressions in a particular class:

Position[{f[a],g[b],f[c]},f[x_]]

The basic object that appears in almost all Wolfram Language patterns is _ (traditionally called "blank" by Wolfram Language programmers). The fundamental rule is simply that _ stands for any expression. On most keyboards the _ underscore character appears as the shifted version of the - dash character.

Thus, for example, the pattern f[_] stands for any expression of the form f[anything]. The pattern f[x_] also stands for any expression of the form f[anything], but gives the name x to the expression anything, allowing you to refer to it on the right-hand side of a transformation rule.

You can put blanks anywhere in an expression. What you get is a pattern which matches all expressions that can be made by "filling in the blanks" in any way.

Some examples of patterns.

You can construct patterns for expressions with any structure:

f[{a,b}]+f[c]/.f[{x_,y_}]->p[x+y]

One of the most common uses of patterns is for "destructuring" function arguments. If you make a definition for f[list_], then you need to use functions like (RefLink[Part, paclet:ref/Part]) explicitly in order to pick out elements of the list. But if you know for example that the list will always have two elements, then it is usually much more convenient instead to give a definition instead for f[{x_,y_}]. Then you can refer to the elements of the list directly as x and y. In addition, the Wolfram Language will not use the definition you have given unless the argument of f really is of the required form of a list of two expressions.

Here is one way to define a function which takes a list of two elements, and evaluates the first element raised to the power of the second element:

g[list_]:=Part[list,1]^Part[list,2]

Here is a much more elegant way to make the definition, using a pattern:

h[{x_,y_}]:=x^y

A crucial point to understand is that Wolfram Language patterns represent classes of expressions with a given structure. One pattern will match a particular expression if the structure of the pattern is the same as the structure of the expression, in the sense that by filling in blanks in the pattern you can get the expression. Even though two expressions may be mathematically equal, they cannot be represented by the same Wolfram Language pattern unless they have the same structure.

Thus, for example, the pattern (1+x_)^2 can stand for expressions like (1+a)^2 or (1+b^3)^2 that have the same structure. However, it cannot stand for the expression 1+2a+a^2. Although this expression is mathematically equal to (1+a)^2, it does not have the same structure as the pattern (1+x_)^2.

The fact that patterns in the Wolfram Language specify the structure of expressions is crucial in making it possible to set up transformation rules which change the structure of expressions, while leaving them mathematically equal.

It is worth realizing that in general it would be quite impossible for the Wolfram Language to match patterns by mathematical, rather than structural, equivalence. In the case of expressions like (1+a)^2 and 1+2a+a^2, you can determine equivalence just by using functions like (RefLink[Expand, paclet:ref/Expand]) and (RefLink[Factor, paclet:ref/Factor]). But, as discussed in "Reducing Expressions to Their Standard Form" there is no general way to find out whether an arbitrary pair of mathematical expressions are equal.

As another example, the pattern x^_ will match the expression x^2. It will not, however, match the expression 1, even though this could be considered as x^0. "Optional and Default Arguments" discusses how to construct a pattern for which this particular case will match. But you should understand that in all cases pattern matching in the Wolfram Language is fundamentally structural.

The x^n_ matches only x^2 and x^3. 1 and x can mathematically be written as (x^n), but do not have the same structure:

{1,x,x^2,x^3}/.x^n_->r[n]

Another point to realize is that the structure the Wolfram Language uses in pattern matching is the full form of expressions printed by (RefLink[FullForm, paclet:ref/FullForm]). Thus, for example, an object such as 1/x, whose full form is (RefLink[Power, paclet:ref/Power])[x,-1] will be matched by the pattern x_^n_, but not by the pattern x_/y_, whose full form is (RefLink[Times, paclet:ref/Times])[x_,(RefLink[Power, paclet:ref/Power])[y_,-1]]. Again, "Optional and Default Arguments" will discuss how you can construct patterns which can match all these cases.

The expressions in the list contain explicit powers of b, so the transformation rule can be applied:

{a/b,1/b^2,2/b^2}/.b^n_->d[n]

Here is the full form of the list:

FullForm[{a/b,1/b^2,2/b^2}]

Although the Wolfram Language does not use mathematical equivalences such as (x^1)==x when matching patterns, it does use certain structural equivalences. Thus, for example, the Wolfram Language takes account of properties such as commutativity and associativity in pattern matching.

To apply this transformation rule, the Wolfram Language makes use of the commutativity and associativity of addition:

f[a+b]+f[a+c]+f[b+d]/.f[a+x_]+f[c+y_]->p[x,y]

The discussion considers only pattern objects such as x_ which can stand for any single expression. Other tutorials discuss the constructs that the Wolfram System uses to extend and restrict the classes of expressions represented by patterns.