A CONNECTIONIST PARSER 
FOR STRUCTURE UNIFICATION GRAMMAR 
James B. Henderson* 
Department of Computer and Information Science 
University of Pennsylvania 
200 South 33rd 
Philadelphia, PA 19104, USA 
(henders@linc.cis.upenn.edu) 
ABSTRACT 
This paper presents a connectionist syntactic 
parser which uses Structure Unification Grammar 
as its grammatical framework. The parser is im- 
plemented in a connectionist architecture which 
stores and dynamically manipulates symbolic rep- 
resentations, but which can't represent arbitrary 
disjunction and has bounded memory. These 
problems can be overcome with Structure Unifica- 
tion Grammar's extensive use of partial descrip- 
tions. 
INTRODUCTION 
The similarity between connectionist models of 
computation and neuron computation suggests 
that a study of syntactic parsing in a connection- 
ist computational architecture could lead to sig- 
nificant insights into ways natural language can 
be parsed efficiently. Unfortunately, previous in- 
vestigations into connectionist parsing (Cottrell, 
1989, Fanty, 1985, Selman and Hirst, 1987) have 
not been very successful. They cannot parse arbi- 
trarily long sentences and have inadequate gram- 
mar representations. However, the difficulties with 
connectionist parsing can be overcome by adopt- 
ing a different connectionist model of computa- 
tion, namely that proposed by Shastri and Ajjana- 
gadde (1990). This connectionist computational 
architecture differs from others in that it directly 
manifests the symbolic interpretation of the infor- 
mation it stores and manipulates. It also shares 
the massive parallelism, evidential reasoning abil- 
ity, and neurological plausibility of other connec- 
tionist architectures. Since virtually all charac- 
terizations of natural language syntax have relied 
heavily on symbolic representations, this architec- 
ture is ideally suited for the investigation of syn- 
tactic parsing. 
*This research was supported by ARO grant 
DAAL 03-89-C-0031, DARPA grant N00014-90-J- 
1863, NSF grant IRI 90-16592, and Ben Franklin grant 
91S.3078C-1. 
The computational architecture proposed by 
Shastri and Ajjanagadde (1990) provides a rather 
general purpose computing framework, but it does 
have significant limitations. A computing mod- 
ule can represent entities, store predications over 
those entities, and use pattern-action rules to ma- 
nipulate this stored information. This form of rep- 
resentation is very expressive, and pattern-action 
rules are a general purpose way to do compu- 
tation. However, this architecture has two lim- 
itations which pose difficult problems for pars- 
ing natural language. First, only a conjunction 
of predications can be stored. The architecture 
cannot represent arbitrary disjunction. This lim- 
itation implies that the parser's representation of 
syntactic structure must be able to leave unspec- 
ified the information which the input has not yet 
determined, rather than having a disjunction of 
more completely specified possibilities for com- 
pleting the sentence. Second, the memory ca- 
pacity of any module is bounded. The number 
of entities which can be stored is bounded by a 
small constant, and the number of predications 
per predicate is also bounded. These bounds pose 
problems for parsing because the syntactic struc- 
tures which need to be recovered can be arbitrarily 
large. This problem can be solved by allowing the 
parser to output the syntactic structure incremen- 
tally, thus allowing the parser to forget the infor- 
mation which it has already output and which it 
no longer needs to complete the parse. This tech- 
nique requires that the representation of syntactic 
structure be able to leave unspecified the informa- 
tion which has already been determined but which 
is no longer needed for the completion of the parse. 
Thus the limitations of the architecture mean that 
the parser's representation of syntactic structure 
must be able to leave unspecified both the infor- 
mation which the input has not yet determined 
and the information which is no longer needed. 
In order to comply with these requirements, 
the parser uses Structure Unification Grammar 
(Henderson, 1990) as its grammatical framework. 
SUG is a formalization of accumulating informa- 
144 
tion about the phrase structure of a sentence un- 
til a complete description of the sentence's phrase 
structure tree is constructed. Its extensive use 
of partial descriptions makes it ideally suited for 
dealing with the limitations of the architecture. 
This paper focuses on the parser's represen- 
tation of phrase structure information and on the 
way the parser accumulates this information dur- 
ing a parse. Brief descriptions of the grammar 
formalism and the implementation in the connec- 
tionist architecture are also given. Except where 
otherwise noted, a simulation of the implementa- 
tion has been written, and its grammar supports 
a small set of examples. A more extensive gram- 
mar is under development. SUG is clearly an ade- 
quate grammatical framework, due to its ability 
to straightforwardly simulate Feature Structure 
Based Tree Adjoining Grammar (Vijay-Shanker, 
1987), as well as other formalisms (Henderson, 
1990). Initial investigations suggest that the con- 
straints imposed by the parser do not interfere 
with this linguistic adequacy, and more extensive 
empirical verification of this claim is in progress. 
The remainder of this paper will first give an 
overview of Structure Unification Grammar, then 
present the parser design, and finally a sketch of 
its implementation. 
STRUCTURE UNIFICATION 
GRAMMAR 
Structure Unification Grammar is a formaliza- 
tion of accumulating information about the phrase 
structure of a sentence until this structure is com- 
pletely described. This information is specified in 
partial descriptions of phrase structure trees. An 
SUG grammar is simply a set of these descriptions. 
The descriptions cannot use disjunction or nega- 
tion, but their partiality makes them both flexi- 
ble enough and powerful enough to state what is 
known and only what is known where it is known. 
There is also a simple abstraction operation for 
SUG descriptions which allows unneeded informa- 
tion to be forgotten, as will be discussed in the 
section on the parser design. In an SUG deriva- 
tion, descriptions are combined by equating nodes. 
This way of combining descriptions is extremely 
flexible, thus allowing the parser to take full ad- 
vantage of the flexibility of SUG descriptions, and 
also providing for efficient parsing strategies. The 
final description produced by a derivation must 
completely describe some phrase structure tree. 
This tree is the result of the derivation. The de- 
sign of SUG incorporates ideas from Tree Adjoin- 
ing Grammar, Description Theory (Marcus et al., 
1983), Combinatory Categorial Grammar, Lexi- 
cal Functional Grammar, and Head-driven Phrase 
Structure Grammar. 
An SUG grammar is a set of partial descrip- 
tions of phrase structure trees. Each SUG gram- 
mar entry simply specifies an allowable grouping 
of information, thus expressing the information in- 
terdependencies. The language which SUG pro- 
vides for specifying these descriptions allows par- 
tiality both in the information about individual 
nodes, and (crucially) in the information about 
the structural relations between nodes. As in 
many formalisms, nodes are described with fea- 
ture structures. The use of feature structures al- 
lows unknown characteristics of a node to be left 
unspecified. Nodes are divided into nonterminals, 
which are arbitrary feature structures, and termi- 
nals, which are atomic instances of strings. Unlike 
most formalisms, SUG allows the specification of 
the structural relations to be equally partial. For 
example, if a description specifies children for a 
node, this does not preclude that node from ac- 
quiring other children, such as modifiers. This 
partiality also allows grammar entries to under- 
specify ordering constraints between nodes, thus 
allowing for variations in word order. This partial- 
ity in structural information is imperative to allow 
incremental parsing without disjunction (Marcus 
et al., 1983). In addition to the immediate domi- 
nance relation for specifying parent-child relation- 
ships and linear precedence for specifying ordering 
constraints, SUG allows chains of immediate dom- 
inance relationships to be partially specified using 
the dominance relation. A dominance constraint 
between two nodes specifies that there must be a 
chain of zero or more immediate dominance con- 
straints between the two nodes, but it does not 
say anything about the chain. This relation is 
necessary to express long distance dependencies in 
a single grammar entry. Some examples of SUG 
phrase structure descriptions are given in figure 1, 
and will be discussed below. 
A complete description of a phrase structure 
tree is constructed from the partial descriptions in 
an SUG grammar by conjoining a set of grammar 
entries and specifying how these descriptions share 
nodes. More formally, an SUG derivation starts 
with descriptions from the grammar, and in each 
step conjoins a set of one or more descriptions and 
adds zero or more statements of equality between 
nonterminal nodes. The description which results 
from a derivation step must be satisfiable, so the 
feature structures of any two equated nodes must 
unify and the resulting structural constraints must 
be consistent with some phrase structure tree. The 
final description produced by a derivation must 
be a complete description of some phrase struc- 
ture tree. This tree is the result of the derivation. 
The sentences generated by a derivation are all 
those terminal strings which are consistent with 
the ordering constraints on the resulting tree. Fig- 
145 
h AP-'~\[\] t N ~tet plzzat 
key: ~ x immediately "~h y is the head 
dominates y xj. feature value Y 
Y of x 
X 
', x dominates y x t x is a terminal 
\[\] empty feature 
x--~y x precedes y structure 
Figure 1: Example grammar entries. They can 
be combined to form a structure for the sentence 
"Who ate white pizza?". 
ure 2 shows an example derivation with one step 
in which all grammar entries are combined and 
all equations are done. This definition of deriva- 
tions provides a very flexible framework for investi- 
gating various parsing strategies. Any ordering of 
combining grammar entries and doing equations is 
a valid derivation. The only constraints on deriva- 
tions come from the meanings of the description 
primitives and from the need to have a unique re- 
sulting tree. This flexibility is crucial to allow the 
parser to compensate for the connectionist archi- 
tecture's limitations and to parse efficiently. 
Because the resulting description of an SUG 
derivation must be both a consistent description 
and a complete description of some tree, an SUG 
grammar entry can state both what is true about 
the phrase structure tree and what needs to be 
true. For a description to be complete it must 
specify a single immediate dominance tree and all 
terminals mentioned in the description must have 
some (possibly empty) string specified for them. 
Otherwise there would be no way to determine the 
exact tree structure or the word for each terminal 
in the resulting tree. A grammar entry can express 
grammatical requirements by not satisfying these 
completion requirements locally. For example, in 
figure 1 the structure for "ate" has a subject node 
with category NP and with a terminal as the val- 
ues of its head feature. Because this terminal does 
not have its word specified, this NP must equate 
with another NP node which does have a word for 
the value of its head feature. The unification of the 
two NP's feature structures will cause the equation 
of the two head terminals. In this way the struc- 
ture for "ate" expresses the fact that it obligatorily 
subcategorizes for a subject NP. The structure for 
"ate" also expresses its subcategorization for an 
object NP, but this object is not obligatory since 
it does not have an underspecified terminal head. 
Like the subject of "ate", the root of the structure 
for "white" in figure 1 has an underspecified ter- 
minal head. This expresses the fact that "white" 
obligatorily modifies N's. The need to construct 
a single immediate dominance tree is used in the 
structure for "who" to express the need for the 
subcategorized S to have an NP gap. Because the 
dominated NP node does not have an immediate 
parent, it must equate with some node which has 
an immediate parent. The site of this equation is 
the gap associated with "who". 
THE PARSER 
The parser presented in this paper accumulates 
phrase structure information in the same way as 
does Structure Unification Grammar. It calcu- 
lates SUG derivation steps using a small set of 
operations, and incrementally outputs the deriva- 
tion as it parses. The parser is implemented in 
the connectionist architecture proposed by Shastri 
and Ajjanagadde (1990) as a special purpose mod- 
ule for syntactic constituent structure parsing. An 
SUG description is stored in the module's mem- 
ory by representing nonterminal nodes as entities 
and all other needed information as predications 
over these nodes. If the parser starts to run out 
of memory space, then it can remove some nodes 
from the memory, thus forgetting all information 
about those nodes. The parser operations are im- 
plemented in pattern-action rules. As each word 
is input to the parser, one of these rules combines 
one of the word's grammar entries with the current 
description. When the parse is finished the parser 
checks to make sure it has produced a complete 
description of some phrase structure tree. 
THE GRAMMARS 
The grammars which are supported by the parser 
are a subset of those for Structure Unification 
Grammar. These grammars are for the most part 
lexicalized. Each lexicalized grammar entry is a 
rooted tree fragment with exactly one phoneti- 
cally realized terminal, which is the word of the 
entry. Such grammar entries specify what infor- 
mation is known about the phrase structure of 
the sentence given the presence of the word, and 
can be used (Henderson, 1990) to simulate Lexi- 
calized Tree Adjoining Grammar (Schabes, 1990). 
Nonlexical grammar entries are rooted tree frag- 
ments with no words. They can be used to ex- 
press constructions like reduced relative clauses, 
for which no lexical information is necessary. The 
146 
Ill' 
, - t 
I 
I 
I 
i ; 
1 
who t did t Barbie seet a 
il h 
/:; p!ct~, \!fS4h~\[\]~yest!r!ay, 
y,A, 
., 12I14  . ; i / i 
"7 : .4 h , ,, ..Nl;!!l!\l..,") 
who  did lhrbie  see  p cture o J yest 
i 
1 ~ayt 
xis u., l with y I 
Figure 2: A derivation for the sentence 'TVho did Barbie see a picture of yesterday".. 
current mechanism the parser uses to find possible 
long distance dependencies requires some informa- 
tion about possible extractions to be specified in 
grammar entries, despite the fact that this infor- 
mation currently only has meaning at the level of 
the parser. 
The primary limitations on the parser's abil- 
ity to parse the sentences derivable with a gram- 
max are due to the architecture's lack of disjunc- 
tion and limited memory capacity. Technically, 
constraints on long distance dependencies are en- 
forced by the parser's limited ability to calcu- 
late dominance relationships, but the definition 
of an SUG derivation could be changed to man- 
ifest these constraints. This new definition would 
be necessary to maintain the traditional split be- 
tween competence and performance phenomena. 
The remaining constraints imposed at the level of 
the parser are traditionally treated as performance 
constraints. For example, the parser's bounded 
memory prevents it from being able to parse arbi- 
trarily center embedded sentences or from allow- 
ing arbitrarily many phrases on the right frontier 
of a sentence to be modified. These are well es- 
tablished performance constraints on natural lan- 
guage (Chomsky, 1959, and many others). The 
lack of a disjunction operator limits the parser's 
ability to represent local ambiguities. This re- 
sults in some locally ambiguous grammatical sen- 
tences being unparsable. The existence of such 
sentences for the human parser, called garden path 
sentences, is also well documented (Bever, 1970, 
among others). The representations currently 
used for handling local ambiguities appear to be 
adequate for building the constituent structure of 
any non-garden path sentences. The full verifi- 
cation of this claim awaits a study of how effec- 
tively probabilistic constraints can be used to re- 
solve ambiguities. The work presented in this pa- 
per does not directly address the question of how 
ambiguities between possible predicate-argument 
structures are resolved. Also, the current parser 
is not intended to be a model of performance phe- 
nomena, although since the parser is intended to 
be computationally adequate, all limitations im- 
posed by the parser must fall within the set of 
performance constraints on natural language. 
THE PARSER DESIGN 
The parser follows SUG derivations, incrementally 
combining a grammar entry for each word with the 
description built from the previous words of the 
sentence. Like in SUG the intermediate descrip- 
tions can specify multiple rooted tree fragments, 
but the parser represents such a set as a list in or- 
der to represent the ordering between terminals in 
the fragments. The parser begins with a descrip- 
tion containing only an S node which needs a head. 
This description expresses the parser's expectation 
for a sentence. As each word is read, a gram- 
mar entry for that word is chosen and combined 147 
current grammar 
description: entry: 
~ ~ attaching 
=~. at x 
current grammar 
description: entry: 
,A r\ leftward attaching 
aty 
current grammar 
description: entry: 
Q 
current Z: 
or 
dominance 
instantiating 
at z 
current 
description: 
current grammar 
description: entry: 
//~ J/~ equa~onle~s 
~, ~ combining 
internal 
equation 
key: 
.~ x is the 
y host of y 
xis xi 
YO equatable 
with y 
Figure 3: The operations of the parser. 
with the current description using one of four com- 
bination operations. Nonlexical grammar entries 
can be combined with the current description at 
any time using the same operations. There is also 
an internal operation which equates two nodes al- 
ready in the current description without using a 
grammar entry. The parser outputs each opera- 
tion it does as it does them, thus providing incre- 
mental output to other language modules. After 
each operation the parser's representation of the 
current description is updated so that it fully re- 
flects the new information added by the operation. 
The five operations used by the parser axe 
shown in figure 3. The first combination opera- 
tion, called attaching, adds the grammar entry to 
the current description and equates the root of the 
grammar entry with some node already in the cur- 
rent description. The second, called dominance in- 
stantiating, equates a node without a parent in the 
current description with a node in the grammar 
entry, and equates the host of the unparented node 
with the root of the grammar entry. The host func- 
tion is used in the parser's mechanism for enforc- 
ing dominance constraints, and represents the fact 
that the unparented node is potentially dominated 
by its current host. In the case of long distance 
dependencies, a node's host is changed to nodes 
further and further down in the tree in a man- 
ner similar to slash passing in Generalized Phrase 
Structure Grammar, but the resulting domain of 
possible extractions is more similar to that of Tree 
Adjoining Grammar. The equationless combining 
operation simply adds a grammar entry to the end 
of the tree fragment list. This operation is some- 
times necessary in order to delay attachment de- 
cisions long enough to make the right choice. The 
leftward attaching operation equates the root of 
the tree fragment on the end of the list with some 
node in the grammar entry, as long as this root is 
not the initializing matrix S 1. The one parser op- 
eration which does not involve a grammar entry is 
called internal equating. When the parser's rep- 
resentation of the current description is updated 
so that it fully reflects newly added information, 
some potential equations are calculated for nodes 
which do not yet have immediate parents. The 
internal equating operation executes one of these 
potential equations. There are two cases when this 
can occur, equating fillers with gaps and equating 
a root of a tree fragment with a node in the next 
earlier tree fragment on the list. The later is how 
tree fragments are removed from the list. 
The bound on the number of entities which 
can be stored in the parser's memory requires that 
the parser be able to forget entities. The imple- 
mentation of the parser only represents nontermi- 
nal nodes as entities. The number of nontermi- 
nals in the memory is kept low simply by forget- 
ting nodes when the memory starts getting full, 
thereby also forgetting the predications over the 
nodes. This forgetting operation abstracts away 
from the existence of the forgotten node in the 
phrase structure. Once a node is forgotten it can 
no longer be equated with, so nodes which must 
be equated with in order for the total descrip- 
tion to be complete can not be forgotten. Forget- 
ting nodes may eliminate some otherwise possible 
parses, but it will never allow parses which violate 
1As of this writing the implementation of the tree 
fragment list and these later two combination opera- 
tions has been designed, but not coded in the simula- 
tion of the parser's implementation. 
148 
parser state : 
S h 
attaching 
S h 
Barbie t dominance instantiating 
h~rLie t~~ r~ forgetting 
hS 
equationless combining 
tit AP.,,h 
fashiolllab~\]yt 
Ba sest fashionablyt 
internal 
equating 
grammar entries : 
Barbiet Barbiet 
h - :VP 
dres~est 
\ 
fashionablyt 
h 
~esses t 
Figure 4: An example parse of "Barbie dresses fashionably". 
the forgotten constraints. Any forgetting strategy 
can be used as long as the only eliminated parses 
are for readings which people do not get. Several 
such strategies have been proposed in the litera- 
ture. 
As a simple example parse consider the parse 
of "Barbie dresses fashionably" sketched in fig- 
ure 4. The parser begins with an S which needs 
a head, and receives the word "Barbie". The un- 
derlined grammar entry is chosen because it can 
attach to the S in the current description using 
the attaching operation. The next word input is 
"dresses", and its verb grammar entry is chosen 
and combined with the current description using 
the dominance instantiating operation. In the re- 
sulting description the subject NP is no longer on 
the right frontier, so it will not be involved in any 
future equations and thus can be forgotten. Re- 
member that the output of the parser is incremen- 
tal, so forgetting the subject will not interfere with 
semantic interpretation. The next word input is 
"fashionably", which is a VP modifier. The parser 
could simply attach "fashionably", but for the pur- 
poses of exposition assume the parser is not sure 
where to attach this modifier, so it simply adds 
this grammar entry to the end of the tree frag- 
ment list using equationless combining. The up- 
dating rules of the parser then calculate that the 
VP root of this tree fragment could equate with 
the VP for "dresses", and it records this fact. The 
internal equating operation can then apply to do 
this equation, thereby choosing this attachment 
site for "fashionably". This technique can be used 
to delay resolving any attachment ambiguity. At 
this point the end of the sentence has been reached 
and the current description is complete, so a suc- 
cessful parse is signaled. 
Another example which illustrates the parser's 
ability to use underspecification to delay disam- 
biguation decisions is given in figure 5. The feature 
decomposition ~:A,:EV is used for the major cate- 
gories (N, V, A, and P) in order to allow the object 
of "know" to be underspecified as to whether it is 
of category i (\[-A,-V\]) or V (\[-A,TV\]). When 
149 
parser state : grammar entry: 
Barbiet knows t ~ at mant leftt 
Figure 5: Delaying the resolution of the ambigu- 
ity between "Barbie knows a man." and "Barbie 
knows a man left." 
"a man" is input the parser is not sure if it is the 
object of "know" or the subject of this object, so 
the structure for "a man" is simply added to the 
parser state using equationless combining. This 
underspecification can be maintained for as long 
as necessary, provided there are resources available 
to maintain it. If no verb is subsequently input 
then the NP can be equated with the -A node 
using internal equation, thus making "a man" the 
object of "know". If, as shown, a verb is input 
then leftward attaching can be used to attach "a 
man" as the subject of the verb, and then the 
verb's S node can be equated with the -A node to 
make it the object of "know". Since this parser is 
only concerned with constituent structure and not 
with predicate-argument structure, the fact that 
the -A node plays two different semantic roles in 
the two cases is not a problem. 
THE CONNECTIONIST 
IMPLEMENTATION 
The above parser is implemented using the con- 
nectionist computational architecture proposed by 
Shastri and Ajjanagadde (1990). This architecture 
solves the variable binding problem 2 by using units 
which pulse periodically, and representing differ- 
ent entities in different phases. Units which are 
storing predications about the same entity pulse 
synchronously, and units which are storing pred- 
ications about different entities pulse in different 
phases. The number of distinct entities which can 
be stored in a module's memory at one time is 
determined by the width of a pulse spike and the 
time between periodic firings (the period). Neuro- 
logically plausible estimates of these values put the 
maximum number of entities in the general vicin- 
ity of 7-4-2. The architecture does computation 
with sets of units which implement pattern-action 
rules. When such a set of units finds its pattern 
in the predications in the memory, it modifies the 
memory contents in accordance with its action and 
2The variable binding problem is keeping track of 
what predications are for what variables when more 
than one variable is being used. 
Figure 6: The architecture of the parser. 
the entity(s) which matched. 
This connectionist computational architecture 
is used to implement a special purpose module 
for syntactic constituent structure parsing. A di~ 
agram of the parser's architecture is shown in fig- 
ure 6. This parsing module uses its memory to 
store information about the phrase structure de- 
scription being built. Nonterminals are the enti- 
ties in the memory, and predications over nonter- 
minals are used to represent all the information 
the parser needs about the current description. 
Pattern-action rules are used to make changes to 
this information. Most of these rules implement 
the grammar. For each grammar entry there is 
a rule for each way of using that grammar en- 
try in a combination operation. The patterns for 
these rules look for nodes in the current descrip- 
tion where their grammar entry can be combined 
in their way. The actions for these rules add in- 
formation to the memory so as to represent the 
changes to the current description which result 
from their combination. If the grammar entry is 
lexical then its rules are only activated when its 
word is the next word in the sentence. A general 
purpose connectionist arbitrator is used to choose 
between multiple rule pattern matches, as with 
other disambiguation decisions 3. This arbitrator 
3Because a rule's pattern matches must be commu- 
nicated to the rule's action through an arbitrator, the 
existence and quality of a match must be specified in 
a single node's phase. For rules which involve more 
than one node, information about one of the nodes 
must be represented in the phase of the other node for 
the purposes of testing patterns. This is the purpose 
150 
weighs the preferences for the possible choices and 
makes a decision. This mechanism for doing dis- 
ambiguation allows higher level components of the 
language system to influence disambiguation by 
adding to the preferences of the arbitrator 4. It 
also allows probabilistic constraints such as lexi- 
cal preferences and structural biases to be used, 
although these aspects of the parser design have 
not yet been adequately investigated. Because the 
parser's grammar is implemented in rules which 
all compute in parallel, the speed of the parser 
is independent of the size of the grammar. The 
internal equating operation is implemented with 
a rule that looks for pairs of nodes which have 
been specified as possible equations, and equates 
them, provided that that equation is chosen by 
the arbitrator. Equation is done by translating 
all predications for one node to the phase of the 
other node, then forgetting the first node. The for- 
getting operation is implemented with links which 
suppress all predications stored for the node to be 
forgotten. The only other rules update the parser 
state to fully reflects any new information added 
by a grammar rule. These rules act whenever they 
apply, and include the calculation of equatability 
and host relationships. 
CONCLUSION 
This paper has given an overview of a connection- 
ist syntactic constituent structure parser which 
uses Structure Unification Grammar as its gram- 
matical framework. The connectionist computa- 
tional architecture which is used stores and dy- 
namically manipulates symbolic representations, 
thus making it ideally suited for syntactic parsing. 
However, the architecture's inability to represent 
arbitrary disjunction and its bounded memory ca- 
pacity pose problems for parsing. These difficul- 
ties can be overcome by using Structure Unifica- 
tion Grammar as the grammatical framework, due 
to SUG's extensive use of partial descriptions. 
This investigation has indeed led to insights 
into efficient natural language parsing. This 
parser's speed is independent of the size of its 
grammar. It only uses a bounded amount of mem- 
ory. Its output is incremental, monotonic, and 
does not include disjunction. Its disambiguation 
of the signal generation box in figure 6. For all such 
rules, the identity of one of the nodes can be deter- 
mined uniquely given the other node and the parser 
state. For example in the dominance instantiating op- 
eration, given the unparented node, the host of that 
node can be found because host is a function. This 
constraint on parser operations seems to have signifi- 
cant linguistic import, but more investigation of this 
possibility is necessary. 
4In the current simulation of the parser implemen- 
tation the arbitrators are controlled by the user. 
mechanism provides a parallel interface for the in- 
fluence of higher level language modules. Assum- 
ing neurologically plausible timing characteristics 
for the computing units of the connectionist archi- 
tecture, the parser's speed is roughly compatible 
with the speed of human speech. In the future the 
ability of this architecture to do evidential reason- 
ing should allow the use of statistical information 
in the parser, thus making use of both grammat- 
ical and statistical approaches to language in a 
single framework. 

REFERENCES 
Bever, Thomas G (1970). The cognitive basis for 
linguistic structures. In J. R. Hayes, editor, 
Cognition and the Development of Language. 
John Wiley, New York, NY. 
Chomsky, Noam (1959). On certain formal prop- 
erties of grammars. Information and Control, 
2: 137-167. 
Cottrell, Garrison Weeks (1989). A Connectionist 
Approach to Word Sense Disambiguation. Mor- 
gan Kaufmann Publishers, Los Altos, CA. 
Fanty, Mark (1985). Context-free parsing in con- 
nectionist networks. Technical Report TR174, 
University of Rochester, Rochester, NY. 
Henderson, James (1990). Structure unifica- 
tion grammar: A unifying framework for in- 
vestigating natural language. Technical Re- 
port MS-CIS-90-94, University of Pennsylvania, 
Philadelphia, PA. 
Marcus, Mitchell; Hindle, Donald; and Fleck, 
Margaret (1983). D-theory: Talking about talk- 
ing about trees. In Proceedings of the 21st An- 
nual Meeting of the ACL, Cambridge, MA. 
Schabes, Yves (1990). Mathematical and Compu- 
tational Aspects of Lexicalized Grammars. PhD 
thesis, University of Pennsylvania, Philadelphia, 
PA. 
Selman, Bart and Hirst, Graeme (1987). Pars- 
ing as an energy minimization problem. In 
Lawrence Davis, editor, Genetic Algorithms and 
Simulated Annealing, chapter 11, pages 141- 
154. Morgan Kaufmann Publishers, Los Altos, 
CA. 
Shastri, Lokendra and Ajjanagadde, Venkat 
(1990). From simple associations to system- 
atic reasoning: A connectionist representation 
of rules, variables and dynamic bindings. Tech- 
nical Report MS-CIS-90-05, University of Penn- 
sylvania, Philadelphia, PA. Revised Jan 1992. 
Vijay-Shanker, K. (1987). A Study of Tree Ad- 
joining Grammars. PhD thesis, University of 
Pennsylvania, Philadelphia, PA. 
