Notes on computational linguistics.pdf - UCLA Department of ...

Stabler - Lx 185/209 2003
5.3.2 Adjunction
(23) Like substitution, adjunction basically involves two replacements, but adjunction is, unfortunately,
quite a bit more complex. The main reason is that we can have adjunctions like the ones shown in 14c,
where a node is extracted and adjoined to an ancestor. That means that one replacement is done inside
one of the constituents affected by the other replacement. A second factor that slightly increases the
complexity of the relation is that a new adjunction structure is built. It is no surprise, then, that the
specifically linguistic restrictions on this operation are also slightly different from those on substitution.
(24) We define the relation adjunction in terms of the replacement relation adjoin_node. The latter relation
is similar to twice_replace_node, but builds appropriate adjunction structures. These adjunction
structures are defined slightly differently for the two basic situations: the more complex case in which
one of the changes is inside a moved constituent, and the simpler case in which the two affected nodes
are distinct. The other relations just define the relevant requirements on the nodes involved.
(25) So,tobeginwith,wedefine:
adjunction(OldRoot, NewRoot, Adjunct, Trace) :root(OldRoot),
root(NewRoot),
adjunct(OldNode, Adjunct),
trace(Adjunct, Trace),
adjunction_structure(AdjnctSite, Adjunct, _Segment, Adjunction),
adjoin_node(OldRoot, OldNode, AdjnctSite, NewRoot, Trace, Adjunction),
nonargument(AdjnctSite),
copy_phi_features(OldNode, Trace0),
add_feature(Trace0, index, I, Trace),
copy_psi_features(OldNode, Adjunct0),
add_feature(Adjunct0, index, I, Adjunct).
(26) The Adjunct part of the adjunction structure will be similartotheoriginalnodetobemoved,OldNode,
as follows:
adjunct(OldNode, Adjunct) :category(OldNode,
Category), category(Adjunct, Category),
barlevel(OldNode, Bar), barlevel(Adjunct, Bar),
extended(OldNode, EP), extended(Adjunct, EP),
contents(OldNode, Contents), contents(Adjunct,Contents).
(27) Now we turn to the basic replacement operations. For substitution, these were trivial, but adjunction
requires a more careful treatment. In the following definition, the first clause is essentially identical
to the definition of twice_replace_node, but here we must add the second clause to cover the case
where A is replaced by DB2 after replacing DA1 by DB1 in a segment of DB2:
adjoin_node(A, DA1, DA2, B, DB1, DB2) :label(A,
Label),
label(B, Label),
children(A, ChildrenA),
children(B, ChildrenB),
adjoin_nodes(ChildrenA, DA1, DA2, ChildrenB, DB1, DB2).
adjoin_node(A, DA1, A, B, DB1, B) :adjunction_structure(A,
_Adjunct, Segment, B),
lower_segment(A,LowerA),
replace_node(LowerA, DA1, Segment, DB1).
lower_segment(A,LowerA) :category(A,Cat),
category(LowerA,Cat),
barlevel(A,Bar), barlevel(LowerA,Bar),
features(A,F), features(LowerA,F),
contents(A,Contents), contents(LowerA,Contents),
same_pedigrees(A,LowerA).
Notice that the features and the extended feature of A are not copied to LowerA: this just allows LowerA
to match the lower segment of the adjunction structure.
(28) Adjunction of one node to another on a distinct branch of the tree is slightly less awkward to handle.
Notice how similar the following definition is to the definition of twice_replace_nodes:
adjoin_nodes([A|As], DA1, DA2, [B|Bs], DB1, DB2) :replace_node(A,
DA1, B, DB1),
replace_nodes(As, DA2, Bs, DB2),
adjunction_structure(DA2, _Adjunct, Segment, DB2),
features(DA2, Features), features(Segment, Features),
contents(DA2, Contents), contents(Segment, Contents).
71