Love: <> == VERB <mor root> == love.According to the definition of a model given previously, any model of that theory will associate with the node

On the other hand, there is no guarantee that a given model will also respect the following containment:

In fact, this containment (amongst other things) *should* hold.
It follows by default from the statements made about `Love`
that the path `<mor>` inherits locally from `VERB` and
that the value associated with any extension of `<mor root>`
is `love`.

There have been a number of formal treatments of defaults in
the setting of attribute-value formalisms.
All these approaches formalize a
notion of default inheritance by defining appropriate operations
(e.g., default unification) for combining strict and default information.
Strict information is allowed to over-ride default information where the
combination would otherwise lead to inconsistency (i.e., unification
failure). In the case of `DATR` however, the formalism does not draw an
explicit distinction between strict and default values for paths. In
fact, all of the information given explicitly in a `DATR` theory is
strict. The non-monotonic nature of `DATR` theories
arises from a general, default mechanism which
fills in the gaps by supplying values for paths not explicitly
specified in a theory.
More specifically,
`DATR`'s default mechanism ensures that any path that is not
explicitly specified for a given node will take its definition from the
longest prefix of that path that *is* specified. Thus, the default
mechanism defines a class of implicit, definitional sentences with paths
on the left that extend paths found on the left of explicit sentences.
Furthermore, this extension of paths is also carried over to paths
occurring on the right. In effect, each (explicit) path is associated
not just with a single value specification, but with a whole family of
specifications indexed by extensions of those paths.

This suggests the following approach to the semantics of defaults in
`DATR`. Rather than interpreting node definitions (in a given global
context) as partial functions from paths to values (i.e., of type ) we choose instead to interpret them as partial
functions from (explicit) paths, to functions from extensions of those
paths to values (i.e., of type ). Now suppose that is
the function associated with the node definition in a given
`DATR` interpretation. We can define a partial function (the *default interpretation* of ) as
follows. For each set

where *v* = *v _{1}v_{2}* and

In order to re-interpret node definitions in the manner suggested above,
it is necessary to modify the interpretation of value descriptors.
In a given global context *c*, a value descriptor
*d* now corresponds to a total function (intuitively, a function from path extensions to values). For
example, atoms now denote constant functions:

More generally, value descriptors will denote different values for
different paths. Figure 2 shows the revised clause for
global node/path pairs, the other definitions being very similar. Note
the way in which the path argument *v* is used to extend in order to define the new local (and in this case also, global)
context *c*'. Similarly, the meaning of each of the *d*_{i} is obtained
with respect to the path extension *v*.

As before, the interpretation function is extended to sequences of path
descriptors, so that for () we have
, if is defined, for each *i* () (and
is undefined otherwise). The definition of the
interpretation of node definitions can be taken over unchanged from the
previous section. However, for a theory *T* and node *N*, the
function is now of type . An interpretation is a *
default model* for theory *T* just in case for every context *c*
and node *N* we have:

As an example, consider the default interpretation of the definition of
the node `Love` given above. By definition, any default model of
the theory must respect the following
containment:

From the definition of , it follows that for any path *v*, if
*v* extends `<mor root>`, then it is mapped onto the value
`love`, and otherwise it is mapped to the value given by
. We have the following picture:

The default models of a theory *T* constitute a proper subset of
the models of *T*: just those that respect the default
interpretations of each of the nodes defined within the theory.