previous up contents next
Left: Inheritance in DATR Up: Inheritance in DATR Right: Global inheritance

Local inheritance

 The simplest type of inheritance in DATR is the specification of a value by local inheritance. Such specifications may provide a new node, a new path, or a new node and path to inherit from. An example definition for the lexeme Come illustrates all three of these types:
    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.

---------------------------------------------------------

previous up contents next
Left: Inheritance in DATR Up: Inheritance in DATR Right: Global inheritance
Copyright © Roger Evans, Gerald Gazdar & Bill Keller, Tuesday 10 November 1998