Come:
<> == VERB
<mor root> == come
<mor past> == came
<mor past participle> == <mor root>
<syn> == INTRANSITIVE:<>.
Here the empty path inherits from VERB so the value of
Come:<> is equated to that of VERB:<>. And
the past participle inherits from the root: Come:<mor
past participle> is equated with Come:<mor root> (i.e., come).
In both these inheritances, only one of the node or path was
specified: the other was taken to be the same as that found
on the left-hand-side of the statement (<> and Come respectively).
The third type of local inheritance is illustrated by the final
statement, in which both node and path are specified: the syntax of
Come is equated with the empty path at INTRANSITIVE,
an abstract node defining the syntax of intransitive verbs.
Bear in mind that the following are not synonymous
Come:<syn> == INTRANSITIVE:<>.
Come:<syn> == INTRANSITIVE.
since the latter is equivalent to
Come:<syn> == INTRANSITIVE:<syn>.
There is a natural procedural interpretation of this kind of
inheritance, in which the value associated with the definitional
expression is determined by ``following'' the inheritance specification
and looking for the value at the new site. So given a DATR description
(i.e., a set of definitional statements) and an initial node/path query,
we look for the node and path as the left hand side of a definitional
statement. If the definitional statement for this pair provides a local
descriptor, then we follow it, by changing one or both of the node or
path, and then repeat the process with the resulting node/path pair. We
continue until some node/path pair specifies an explicit value. In the
case of multiple expressions on the right hand side of a statement, we
pursue each of them entirely independently of the others. This operation
is local in the sense that each step is carried out without reference to
any context wider than the immediate definitional statement at hand.
Declaratively speaking, local descriptors simply express equality constraints between definitional values for node/path pairs. The statement:
Node1:Path1 == Node2:Path2.
can be read approximately as ``if the value for Node2:Path2 is
defined, then the value of Node1:Path1 is defined and equal to
it''. There are several points to notice here. First, if
Node2:Path2 is not defined, then Node1:Path1 is
unconstrained, so this is a weak directional equality constraint.
However, in practice this has no useful consequences, due to
interactions with the default mechanism - see Section
3.1.5 below. Second, ``defined'' here means ``defined by a
definitional statement'', that is a ``=='' statement: local
inheritance operates entirely with definitional statements, implicitly
introducing new ones for Node1:Path1 on the basis of those defined
for Node2:Path2. Finally, as we shall discuss more fully in the
next subsection,
``value'' here technically covers both simple values
and global inheritance descriptors.
