File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/97/p97-1053_metho.xml
Size: 17,442 bytes
Last Modified: 2025-10-06 14:14:38
<?xml version="1.0" standalone="yes"?> <Paper uid="P97-1053"> <Title>A Uniform Approach to Underspecification and Parallelism</Title> <Section position="3" start_page="410" end_page="412" type="metho"> <SectionTitle> 2 Context Unification </SectionTitle> <Paragraph position="0"> Context unification is the problem of solving context constraints over finite trees. The notion of context unification stems from (L6vy, 1996) whereas the problem originates from (Comon, 1992) and (Schmidt-Schaul3, 1994). Context unification has been formally defined and investigated by the authors in (Niehren, Pinkal, and Ruhrberg, 1997).</Paragraph> <Paragraph position="1"> Here, we select and summarize relevant results on context unification from the latter.</Paragraph> <Paragraph position="2"> Context unification subsumes string unification (see (Baader and Siekmann, 1993) for an overview) and is subsumed by linear second-order unification which has been independently proposed by (L@vy, 1996) and (Pinkal, 1995). The decidability of context unification is an open problem. String unification has been proved decidable by (Makanin, 1977). The decidability of linear second-order unification is an open problem too whereas second-order unification is known to be undecidable (Goldfarb, 1981).</Paragraph> <Paragraph position="3"> The syntax and semantics of context constraints are defined as follows. We assume an infinite set of first-order variables ranged over by X, Y, Z, an infinite set of second-order variables ranged over by C, and a set of function symbols ranged over by f, that are equipped with an arity n > 0. Nullary function symbols are called constants. Context constraints ~o are defined by the following abstract syntax:</Paragraph> <Paragraph position="5"> A (second-order) term t is either a first-order variable X, a construction f(tl,..., tn) where the arity off is n, or an application C(t). A context constraint is a conjunction of equations between second-order terms.</Paragraph> <Paragraph position="6"> Semantically, we interpret first-order variables X as finite constructor trees, which are first-order terms without variables, and second-order variables C as context functions that we define next. A context with hole X is a term t that does not contain any other variable than X and has exactly one occurrence of X. A conlezt function 7 is a function from trees to trees such that there exists a variable X and a context t with hole X satisfying the equation: 7(~r) = t\[~r/X\] for all trees or.</Paragraph> <Paragraph position="7"> Note that context functions can be described by linear second-order lambda terms of the form AX.t where X occurs exactly once in the second-order term t. Let a be a variable assignment that maps first-order variables to finite trees and second-order variables to context functions. The interpretation (~(t) of a term t under a is the finite tree defined as follows:</Paragraph> <Paragraph position="9"> A solution of a context constraint ~ is a variable assignment a such that a(t) = a(t') for all equations t = t' in 9. A context constraint is called satisfiable if it has a solution. Context unification is the satisfiability problem of context constraints.</Paragraph> <Paragraph position="10"> Context constraints (plus existential quantification) can express subtree constraints over finite trees. A subtree constraint has the form X<<X' and is interpreted with respect to the subtree relation on finite trees. A subtree relation C/r<<a ~ holds if cr is a subtree of cr I, i.e. if there exists a context function 7 such that a' = 7(a). Thus, the following equivalence is valid over finite trees: X<<X' ~ ~C(X' = C(X)) Context constraints are also more general than equality up-to constraints over finite trees, which allow to describe parallel tree structures. An equality up-to constraint has the form X1/X~=Y1/Y~ and is interpreted with respect to the equality up-to relation on finite trees. Given finite trees al,cr~, cr2,a~, the equality up-to relation ai/a~=a2/a~ holds if ~r~ is equal to ~2 up-to one position p where al has the subtree a~ and ~2 the subtree a S. This is depicted in Figure 1. In this case, there exists a context function 7 such that al = 7(al) and a2 = 7(a~). In other words, the following equivalence holds: X/X'=Y/Y' +-+ 3C(X=C(X') AY=C(Y')) Indeed, the satisfiability problems of context constraints and equality up-to constraints over finite trees are equivalent. In other words, context unification can be considered as the problem of solving equality up-to constraints over finite trees.</Paragraph> <Section position="1" start_page="411" end_page="412" type="sub_section"> <SectionTitle> 2.1 Solving Context Constraints </SectionTitle> <Paragraph position="0"> There exists a correct and complete semi-decision procedure for context unification. This algorithm computes a representation of all solutions of a context constraint, in case there are any. We illustrate the algorithm in figure 2. There, we consider the constraint X,=@(Q(s, c), j) A X, =C(Xcs) A Xc,=j which is also discussed in example (11)(i) as part of an elliptical construction.</Paragraph> <Paragraph position="1"> Our algorithm proceeds on pairs consisting of a constraint and a set of variable bindings. At the beginning the set of variable bindings is empty. In case of termination with an empty constraint, the set of variable bindings describes a set of solutions of the initial constraint.</Paragraph> <Paragraph position="2"> Consider the run of our algorithm in figure 2. In the first step, Xs =@(@(s, c), j) is removed from the constraint and the variable binding X8 ~-* @(@(s, c), j) is added. This variable binding is applied to the remaining constraint where X8 is substituted by @(@(s, c), j). The second computation step is similar. It replace the to constraint Xcs=j by a variable binding Xcs ~-~ j and eliminates Xc8 in the remaining constraint.</Paragraph> <Paragraph position="3"> The resulting constraint @(@(s,c),j) = C(j) presents an equation between a term with a constant @ as its (&quot;rigid&quot;) head symbol and a term with a context variable C as its (&quot;flexible&quot;) head symbol. In such a case one can either apply a projection rule that binds C to the identity context AY.Y or an imitation rule. Projection produces a clash of two rigid head symbols @ and j. Imitation presents two possibilities for locating the argument j of the context variable C as a subtree of the two arguments of the rigid head symbol @. Both alternatives lead to new rigid-flexible situations. The first alternative leads to failure (via further projection or imitation) as @(s, c) does not contain j as a subtree. The second leads to success by another projection step.</Paragraph> <Paragraph position="4"> The unique solution of the constraint in figure 2 can be described as follows:</Paragraph> <Paragraph position="6"> The full version of (Niehren, Pinkal, and Ruhrberg, 1997) contains discussions of two algorithms for context unification. For a discussion on decidable fragments of context constraints, we also refer to this paper.</Paragraph> </Section> </Section> <Section position="4" start_page="412" end_page="415" type="metho"> <SectionTitle> 3 Underspecification and Parallelism </SectionTitle> <Paragraph position="0"> In this section, we discuss the use of context unification for treating underspecification and parallelism by some concrete examples. The set of solutions of a context constraint represents the set of possible readings of a given discourse. The trees assigned by the solutions represent expressions of some semantic representation language. Here, we choose (extensional) typed higher-order logic, HOL, (Dowty, Wall, and Peters, 1981). However, any other logical language can be used in principle, so long as we can represent its syntax in terms of finite trees.</Paragraph> <Paragraph position="1"> It is important to keep our semantic representation language (HOL) clearly separate from our description language (context constraints over finite trees). We assume an infinite set of HOL-variables ranged over by x and y. The signature of context constraints contains a unary function symbol lamx and a constant var. per HOL-variable x. Futhermore, we assume a binary function symbol @ that we write in left associative infix notation and constants like john, language, etc. For example the tree (many@language)@(lamx((spoken_by@john)@varx)) represents the HOL formula (=poke by(j Note that the function symbol @ represents the application in HOL and the function symbols lamx the abstraction over x in HOL.</Paragraph> <Section position="1" start_page="413" end_page="413" type="sub_section"> <SectionTitle> 3.1 Scope </SectionTitle> <Paragraph position="0"> Scope underspecification for a sentence like (5) is expressed by the equations in (6):</Paragraph> <Paragraph position="2"> The algorithm for context unification leads to a disjunction of two solved constraints given in (7) (i) and (ii).</Paragraph> <Paragraph position="4"> The algorithm does in fact compute a third kind of solved constraint for (6), where none of the quantifiers two@language and many@linguist are required to be within the scope of each other. This possibility can be excluded within the given framework by using a stronger set of equations between second-order terms as in (6'). Such equations can be reduced to context constraints via Skolemisation.</Paragraph> <Paragraph position="6"> Both solved constraints in (7) describe infinite sets of solutions which arise from freely instantiating the remaining context variables by arbitrary contexts. We need to apply a closure operation consisting in projecting the remaining free context variables to the indentity context AX.X. This gives us in some sense the minimal solutions to the original constraint. It is clear that performing the closure operation must be based on the information that the semantic material assembled so far is complete. Phenomena of incomplete input, or coercion, require a withholding, or at least a delaying of the closure operation. The closure operation on (7) (i) and (ii)leads to the two possible scope readings of (5) given in (8) (i) and A constraint set specifying the scope-neutral meaning information as in (6') can be obtained in a rather simple compositional fashion. Let each node P in the syntactic structure be associated with three semantic meta-variables Xp, X~p, and Cp, and let I(P) be the scope boundary for each node P . Rules for obtaining semantic constraints from binary syntax trees are: (9) (i) For every S-node P add Xp = Cp(X~p), for any other node add Xp = X~p.</Paragraph> <Paragraph position="7"> (ii) If\[p V R\], Q and Rare not NP nodes, add X~ = XQ@Xn or X~p = XI~@XQ, according to HOL type.</Paragraph> <Paragraph position="8"> (iii) If \[p Q R\] or \[p R Q\], and R is an NP node, then add X~o = XQ@varx and</Paragraph> <Paragraph position="10"> For example, the first two constraints in example (6') result from applying rule (iii), where the values for the quantifiers two@language and many@linguist are already substituted in for the variables XR in both cases. The quantifiers themselves are put together by rule (ii). The third constraint results from rule (i) when the semantics of X~ is filled in. The latter is a byproduct of the applications of rule (iii) to the two NPs.</Paragraph> </Section> <Section position="2" start_page="413" end_page="414" type="sub_section"> <SectionTitle> 3.2 Ellipsis </SectionTitle> <Paragraph position="0"> We now look into the interpretation of examples (1) to (4), which exhibit forms of parallelism. Let us take Xs and Xt to represent the semantics of the source and the target clause (i.e., the first and the second clause of a parallel construction; the terminology is taken over from the ellipsis literature), and Xcs and Xct to refer to the semantic values of the contrast pair. The constraint set of the whole construction is the union of the constraint sets obtained by interpreting source and target clause independent of each other plus the pair of constraints given in</Paragraph> <Paragraph position="2"> The equations in (10) determine that the semantics of the source clause and the semantics of the target clause are obtained by embedding the representations of the respective contrasting elements into the same context. In other words: Source semantics and target semantics must be identical up to the positions of the contrasting elements.</Paragraph> <Paragraph position="3"> As an example, consider the ellipsis construction of Sentence (1), where for simplicity we assume that proper names are interpreted by constants and not as quantifiers. It makes no difference for our treatment of parallelism.</Paragraph> <Paragraph position="5"> (ii) Xa = bill A Xt = C(Xot) By applying the algorithm for context unification to this constraint, in particular to part (i) as demonstrated in figure 2, we can compute the context C to be AY.(speak@chinese@Y). This yields the interpretation of the elliptical clause, which is given by Xt ~ speak@chinese@bill.</Paragraph> <Paragraph position="6"> Note that the treatment of parallelism refers to contrasted and non-contrasted portions of the clause pairs rather than to overt and phonetically unrealized elements. Thus it is not specifc for the treatment of ellipsis, but can be applied to other kinds of parallel constructions, as well. In the correction pair of Sentence (2), it provides a certain unambiguous reading for the pronoun, in (3), it gives X8 = speak@chinese@X~ as a partial description of the (overheard or unuttered) source clause.</Paragraph> </Section> <Section position="3" start_page="414" end_page="415" type="sub_section"> <SectionTitle> 3.3 Scope and Ellipsis </SectionTitle> <Paragraph position="0"> Finally, let us look at the problem case of parallelism constraints for structurally underspecified clause pairs. We get a combination of constraints for a scope underspecified source clause (12) and parallelism constraints between source and target (13).</Paragraph> <Paragraph position="2"> The conjunction of the constraints in (12) and (13) correctly allows for the two solutions (14) and (15), with corresponding scopings in Xs and Xt after closure. 2 Mixed solutions, where the two quantifiers take different relative scope in the source and target clause are not permitted by our constraints. For example, (16) provides no solution to the above constraints. (16) X 3</Paragraph> <Paragraph position="4"> 2Notice that closure is applied to the solved form of the combined constraints (i.e. (14) and (15) respectively) of the two sentences here, rather than to solved forms of (12) and (13) separately. This reflects the dependency of the interpretation of the second sentence on material in the first one.</Paragraph> <Paragraph position="5"> From the trees in (16) one cannot construct a context function to be assigned to C which solves the parallelism constraints in (13).</Paragraph> </Section> </Section> <Section position="5" start_page="415" end_page="415" type="metho"> <SectionTitle> 4 Comparison to other Theories </SectionTitle> <Paragraph position="0"> Standard theories for scope underspecification make use of subtree relations and equality relations only.</Paragraph> <Paragraph position="1"> Such relationships may be expressed on a level of a separate constraint language, as in our case, or be incorporated into the semantic formalism itself, as it is done for DRT by the system of UDRT (Reyle, 1993).</Paragraph> <Paragraph position="2"> In UDRT one introduces &quot;labels&quot; that behave very much like variables for DRSes. These labels figure in equations as well as subordination constraints to express scope relations between quantifiers. Equations and subordination constraints alone do not provide us with a treatment of parallelism. An idea that seems to come close to our notion of equality up-to constraints is the co-indexing technique in (Reyle, 1995), where non-local forms of parallelism are treated by dependency marking on labels. We believe that our use of a separate constraint language is more transparent.</Paragraph> <Paragraph position="3"> A treatment for ellipsis interpretation which uses a form of higher-order unification has been proposed in (Dalrymple, Shieber, and Pereira, 1991) and extended to other kinds of parallel constructions by (Gardent, Kohlhase, and van Leusen, 1996; Gardent and Kohlhase, 1996). Though related in some respects, there are formal differences and differences in coverage between this approach and the one we propose. They use an algorithm for higher-order matching rather than context unification and they do not distinguish an object and meta language level. As a consequence they need to resort to additional machinery for the treatment of scope relations, such as Pereira's scoping calculus, described in (Shieber, Pereira, and Dalrymple, 1996).</Paragraph> <Paragraph position="4"> On the other hand, their approach treats a large number of problems of the interaction of anaphora and ellipsis, especially strict/sloppy ambiguities.</Paragraph> <Paragraph position="5"> Our use of context unification does not allow us to adopt their strategy of capturing such ambiguities by admitting non-linear solutions to parallelism constraints. null</Paragraph> </Section> class="xml-element"></Paper>