As an example consider a transfer grammar to define the transfer relation between Dutch and English. The semantic representations of English and Dutch are labelled by the labels gb and nl respectively. We simplify this example by not taking into account properties such as tense and aspect. A rule that translates `open_fire_on' into `het_vuur_openen_op' is defined as:
This rule simply states that the translation of an argument structure
is composed of the translation of its arguments; furthermore the value
for the
neg attribute is simply defined to be the same for the
English and Dutch argument structure representations. Similar rules
can be written for other predicates. If the rule applies to the goal
the two daughters of the
rule will be `instantiated', and the value of
nl will be bound to the
nl values of these daughters; i.e. we obtain the goal:
An example of the rule for the first daughter will be a bilingual lexical entry
and looks as:
The second daughter will be translated by a general rule translating argument structures
of sort `modifier' (this rule will be modified later in this section):
The complex English expression `prime minister' has to be translated as a simple expression in Dutch: `premier'. This rule can be defined as:
where it is assumed that the construction is analyzed in English as an
ordinary modified construction (rather than as a single idiomatic
expression), and where the semantic representation of the modifier (`prime')
takes the semantic representation of the noun as its argument. Note that a
similar rule could be written to deal with the `schimmel - white
horse' example. As a result of the rule applications we obtain the
following feature structure from which the generator generates the
sentence
The abbreviated `parse tree' for this example can be shown as in figure 5.5.
In the foregoing examples the relation between semantic representations is rather straightforward. Note however that the full power of a unification grammar can be used to settle more difficult translation cases, because different labels can be used to represent the `translational syntax'. For instance we can build a tree as value of the label tree to represent the derivational history of the translation process. Or we can `thread' information through different nodes to be able to make translations dependent on each other. Translation parameters such as style and subject field can be percolated as labels of nodes to obtain consistent translations; but these labels themselves need not be translated. Some examples of more interesting translation rules using some of these possibilities are defined in the next sections.