previous up contents next
Left: DATR techniques Up: DATR techniques Right: Boolean logic

Case constructs and parameters

 Evaluable paths allow the value of one path to be determined by the value of another. More generally, the values of an arbitrary number of descriptors can be invoked as parameters in an evaluable path and thus determine the value of a particular node/path pair. The familiar case construct of procedural programming languages is readily implemented, as the following example describing English plural suffixes shows:
    NOUN:
        <plural> == <case of "<origin>">

        <case of latin masculine> == -i
        <case of latin neuter>    == -a
        <case of>                 == -s

        <origin> == norman.

    Cat:
        <> == NOUN.
    Datum:
        <> == NOUN
        <origin> == latin neuter.
    Alumnus:
        <> == NOUN
        <origin> == latin masculine.
Here the value of the <origin> attribute of a noun (denoting its etymological source) is used to determine the value of its <plural> suffix. Thus we can derive the following extensional statements:

    Cat:
        <plural> = -s.
    Datum:
        <plural> = -a.
    Alumnus:
        <plural> = -i.

We do not need to invoke an attribute called case to get this technique to work. For example, in Section 2, we gave the following definition of <mor form> in terms of <syn form>:

    VERB:
        <mor form> == <mor "<syn form>">.
Here the feature <syn form> returns a value (such as passive participle or present tense sing three) which becomes part of the path through which <mor form> inherits. This means that nodes for surface word forms need only state their parent lexeme and <syn form> feature in order for their <mor form> to be fully described. So, as we saw in Section 2 above, the passive participle form of sew is fully described by the node definition for Word3.

    Word3:
        <> == Sew
        <syn form> == passive participle.
For finite forms, we could use a similar technique. From this,

    Word4:
        <> == Sew
        <syn form> == present sing third.
we would want to be able to infer this:

    Word4:
        <mor form> = sew s
However, the components of <syn form>, present, sing, third are themselves values of features we probably want to represent independently. One way to achieve this is to define a value for <syn form> which is itself parameterised from the values of these other features. And the appropriate place to do this is in the VERB node, thus:

    VERB:
        <syn form> == "<syn tense>" "<syn number>" "<syn person>".
This says that the default value for the syntactic form of a verb is a finite form, but exactly which finite form depends on the settings of three other paths, <syn tense>, <syn number> and <syn person>. So now we can express Word4 as:

    Word4:
        <> == Sew
        <syn tense> == present
        <syn number> == sing
        <syn person> == third.
This approach has the advantage that the attribute ordering used in the <mor...> paths is handled internally: the leaf nodes need not know or care about it. Thus Word3 remains unchanged, overriding the definition of <syn form> and so not requiring these additional features to be defined at all, nor making any use of them if they are defined.

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

previous up contents next
Left: DATR techniques Up: DATR techniques Right: Boolean logic
Copyright © Roger Evans, Gerald Gazdar & Bill Keller, Tuesday 10 November 1998