# Introduction to Patterns

Patterns are used throughout

*Mathematica* to represent classes of expressions. A simple example of a pattern is the expression

. 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

*Mathematica* 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.

Out[1]= | |

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

Out[2]= | |

The basic object that appears in almost all

*Mathematica* patterns is

(traditionally called "blank" by

*Mathematica* 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

stands for any expression of the form

f[anything]. The pattern

also stands for any expression of the form

f[anything], but gives the name

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.

f[n_] | with any argument, named |

f[n_,m_] | with two arguments, named and |

x^n_ | to any power, with the power named |

x_^n_ | any expression to any power |

a_+b_ | a sum of two expressions |

{a1_,a2_} | a list of two expressions |

f[n_,n_] | with two *identical* arguments |

Some examples of patterns.

You can construct patterns for expressions with any structure.

Out[3]= | |

One of the most common uses of patterns is for "destructuring" function arguments. If you make a definition for

, then you need to use functions like

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

. Then you can refer to the elements of the list directly as

and

. In addition,

*Mathematica* will not use the definition you have given unless the argument of

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.

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

A crucial point to understand is that

*Mathematica* 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

*Mathematica* pattern unless they have the same structure.

Thus, for example, the pattern

can stand for expressions like

or

that have the same

*structure*. However, it cannot stand for the expression

. Although this expression is

*mathematically equal* to

, it does not have the same

*structure* as the pattern

.

The fact that patterns in

*Mathematica* 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

*Mathematica* to match patterns by mathematical, rather than structural, equivalence. In the case of expressions like

and

, you can determine equivalence just by using functions like

Expand and

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

will match the expression

. It will not, however, match the expression

, even though this could be considered as

.

"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

*Mathematica* is fundamentally structural.

The

matches only

and

.

and

can mathematically be written as

, but do not have the same structure.

Out[6]= | |

Another point to realize is that the structure

*Mathematica* uses in pattern matching is the full form of expressions printed by

FullForm. Thus, for example, an object such as

, whose full form is

Power will be matched by the pattern

, but not by the pattern

, whose full form is

Times[x_, 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

, so the transformation rule can be applied.

Out[7]= | |

Here is the full form of the list.

Out[8]//FullForm= |

| |

Although

*Mathematica* does not use mathematical equivalences such as

when matching patterns, it does use certain structural equivalences. Thus, for example,

*Mathematica* takes account of properties such as commutativity and associativity in pattern matching.

To apply this transformation rule,

*Mathematica* makes use of the commutativity and associativity of addition.

Out[9]= | |

The discussion considers only pattern objects such as

which can stand for any single expression. Other tutorials discuss the constructs that

*Mathematica* uses to extend and restrict the classes of expressions represented by patterns.