Syntax:
patmatch(expr,pattern); or patmatch(expr, pattern, 's');
expr: the expression to be matched.
pattern: the pattern.
s: the returned variable with the substitution.

The patmatch function returns true if it can match expr to pattern, and returns false otherwise. If the matching is successful, s is assigned to a substitution set such that subs(s, pattern) = expr.

A pattern is an expression containing variables with type defined by "::"; for example, a::radnum means that $a$ is matched to an expression of type radnum. Note that, in a sum such as a::realcons+x, $a$ can be $0$; while in a product, such as a::realcons*x, $a$ can be $1$. This behavior can be avoided by wrapping the keyword nonunit around the type: for example, a::nonunit(realcons)*x does not match $x$.

Examples:

Matching a linear expression with real coefficients:

The following pattern matcher looks for type $ax\+b$ where $b$ is a sum of real constants:

keyword nonunit:

The pattern matcher matches the commutative operations `+` and `*`; for example, the pattern a::realcons*x+b::algebraic will look for a term of the form realcons*x, and then bind the rest of the sum to $b$.

The special keyword conditional is used to specify patterns having additional conditions. This is used for programming patterns in tables with additional conditions on the pattern. The syntax is conditional(pattern, condition) and conditional(pattern=right_hand_side, condition) for rules in tables or define. For example, it can be used for patterns of type int(a::algebraic,x::name)=a*x,_type(a,freeof(x)). This is not the same as int(a::freeof(x),x::name), because at the point that the pattern matcher matches, $a$, $x$ is not known yet. Note that the condition has to be unevaluated or in inert form, meaning that you must use an underscore '_' in front of every name; for example, _type(a,freeof(x)).
Note: You cannot use `=` or `<>`.

Examples:

Matching linear patterns and other common patterns: the pattern a::nonunit(algebraic)+b::nonunit(algebraic) matches the sum of two or more terms. (The same construct as for *.)  a::nonunit(algebraic)+b::algebraic matches a single term or the sum of terms. Note that in define (see the help page of define) we have the keywords linear and multilinear, which generate more efficient code. x^nonunit(n::integer) matches an integer power of $x$ but not $x$ itself.

Examples:

Note: for the last result, one may obtain either $A\&equals;a$ or $A\&equals;a\&plus;{\&ExponentialE;}^x$.  Several outcomes are possible for the following case:

The pattern matcher can also handle lists: