Love:
<> == VERB
<mor root> == love.
According to the definition of a model given previously, any model of that
theory will associate with the node
Love a function from paths to values
which respects the above definition. This means that for
every global context c, the following containment must
hold (in this and subsequent examples in this section,
syntactic objects,
e.g., love, <mor root>) are used to stand for their
semantic counterparts under F (i.e.,
![]()
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 = v1v2 and v1 is the longest prefix of v such that
f(v1) is defined. In effect, the function
makes explicit
that information about paths and values that is only
implicit in f, but just in
so far as it does not conflict with explicit information provided by
f.
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 di 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:
![\begin{displaymath}
\begin{array}
{lcl}
\left[\!\left[ \mbox {\tt Love} \right]\...
...}, \mbox{\tt love} \rangle, \ & & \:\:\: \ldots \}\end{array}\end{displaymath}](datrimg69.gif)
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.
