Semantic Construction from Parse Forests 
Michael Schiehlen* 
Institute for Computational Linguistics, University of Stuttgart, 
Azenbergstr. 12, 70174 Stuttgart 
mike¢adler, ims. uni:stuttgart, de 
Abstract 
The paper describes a system which uses 
packed parser output directly to build 
semantic representations. More specifi- 
cally, the system takes as input Packed 
Shared Forests in the sense of Tomita 
(l_bmita, 1985) and produces packed 
Underspeeified Discourse Representation 
Structures. The algorithm visits every 
node in the Parse Forest only a bounded 
number of times, so that a significant in- 
crease in efficiency is registered for am- 
biguous sentences. 
1 Introduction 
One of the most inl;eresting problems comes about 
by the tendency of natural language discourse to 
be ambiguous and open to a wide variety of in- 
terpretations. Generating representations for all 
the interpretations is nol, feasible in view of the 
strict computa|,ional bounds imposed on NLP sys- 
tems. Instead, two other routes have been tmr- 
sued: (1) the integration of further disambiguat- 
ing knowledge and heuristics into the system or 
(2) the general;ion of a single semantic represent, a- 
lion that summarizes all the interI>retations in the 
hope that the application task will force a distin<:- 
lion between the int;erpretations only in few cases. 
Such a summary repre.sentation is called under- 
specified if a procedure is given with it to <terive 
a set of real semantic representations fl'om it. By 
now~ several techniques are kIlown to underspec- 
ify quantifier scope ambiguities (Alshawi, 1992), 
(Reyle, 1993). In this paper Discourse Repre- 
sentation Structures (Kamp mM Reyle, 1993) are 
employed as underlying semantic ret)resentations. 
For underspecification with respect to s<:ope atnbi- 
gullies the present approach makes use of Under- 
*This work was funded by the Germ;m Federal 
Ministry of Edu(:ation, Science, Research and Te(:h- 
nology (BMBF) in the flamework of the Verbmobil 
Project under Grant 01. IV 1.01 U. Many thanks are 
due to M. Dorna, J. DSrre, M. Einele, E. KSnig- 
Bamner, C. Rohrer, C.J. Rupp, attd C. Vogel. 
speeilied Discourse Representation Theory (Reyle, 
1993). Another strand of research has looked al; 
compact representations for parse outputs (Ear- 
Icy, 1970), (Tomita, 1985) and etticienI, parsing 
algorithms 1,o deliver such ret>resentalions. Un- 
fortunately, advances made in this area (lid not; 
have impact on semantic construction. It; was still 
necessary to first unpack the compacl; parsing ret)- 
resentation and derive the individual parse trees 
from it before going about generating semant;ic 
representations. So in this area another applica- 
lion for semantic underspecitieation is lurking. 
Several approaches to underspecifica|,ion axe 
conceival)le. (1) OperationM Underspecilical,ion: 
Construction operations that; involve art)itrary 
choices are delayed and carried out only on de- 
mand (Alshawi, 1992), (Pinkal, 1995). (2) I{ep- 
resentational Underspeeification: The ambiguil;ies 
are represented (explicitly or implicitly) in a for- 
realism. A resolution procedure derives the hill- 
fledged semantic representations. This t)aper opts 
for the second approach (for motivation see chap- 
ter 7). hel,ween the t)arser and the semantic (:on- 
sl;rllc|;ion colnponen|,~ (;oo. 
• Parse forests/charts (Alshawi, 1992). 
• Underspecified "trees" with abstract donfi- 
nanee information (Pinlml, 1.995). 
• Fully specified parse trees (Egg and Lebet;h, 
1995). The syntactic ambiguities are ol)- 
rained by re-ambiguat;ion in the semanl;ic 
eoHlponent. 
Our choice are parse forests since there are well- 
known methods of construction for t, hem and it 
is guarant;eed that every syntactic ambiguit;y can 
be represented in this way. ISu'thermore a wide 
range of existing parsing systems, e.g. (Block and 
Schachtl, 1992), produce packed representations 
of this kind. 
2 Outline of the System 
Let us begin wil;h a rough sketch of the arctfitec- 
lure of the systmn. The semantic cons|;rllcl;ion 
module works on parse forests and presut)t)oses 
907 
a semantic grammar of a certain kind (see chap- 
ter 6). The semantic grammar must be correlated 
with the syntactic grammar so that there is a one- 
to-one mapping between lexical entries and rules. 
input string 
I Parser 
using: Syntactic Grammar 
4, 
parse forest 
I emantic Construction Module 
using: Semantic Grammar $ 
packed UDRS 
Inside the semantic construction module three 
processes are distinguished. They are described in 
turn (see chapter 4 and 6). 
parse forest 
4 \[' Tree naming 
disambiguated parse forest 
I Semantic coiastruction proper 
using: Semantic Grammar $ 
packed UDRS $ 
F Determining unambiguous arguments \] 
packed UDRS 
3 Packed Shared Forests 
In this section a formal description of packed 
shared forests in the sense of Tomita (Tomita, 
1985) is given. 
Let a context-free grammar G be a quadru- 
ple < N, T, R, S > where N and T are finite dis- 
joint sets of nonterminal symbols and terminal 
symbols, respectively, R is a set of rules of the 
form A -+ a (A is a nonterminal and a a possibly 
empty string of nonterminal or terminal symbols), 
S is a speciM nontermin~l, called start symbol. 
An ordered directed graph marked according 
to grammar ~ is a triple < V,E,m > so that 
V is a finite set of vertices or nodes, E a fi- 
nite set of edges e of the form (vl, (v2,... ,vn)) 
(vi C V,n > 2, e starts at vl, vl is the prede- 
cessor of v2,..., vn), m is the marking function 
which associates with each vertex a terrainai or 
nonterminai symbol or the special symbol e. m 
is restricted so that the vertices on each edge are 
marked with the,symbols of a rule in 6, the empty 
string being represented by the additional sym- 
bol ~. A parse tree is an ordered directed acyclic 
graph (DAG) satisfying the following constraints. 
1. There is exactly one vertex without predeces- 
sors, called the top vertex or root. The root 
is marked with the start symbol. 
2. For every vertex there is at most one edge 
starting at the vette±. Vertices that do not 
begin edges are called leaves, such that do 
are called inner nodes. 
3. Every vertex except the root has exactly one 
predecessor. 
A DAG satisfying the constraints (1-2) is called 
Shared Forest, a DAG only satisfying (1) is a 
Packed Shared Forest or parse forest (see fig- 
ure 1). A packed shared forest for an input string 
a obeys the further constraint that, there must be 
at most one vertex for each grammar symbol and 
substring of a. Thus, if a consists of n words, 
there will be at most k * n 2 vertices in the parse 
forest for it (k being constant). Parse forests can 
be efficiently constructed using conventional pars- 
ing algorithms (Tomita, 1985), (Earley, 1970). 
4 Determining Tree Readings from 
a Forest 
A tree reading of forest F is a tree in F that; con- 
tains the root and all leaves. Tree readings are 
treated as objects. An edge is used in a tree read- 
ing if it is one of the tree's edges. Let us now define 
a disambiguated parse forest (DPF for short). A 
DPF 79 is a quadruple < V,D,E',m > such that 
• V and D are finite disjoint sets. V is the set 
of vertices and D is the set of tree readings. 
• E' is a finite set of edges of the form 
(vl, {v2,..., vn), {dl,..., d,~}). The third el- 
ement is a set of tree readings (C D) and 
encodes the tree readings in which the edge 
is used. 
• m is a marking function from vertices to 
grammar symbols. 
To derive a DPF from a parse forest every edge 
must be assigned a set of tree readings. There is 
no simple way to determine from a parse forest the 
number of its tree readings. So instead of postu- 
lating a fixed set of readings the present approach 
uses pointers (implemented as Prolog variables) to 
refer to sets of tree readings. Two operations dis- 
joint union and multiplication are defined for these 
sct pointers. Both operations are monotonic in the 
sense that the pointers are not altered, their value 
is only specified. Let si be a set of tree readings. 
• 81 0 82 
The operator tJ differs from the set-theoretic 
notion of disjoint union in that it is neither 
commutative nor associative. This is so be- 
cause on the implementational level commu- 
tativity and associativity would necessitate 
an abstract data type, thus a costly overhead. 
• 81 X 82 
In general, sl and s2 correspond to formulae 
invo!ving atomic sets and 0 operators\[ Sl = 
Sll U ... U 81m and s2 = s21 U ... U 82n. 
908 
Z ,,' 
np v d n p d n p d n 
I saw a man in the apt with a tel 
Figure 1: a parse forest with a tree reading all: edges used in dl are shown as broken lines 
The operation x introduces m* n new atomic 
sets s~j and splits the former atomic sets such 
that Vi: 1 <i < m : Sli = s~l 0 ... 0 s~,, 
and Vj : 1 <<_ j < n : s2j = s~j 0 " ' ... U Smj. 
The sets Sl and s2 are now equal modulo as- 
sociativity and commutativity. Consider the 
following example: 
(81 0 82 0 83) X (8a 0 8b) --} 
(.~, 0 s~ 0 ~)=(4o 0 d~) 0 (A,, 0 ,~,,)' 0 (s~o' 0 .~,,)' 
(,. 0 *b)=(.% 0 4. 0 4.) 0 (4b 0,5~ 0 ,'~) 
We begin by associating a particular set pointer sl 
with the root vertex. Sl refers to the, total set of 
tree readings of the forest; since the root vertex fig- 
ures in all trees derivable from the forest. We then 
traverse the graph in top-down fashion applying 
to each new vertex v the following procedure: 
Let ei be the set of tree readings at edge 
i ending in v, and b# the set of tree read- 
ings at edge j starting in v. Then the 
following actions must be performed. 
• Apply the procedure to all succes- 
sors of v. This step yields for each 
edge j starting in v and for each ver- 
tex u at the end of j a set of tree 
readings b~,,. 
• bj = b;1 X ... X b},, for each edge j 
starting in v 
• (bl 0 ... 0 bn) x (el 0 ... 0 era) 
If a vertex v h~s already been encountered the only 
action required is to connect the edge information 
on v's predecessor w with the edge information 
already present on vertex v. In particular, the 
successors of v need not be checked again. 
Let k be the edge ()vet' which the vertex v 
was reached from another vertex w in the 
top-down traversal. Let C'k,t, be the set 
of tree readings determined for edge k at 
vertex w and ek,, the set of tree readings 
determined for the edge at vertex v. 
• ('~kv X Ckw 
5 Packed Underspecified Discourse 
Representation Structures 
In this section an extension to UDRSs (Reyle, 
1993) to express referentially underspecified se- 
mantic representations is presented. 
First a detinition of UDRSs is given. A UDRS/J 
is a quadruple < L,R,C, <_> where L and R are 
disjoint finite sets of labels and discourse refer- 
ents, respectively. The order relation < forms a 
semilattice ow, r L with one-element lq. C is a set 
of conditions of the following form 
• 1 : x, where l C 12,x E :R.. 
* 1 : p(xl,...,x,,), where I E 12,xi,...,:r,~ C Tt, 
and p is an n-place predicate 
• I : 11 => 12, where l, ll,12 C 12 
• l : -~ll, where 1,11 ~ £ 
* 1 : ll V 12, where l,ll,l.~ C £ 
* ll ~ 12, where ll,l.~ E 12 
In UDRSs 12 = L and "~ = R. 
To get packed UDRSs the UDRS language is ex- 
tended by adding reified contexts (semantic read- 
ings) to it. The idea of using context variat)les 
to represent ambiguous structures originally stems 
fl'om the literature on constraint-based formalisms 
(DSrre and Eisele, 1990). A packed UDRS is a 
quintuple < L,R,D,C',5> where L, R, < are 
the same as in UDRSs, D is a finite set of con- 
texts which is disjoint from L and R. C' is defined 
as in UDRSs except that (1) any condition may 
909 
also be prefixed by a context set, and (2) label 
arguments may~ not, only be labels but also func- 
tions from contexts to labels (£ = L U (D --~ L)), 
and the same holds for discourse referents (7£ = 
RtA (D ~ R)). If a function {A ~ Xl,B ~ x2} 
replaces a discourse referent in a packed UDRS, 
this intuitively means that the argument slot is 
filled by xt in reading A and by x2 in reading B. 
As an example for a packed UDRS consider the 
following representation for I saw every man with 
a telescope. 
Ii :i 
anchor ( i, .speaker) 
t2 : sce(el,i, xl) 
12 _< 1T 
13 _< lT 
12 _< 14 
13 : every(x1,15, 14) 
15 :man(x1) 
{A -+/2,B -+ 15} : with({A -~ ttl,g --~ ~1},X2) 
{ A -~ 12 , B "~ /5 } _< 1~ 
16 _< 1T 
16 : x2 
16 :telescope(x2) 
In the implementation contexts are represented by 
Prolog variables. In this way disambiguation is 
ensured to be monotonic1: A context d can be 
cancelled by grounding the Prolog variable repre- 
senting d to a specific atom "no". The formalism 
also allows any kind of partially disambiguated 
structures since thc variables for the readings do 
not interact. 
In the above version of UDRS packing, disjuncts 
are re\[fled. Another way to represent referential 
ambiguities is to retry argument slots using addi- 
tional variable names (L and X below, not to be 
mistaken as discourse referents). Disjunctions are 
then represented directly. 
1T:i 
anchor(i, speaker) 
12 : see(el, i, xl) 
l.~ < IT 
13 <~ ll 
12 ~ 14 
/3 : every(xl,15,/4) 
/5 :man(x1) 
L : with(X, x.2) 
L <16 
la < 17 
16 : x2 
/6 : telescope(x2) 
(L -~/2 A X ~- el) V (L = 15 A X = Xl) 
1Another way to see that the resolution procedure 
~s monotonic is to assume a semi-lattice over context 
sets with respect to the subset relation. Cancelling a 
context from a set makes it more specific in the semi- 
lattice. 
6 Building Semantic 
Representations 
UDRS construction (Frank and Reyle, 1992), 
(Bos, 1995) is different from conventional seman- 
tic construction in that embedding is not rep- 
resented directly but by means of labels. Tile 
only semantic composition operation is concate- 
nation. In addition labels and discourse referents 
are matched as specified in the semantic part; of 
the grammar rules (the "semantic grammm'"). In 
the semantic grmnnmr every nonterminal is as- 
signed a list of arguments. For every operator 
(e.g. an NP) a lower label and a series of upper 
labels must be given. The lower label points to 
material which must be in the scope of the op- 
erator (e.g. tile verb). The upper labels refer to 
thc minimal scope domain tile operator must oc- 
cur in. This domain differs for indefinite NPs and 
quantifier NPs since these types of NPs are sub- 
ject to different island constraints (only indefinites 
can be raised over clause boundaries). Further- 
more, the semantic grammar specifies the UDRS 
conditions introduced by lexical items and rules 
and determines the arguments to be matched in 
rules and lexical items. It also gives the direc- 
tion of this matching by fixing in which lexical 
item an argument originates (see last slot of lcxi- 
cal entries). If an argument originates in an item 
(becmlsc it is e.g. its instance discourse referent 
or label) then the value of this argument is un- 
ambigous for the item 2. In adjunct\[on structures, 
the modified constituent assigns and the modifier 
receives the shared discourse referent. Consider 
the following example grammar 3. 
start symbol (s/\[_Event, _VerbL ,Top ,Top\] , 
\[Top\] ). Z originating argument 
s / \[Event, VerbL, DotaL, TopL\] ---> 
np/\[X,VerbL,DomL ,TopL\] , 
vp/\[Event, X, VerbL, DomL, TopL\] . 
vp/\[Event,X,VerbL,DomL,TopL\] ---> 
vt/\[Event,X,Y,VerbL,Domi\], 
np/\[Y,VerbL,DomL,TopL\]. 
np/\[X,VerbL,DomL,TopL\] ---> 
det/\[X,NounL,VerbL,DomL,TopL\], 
n/\[X,NounL,DomL,TopL\]. 
lex(a, det/\[X,Lab,VerbL,_DomL,TopL\], 
\[ leq(VerbL,Lab), 
leq(Lab,TopL), 
Lab:X 
\], \[X\] ). ~ originating argument 
eA similar train of thought lies behind the notion 
of "focus" proposed by Tomita (Tomita, 1985). A "fo- 
cus" in a rule is the constituent which gets assigned 
all argument fi'om the "ba(:kground" constituents of 
the rule. Ill general this notion of focus must be fein- 
t\[vised to individual argmnents. Constituent 1 can be 
focus with respect to argument i while constituent 2 
is focus for argument j in a rule. 
aThc Prolog symbol leq represents the UDRS sub- 
ordination relation <. 
910 
lex (every, de\] / \[X, ResL, VerbL ,DomL, _TopL\] , 
\[ leq (+Lab, Dotal ), 
leq (VerbL, S (opeL) , 
Lab : every (X, ResL, Sc opeL) 
1, 
\[X, Lab, ScopeL\] ). 
lex (man, n/IX, Lab, _DomL, _TopL\] , 
\[ Lab:man(X) 
\], 
\[Lab\] ). 
lex(saw, vt/\]Event ,X,Y ,Lab,DotaL\] , 
\[ Lab:see (Event,X,Y), 
leq (Lab ,DotaL) 
\], 
\]Lab,Event\] ) . 
Let us turn now t;o tim semanl;ie construction com- 
ponent;. The tree readings of the DPF correspond 
to the contexts of tim packed UDRS. The motiva- 
tion behind this layout is that; in most eases syn- 
taclic ambiguity has some impact on the semantic 
readings 4. The construction algorithm traverses 
the DPF and assigns to each vertex the argument 
list associated with its category in the semantic 
grammar. The arguments on this list are not argu- 
ments proper as they would be if only pm'se trees 
were considered, but fl, nctions fl'om contexts to 
arguments proper. These flmctions at'(.' total only 
tbr the root and the leaves, for inner nodes v they 
are restricted to the union D1 of the. context sets 
at \];he edges st;arl,ing at v. A predicate match1 
matches arguments proper as given in the lexical 
e.ntries and the starl;symbol de(:laratkm onto tim(- 
lions as used in the rules. 
Let D1 be a context set {dl,...,dn}, let 
LexArg be an argument as provided l)y a 
lexicM item or startsymbol declaration i, 
let Art be mt argument as occurring at- 
tached to a nonterminal on the right- 
hand side of a grammar rule. 
Then the predicate match1 unifies 
LexArg with Art if LexArg does not 
originate in I. If LexArg does, Arg 
is unified with the fimction {dl -9 
LexArg, . . . , dn -+ LcxAr.q}. 
Let us assume a boi,toln-ut) traversal of the parse 
forest and let e be the edge fi'om v to one of il;s suc- 
cessors w. Then the arguments already presenl; a 
at; w must be matched with the arguments pre- 
dicted for w by the semantic rule corresponding 
to e (predicate match2). Let D2 be the context 
set, assigned to e. Then only the argunmnt val- 
ues of the contexl, s in D2 are unified. In \],his way 
it is guaranteed l;hat argument matching is done 
4If several tree readings correspond to a single con- 
text (semantic reading) this is reeognised in the la.st 
step (determining unambiguous arguments) where the 
tree readings are merged. 
'~The boLl;ore-up ;kssuml)tion makes sure that ver- 
tex w has t)een treated. 
as it would be done in the underlying trees: Tile 
contexts clearly separate the information flow. 
Let D2 be the context set {dl,...,d,~} 
at e, let UpperArg be an argument as 
provided by the semantic rule corre- 
sponding to edge e, let LowerArg be an 
argument as attached to the vertex w. 
Then the predicate match2 unifies 
UpperArg with the restriction of the 
flmction LowerArg to the context;s 
in D2 {dl -~ vl,... ,d, ~ v,} (a subset 
of LowerArg). 
In the linM step the packed UDRS is traversed 
att(t flmetions whet'(; all eontexl;s point to a single 
value are replaced by this vahm. 
7 Comparison with Other 
Approaches 
This seel;ion discusses two evaluation criteria for 
approaches to semantic underspecification. The 
present, proposal is measured against the criteria, 
and so are the Minimal I/,eeursion Semantics ap- 
proach (Egg and Lebelh, 1995), the Radical Un- 
derspeeifieation approach (Pinkal, 1995), and the 
Core Language Engine approach (Alshawi, 1992). 
The first criterion is coverage. Several types of 
syntactic ambiguities can be distinguished. 
• adjunct\]on ambiguities (arising from attach- 
men\] of P Ps, adjectives, adverbial sllb clauses, 
and other modifiers) 
• coordinatkm ambiguities 
• 0-role assignment ambiguities (arising fi'om 
scrambling) 
• arnhiguities arising from multi-part-of-speech 
words (A subcase of this type of ambiguity is 
tit(; treatment of mlknown input words.) 
The MRS approach is restricted to adjunct\]on am- 
biguities, while the othex approaches are applica- 
ble to all the kinds of ambiguities mentioned. A 
drawback of the MRS approach might be that it 
generates semantic readings which are not licensed 
by the syntactic structure. To give an example 
consider the sentence l saw a 'man in the apart- 
merit with a telescope. MRS produces a spurious 
reading in which the PP with a telescope adjoins 
to the NP a man while the PP in the apartment 
modifies the hill sentence. Remember that MRS 
does not use. a parse forest as input structure but 
an arbitrary parse tree, i.e. one speeitic syntac- 
tic reading. MRS re-ambiguates the parse tree 
only afi;erwards within semantic constrn~:tion. At 
this point information about positions in the input; 
string is lost. 
Another test is the uschtlness of the represen- 
tation for fllrther processing. Such processes at'(.' 
• disambiguation by sort; hierarchies 
• theorem proving 
911 
--PPs 
n=l 
n=2 
n=3 
n=4 
n=5 
n=6 
n=7 
n=8 
Readings 
2 
5 
14 
42 
132 
429 
1430 
4862 
U-Nodes U-Time (per reading) 
75 msec (37.5 msec) 
180 msec (36.0 msec) 
430 msec (30.7 msec) 
1115 msec (26.5 msec) 
3145 msee (23.8 msec) 
10505 msec (24.5 msee) 
32195 msee (22.5 msec) 
131125 mscc (27.0 msec) 
16 
28 
43 
61 
82 
106 
133 
163 
S-Time (per reading ) 
15 msec (7.5 msec) 
70 msec (14.0 msec) 
355 msec (25.4 msec) 
2225 msec (53.0 msec) 
16895 msec (128.0 msec) 
176930 msec (412.4 msec) 
441630 msee (308.8 reset) 
4331120 msee (890.8 msee) 
Table 1: Result of Experiment 
• transfer and generation 
All these processes can successfully handle sco- 
pally underspecified structures (for sortal disam- 
biguation and transfer see the Core Language En- 
gine (Alshawi, 1992), for theorem proving see the 
Underspecified DRS formalism (Reyle, 1993)). In 
the Core Language Engine approach to syntactic 
underspecification the representation must be un- 
packed to perform disambiguation by sorts. This 
seems to be true for any approach relying on de- 
lay of semantic construction operations: In order 
to apply the sortal restrictions of, e.g., a verb to 
one of its argument discourse referents it must 
be known which discourse referents could possi- 
bly fill the argument slot. Moore and Alshawi (AI- 
shawl, 1992) explain their reluctance to apply sort 
restrictions already in the packed structure with 
the maintenance overhead in associating semantic 
records with vertices of the forest. In the packed 
UDRS approach the problem is handled by ex- 
plicitly enumerating all possible readings. Then, 
the maintenance effort is reduced to the effort of 
extrapolating the tree readings from the parse for- 
est. None of the compared approaches makes any 
claims about theorem proving and transfer. In 
the packed UDRS approach it is conceivable to 
delay actual disambiguation as long as possible: 
Apart from the potential representation of referen- 
tim ambiguities by functions packed UDRSs look 
exactly like UDRSs. So if only referentially unam- 
biguous conditions must be consulted in a proof, 
a UDRS theorem prover may be used. 
8 Efficiency 
This section reports on an experiment in which 
the efficiency of the proposed underspecified con- 
struction mechanism was measured against the 
cost of generating all UDRSs separately. Table 
1 compares the time behaviour of constructing 
one underspccified structure (U-Time) with the 
time needed for constructing of the whole bunch 
of specified structures (S-Time). The experiment 
was conducted on a SPARCstation 20 using in- 
put sentences of the form I saw a man (with a 
telescope ff . 
Visibly the time needed per reading remains ap- 
proximately constant in the construction of the 
underspecified representation whereas it grows 
sharply when the ambiguities are enumerated. 
References 
Hiyan Alshawi, ed. 1992. The Core Language Engine. 
MIT Press, Cambridge, Massachusetts. 
Hans Ulrich Block and Stefanie Schachtl. 1992. Trace 
and Unification Grammar. In Proceedings of the fif 
tecnth International Conference on Computational 
Linguistics, pages 87--94, Nantes, France, August. 
Johan Bos. 1995. Predicate Logic Unplugged. In 
Proceedings of the Tenth Amsterdam Colloquium, 
ILLC/Department of Philosophy, University of Am- 
sterdam, Amsterdam, Holland, December. 
Jochen D5rrc and Anch'eas Eisele. 1990. Feature 
Logic with Disiunctive Unification. In Proceedings 
of the 13th International Conference on Computa- 
tional Linguistics, Helsinki, Finland. 
Jay Earley. 1970. An Efficient Context-lh'ee P~rsing 
Algorithm. In Communications of the ACM, 13(2), 
pages 94-102, February. 
Markus Egg and Kai Lcbcth. 1995. Semantic un- 
derspecification and modifier attachment ambigui- 
ties. In James Kilbury, Richard Wiese (ed.), Inte- 
grative Ans\[itze in der Compulerlinguistik. Beitrilge 
zur 5. Faehtagung der Sektion Computerlinguistik 
der Deutschcn Gesellschaft fiir SprachuJissenschaft 
(DGfS), pages 19--24, Diisseldorf, Germany. 
Anette Frank aud Uwe Reyle. 1992. IIow to Cope 
with Scrambling and Scope. In GSrz, G. (ed.) 
KONVENS '92. Reihe Informatik aktuell, Springer 
Berlin, pages 121-130, N/irnberg, Germany. 
ttans Kamp and Uwe Reyle. 1993. From Discourse to 
Logic. Kluwer, Dordrecht, ttolland. 
Manfred Pinkal. 1995. Radical Underspecification. 
In Procc~lings of the Tenth Amsterdam Colloquium, 
ILLC/Department of Philosophy, University of Am- 
sterdazn, Amsterdam, IIolland, December. 
Uwe Reyle. 1993. Dealing with Ambiguities by Un- 
derspecification: Construction, Representation and 
Deduction. In Journal of Semantics, 10, 2, pages 
123-179. 
Masaru Tomita. 1985. Efficient Parsing for Natural 
Language. Kluwer, Dordrecht, Holland. 
912 
