For example, let's suppose you want to say that a
`circle` element contains a
`center` element and either a
`radius` or a `diameter` element,
but not both. This declaration does that:

<!ELEMENT circle (center, (radius | diameter))>

To continue with a geometry example, suppose a
`center` element can either be defined in terms of
Cartesian or polar coordinates. Then each center contains either an
`x` and a `y` or an
`r` and a . We would declare this using
two small sequences, each of which is parenthesized and combined in a
choice:

`<!ELEMENT center ((x, y) | (r, ))>`

Suppose you don't really care whether the
`x` element comes before the `y`
element or vice versa, nor do you care whether `r`
comes before . Then you can expand the choice to cover
all four possibilities:

`<!ELEMENT center ((x, y) | (y, x) | (r, ) | (, r) )>`

As the number of elements in the sequence grows, the number of
permutations grows more than exponentially. Thus, this technique
really isn't practical past two or three child
elements. DTDs are not very good at saying you want n instances of A
and m instances of B, but you don't really care
which order they come in.

Suffixes can be applied to parenthesized elements too. For instance,
let's suppose that a polygon is defined by
individual coordinates for each vertex, given in order. For example,
this is a right triangle:

What we want to say is that a polygon is composed of three or more
pairs of x-y or r- coordinates. An `x`
is always followed by a `y`, and an
`r` is always followed by a . This
declaration does that:

The plus sign is applied to `((x,`
`y)` `|` `(r,`
`))`.

To return to the name example, suppose you want to say that a name
can contain just a first name, just a last name, or a first name and
a last name with an indefinite number of middle names. This
declaration achieves that:

<!ELEMENT name (last_name
| (first_name, ( (middle_name+, last_name) | (last_name?) )
) >