Multiple Interpreters in a 
Principle-Based Model of Sentence Processing 
Matthew W. Crocker 
e-mail: mwc@aipna.ed.ac.uk 
Department of Artificial Intelligence Human Communication Research Centre 
University of Edinburgh and University of Edinburgh 
80 South Bridge 2 Buccleuch Place 
Edinburgh, Scotland, EH1 1HN Edinburgh, Scotland, EH8 9LW 
Abstract 
This paper describes a computational model of human 
sentence processing based on the principles and pa- 
rameters paradigm of current linguistic theory. The 
syntactic processing model posits four modules, re- 
covering phrase structure, long-distance dependencies, 
coreference, and thematic structure. These four mod- 
ules are implemented as recta-interpreters over their 
relevant components of the grammar, permitting vari- 
ation in the deductive strategies employed by each 
module. These four interpreters are also 'coroutined' 
via the freeze directive of constraint logic program- 
ruing to achieve incremental interpretation across the 
modules. 
1 Introduction 
A central aim of computational psycholinguistics is the 
development of models of human sentence processing 
which account not only for empirical performance phe- 
nomena, but which also provide some insight into the 
nature of between parser and grammar relationship. 
In concurrent research, we are developing a model of 
sentence processing which has its roots in the princi- 
ples and parameters paradigm of syntactic theory \[1\], 
\[2\], which holds that a number of representations are 
involved in determining a well-formed analysis of an 
utterance. This, in conjunction with Fodor's Modu- 
larity Hypothesis \[6\], has led us to postulate a model 
which consists of four informationally encapsulated 
modules for recovering (1) phrase structure, (2) chains 
(3) coreference, and (4) thematic structure. 
In this paper we will briefly review a model of sen- 
tence processing which has been previously proposed 
in \[5\] and \[3\]. We will illustrate how this model can 
be naturally implemented within the logic program- 
ming paradigm. In particular, we sketch a subset of 
GB theory which defines principles in tern~ of their 
representational units, or schemas. We then discuss 
how the individual processors may be implemented as 
specialised, informationally encapsulated interpreters, 
and discuss how the 'freeze' directive of constraint 
logic programming can be used to effectively coroutine 
the interpreters, to achieve incremental interpretation 
and concurrency. 
2 The Processing Model 
In the proposed model, we assume that the sentence 
processor strives to optimise local comprehension and 
integration of incoming material, into the current con- 
text. That is, decisions about the current syntactic 
analysis are made incrementally (for each input item) 
on the basis of principles which are intended max- 
imise the overall interpretation. We have dubbed this 
the Principle of Incremental Comprehension (PIC), 
stated roughly as follows: 
(1) Principle of Incremental Comprehension: 
The sentence processor operates in such a 
way as to maximise comprehension of the 
sentence at each stage of processing. 
The PIC demands that the language comprehen- 
sion system (LCS), and any sub-system contained 
within it (such as the syntactic and semantic pro- 
cessors), apply maximally to any input, thereby con- 
structing a maximal, partial interpretation for a given 
partial input signal. This entails that each module 
within the LCS apply concurrently. 
The performance model is taken to be directly 
compatible with the modular, language universal, 
principle-based theory of current transformational 
grammar \[3\]. We further suggest a highly modular or- 
ganisation of the sentence processor wherein modules 
are determined by the syntactic representations they 
recover. This is motivated more generally by Fodor's 
Modularity Hypothesis \[6\] which argues that the var- 
ious perceptual/input systems consist of fast, dumb 
informationally encapsulated modules. Specifically, 
we posit four modules within the syntactic processor, 
each affiliated with a "representational" or "informa- 
tional" aspect of the grammar. These are outlined be- 
low in conjunction with the grammatical subsystems 
to which they are related1: 
1 This grouping of grammatical principles with representations 
is both partial and provisional, mad is intended only to give 
the reader a feel for the "natural classes" exploited by the 
model. 
185 - 
(2) 
Modules & Principles: 
Phrase structure (PS): 
Chains (ChS): 
Theta structure (TS): 
Coreference (CiS): 
F-theory, Move-~ 
Bounding, ECP 
0-theory 
Binding, Control 
In Figure 1, we illustrate one possible instance of 
the organisation within the Syntactic Processor. We 
assume that the phrase structure module drives pro- 
cessing based on lexical input, and that the thematic 
structure co-ordinates the relevant aspects of each pro- 
cessor for output to the semantic processor. 
t.~/c~ tnt,.t 
Chain I ! \[ I Coindexation 
Processor ~ Processor 
Thematic \] '" 
L___ -e.- Processor ~ .... 2 
Thematic Output 
Figure 1: Syntactic Processor Organisation 
Just as the PIC applies to the main modules of the 
LCS as discussed above, it also entails that all modules 
within the syntactic processor act concurrently so as 
to apply maximally for a par(ial input, as illustrated 
by the operation shown in Figure 2. For the partial 
input "What did John put ... ~, we can recover the 
partial phrase structure, including the trace in Infl 2. 
In addition, we can recover the chain linking the did to 
its deep structure position in Infl (e-l), and also the 
0-grid for the relation 'put' including the saturated 
agent role 'John'. We might also go one step further 
and postulate a trace as the direct object of put, which 
could be the 0-position of What, but this action might 
be incorrect if the sentence turned out to be What did 
John pui the book oaf, for example. 
3 Principles and Representations 
Before proceeding to a discussion of the model's im- 
plementation, we will first examine more closely the 
representational paradigm which is employed, and dis- 
cuss some aspects of the principles and parameters 
theory we have adopted, restricting our attention pri- 
marily to phrase structure and Chains. In general, a 
2 We assume here a head movement analysis, where the head of 
Infl moves to the head of Comp, to account for Subject-Aux 
inversion. 
I- 
I , \[What,..\] 
l I \[dld,e-I \] 
I 
"What did ~ohn put ..." 
' Spec 
' 'What 
i ! i , d/d 
, • NP ~\]~ 
• •: John "• I 
! •• e-I I ~ V ... 
I • I I" ,, put 
Irel: put 11 ragent: John 
:l grk'" i th.m,. 
i_L__ 12 __, 
Figure 2: Syntactic Processor Operation 
particular representation can be broken down into two 
fundamental components: 1) units of information, i.e. 
the 'nodes' or feature-bundles which are fundamental 
to the representation, and 2) units of structure, the 
minimal structural 'schema' for relating 'nodes' with 
each other. With these two notions defined, the rep- 
resentation can be viewed as some recursive instance 
of its particular schema over a collection of nodes. 
The representation of phrase structure (PS), as de- 
termined principally by ~'-theory, encodes the local, 
sister-hood relations and defines constituency. The 
bar-level notation is used to distinguish the status of 
satellites: 
k (3) (a) x s cific,, x 
(b) ~ --. Modifier,'U~ 
(c) ~-. Complements, X 
(d) X ~ Lexeme 
The linear precedence of satellites with respect to 
their sister X-nodes is taken to be parametrised for 
each category and language. The final rule (d) above, 
is simply the rule for lexical insertion. In addition to 
the canonical structures defined by ~--theory, we re- 
quire additional rules to permit Chomsky-adjunction 
of phrases to maximal projections, via Move-~, and 
the rules for inserting traces (or more generally, empty 
categories) -- a consequence of the Projection Princi- 
ple -- for moved heads and maximal projections. 
Given the rules above, we can see that possible 
phrase structures are limited to some combination of 
binary (non-terminal) and unary (terminal) branches. 
As discussed above, we can characterise the represen- 
tational framework in terms of nodes and schemas: 
186 - 
Phrase Structure Schema 
Node: N-Node: {Cat,Level, ID,Ftrs} 
T-Node: {Cat,Phon,ID,Ftrs} 
Schema: Branch: N-N ode/IN-Node,N-Node\] 
Branch: N-Node/T-Node 
Structure: Tree: N-Node/\[Treer.,TreeR\] 
Tree: N-Node/T-Node 
We allow two types of nodes: 1) non-terminals (N- 
Nodes), which are the nodes projected by X-theory, 
consisting of category, bar level, a unique ID, and the 
features projected from the head, and 2) terminals (T- 
Nodes), which are either lexical items or empty cat- 
egories, which lack bar level, but posses phonological 
features (although these may be 'nil' for some empty 
categories). The schema, defines the unit of structure, 
using the '/' to represent immediate dominance, and 
square brackets '\[... \]' to encode sister-hood and linear 
precedence. Using this notation we define the two pos- 
sible types of branches, binary and unary, where the 
latter is applicable just in case the daughter is a termi- 
nal node. The full PS representation (or Tree) is de- 
fined by allowing non-terminal daughters to dominate 
a recursive instance of the schema. It is interesting to 
note that, for phrase structure at least, the relevant 
principles of grammar can be stated purely as condi- 
tions on branches, rather that trees. More generally, 
We will assume the schema of a particular representa- 
tion provides a formal characterisation of locality. 
Just as phrase structure is defined in terms of 
branches, we can define Chains as a sequence of links. 
More specifically, each position contained by the chain 
'is a node, which represents its category and level (a 
phrase or a head), the status of that position (either 
A or A--), its ID (or location), and relevant features 
(such as L-marking, Case, and 0). If we adhere to the 
representational paradigm used above, we can define 
Chains in the following manner: 
Chain S chevaa 
Node: C-Node: {Cat,Level,Pos,ID,Ftrs} 
Schema: Link: <C-Nodei oo C-Nodej> 
Structure: Chain: \[ C-Node I Chain \] (where, 
<C-Node oo head(Chain)> ) 
Chain: \[ \] 
If we let 'co' denote the linking of two C-Nodes, 
then we can define a Chain to be an ordered fist of C- 
Nodes, such that successive C-Nodes satisfy the link 
relation. In the above definition we have used the 
'1' operator and list notation in the standard Prolog 
sense. The 'head' function returns the first C-Node in 
a (sub) Chain (possibly \[ \]), for purposes of satisfying 
the link relation. Furthermore, <C-Node co \[ \]> is 
a well-formed link denoting the tail, Deep-Structure 
position, of a Chain. Indeed, if this is the only link in 
the Chain we refer to it as a 'unit' Chain, representing 
an unmoved element. 
We noted above that each representation's schema 
provides a natural locality constraint. That is, we 
should be able to state relevant principles and con- 
straints locally, in terms of the schematic unit. This 
clearly holds for Subjacency, a well-formedness condi- 
tion which holds between two nodes of a link: 
(4) <C-Nodei co C-Nodej> ---, 
subjacent(C-Nodei,C-Nodej) 
Other Chain conditions include the Case filter and 
0-Criterion. The former stipulates that each NP 
Chain receive Case at the 'highest' A-position, while 
the latter entails that each argument Chain receive ex- 
actly one 0-role, assigned to the uniquely identifiable 
< C-Node# co \[ \] > link in a Chain. It is therefore 
possible to enforce both of these conditions on locally 
identifiable links of a Chain: 
(5) In an argument (NP) Chain, 
i) <C-Node- A- co C-NodeA> 
case-mark(C-Nodea) or, 
ii) C-NodeA - head(Chain) --* 
ease-mark(C-Nodea) 
In an argument Chain, 
<C-Nodes co \[\]> --, theta-mark(C-Node0) 
In describing the representation of a Chain, we have 
drawn upon Prolog's list notation. To carry this fur- 
ther, we can consider the link operator 'co' to be 
equivalent to the ',' separator in a list, such that for all 
\[... C-Nodei,C-Nodej ... \], C-Nodei co C-NOdej holds. 
In this way, we ensure that each node is well-formed 
with respect to adjacent nodes (i.e. in accordance with 
principles such as those identified in (4) & (5)). 
4 The Computational Model 
In the same manner that linguistic theory makes the 
distinction between competence (the grammar) and 
performance (the parser), logic programming distin- 
guishes the declarative specification of a program from 
its execution. A program specification consists of a set 
of axioms from which solution(s) can be proved as de- 
rived theorems. Within this paradigm, the nature of 
computation is determined by the inferencing strat- 
egy employed by the theorem prover. This aspect of 
logic programming has often been exploited for pars- 
ing; the so called Parsing as Deduction hypothesis. 
In particular it has been shown that meta.interpreters 
or program transformations can be used to affect the 
manner in which a logic grammar is parsed \[10\] \[1i\], 
Recently, there has been an attempt to extend .the 
PAD hypothesis beyond its application to simple logic 
grammars \[14\], \[13\] and \[8\]. In particular, Johnson 
has developed a prototype parser for a fragment of 
a GB grammar \[9\]. The system consists of a declara- 
tive specification of the GB model, which incorporates 
- 187- 
the various principles of grammar and multiple levels 
of representation. Johnson then illustrates how the 
fold/unfold transformation and goal freezing, when 
applied to various components of the grammar, can be 
used to render more or less efficient implementations. 
Unsurprisingly, this deductive approach to parsing in- 
herits a number of problems with automated deduc- 
tion in general. Real (implemented) theorem provers 
are, at least in the general case, incomplete. Indeed, 
we can imagine that a true, deductive implementation 
of GB would present a problem. Unlike traditional, 
homogeneous phrase structure grammars, GB makes 
use of abstract, modular principles, each of which may 
be relevant to only a particular type or level of repre- 
sentation. This modular, heterogeneous organisation 
therefore makes the task of deriving some single, spe- 
cialised interpreter with adequate coverage and effi- 
ciency, a very difficult one. 
4.1 Deduction in a Modular System 
In contrast with the single processor model employed 
by Johnson, the system we propose consists of a num- 
ber of processors over subsets of the grammar. Cen- 
tral to the model is a declarative specification of the 
principles of grammar, defined in terms of the rep- 
resentations listed in (2), as described in §3. If we 
take this specification of the grammar to be the "com- 
petence component", then the "performance compo- 
nent" can be stated as a parse relation which maps 
the input string to a well-formed "State", where State 
= { PS,TS,ChS,CiS }, the 4-tuple constituting all as- 
pects of syntactic analysis. The highest level of the 
parser specifies how each module may communicate 
with the others. Specifically, the PS processor acts 
as input to the other processors which construct their 
representations based on the PS representations and 
their own "representation specific" knowledge. In a 
weaker model, it may be possible for processors to in- 
spect the current State (i.e. the other representations) 
but crucially, no processor ever actually "constructs" 
another processor's representation. The communica- 
tion between modules is made explicit by the Prolog 
specification shown below: 
(6) parse(Lexlnput,State) :- 
State = {PS,TS,ChS,CiS}, 
ts.module(PS,TS), 
chs.xnodule(PS,ChS), 
cis_module(PS,CiS), 
ps_module(Lexlnput,PS). 
The parse relation defines the organisation of the 
processors as shown in Figure 1. The Prolog speci- 
fication above appears to suffer from the traditional 
depth-first, left-to-right computation strategy used by 
Prolog. That is, parse seems to imply the sequen- 
tial execution of each processor. As Stabler has illus- 
trated, however, it is possible to alter the computation 
rule used \[12\], so as to permit incremental interpreta- 
tion by each module: effectively coroutining the vari- 
ous modules. Specifically, Prolog's freeze directive al- 
lows processing of a predicate to be delayed temporar- 
ily until a particular argument variable is (partially) 
instantiated. In accord with the input dependencies 
shown in (7), each module is frozen (or 'waits') on its 
input: 
(7) \[- Input dependencies 
ts=module PS 
chs~odule PS 
cis_module PS 
ps.module LexIn'put 
Using this feature we may effectively "coroutine" 
the four modules, by freezing the PS processor on 
Input, and freezing the remaining processors on PS. 
Theresult is that each representation is constructed 
incrementally, at each stage of processing. To illus- 
trate this, consider once again the partial input string 
"What did John put ...'. The result of the call 
pars e ( \[what, did, john, put I 1, St at e) would yield 
the following instantiation of State (with the repre- 
sentations simplified for readability): 
(8) 
State -- { PS = cp/\[np/what, 
cl/\[c/did, 
ip/\[np/John 
il/\[i/trace-1, 
vp/\[v/put, _\]\]\]\], 
TS = \[rel:put,grid:\[agent:john \].\]\], 
ChS - \[\[what, _\], \[did,trace-l\] 1, 
CiS = _ } 
The PS representation has been constructed as 
mu6h as possible, including the trace of the moved 
head of Intl. The ChS represents a partial chain for 
what and the entire chain for did, which moved from 
its deep structure position to the head of CP, and "IS 
contains a partial 0-grid for the relation 'put', in which 
the Agent role as been saturated. 
This is reminiscent of Johnson's approach \[9\], but 
differs crucially in a number of respects. Firstly, we 
posit several processors which logically exploit the 
grammar, and it is these processors which are corou- 
tined, not the principles of grammar themselves. Each 
interpreter is responsible for recovering only one, ho- 
mogeneous representation, with respect to one input 
representation. This makes reasoning about the com- 
putational behaviour of individual processors much 
easier. At each stage of processing, the individual pro- 
censors increment their representations if and only if, 
for :the current input, there is a "theorem" provable 
from the grammar, which permits the new structure to 
be added. This me\[a-level "parsing as deduction" ap- 
proach permits more finely tuned control of the parser 
as a whole, and allows us to specify distinct inferenc- 
ing strategies for each interpreter, tailoring it to the 
particular representation. 
- 188- 
4.2 The PS-Module Specification 
Lexical ~ \[ Interpreter for ~ PS-Tree 
Input Phrase Structure Output 
! 
PS-Vlew: Mother/\[Left, Right\] \[ 
Mother/Terminal I 
X-Bar Theory 
XP"~ Specifwr, X' 
X' ~ Modifuer, X ° 
X' "~ Complemenzs, X 
X "~Lexeme 
Move-alpha 
XP ~ Adjunct, XP 
XP ~ trace 
X "~trace 
Figure 3: The Phrase Structure Module 
We have illustrated in §3 that the various represen- 
tations and grammatical principles may be defined in 
terms of their respective schematic units. Given this, 
the task of recovering representations (roughly pars- 
ing) is simply a matter of proving well-formed rep- 
resentations, as recursive instances of 'schematic ax- 
ioms', i.e. those instantiations of a schema which are 
considered well-formed by the grammar. The form 
of the PS-Module can be depicted as in Figure 3. 
The PS interpreter incorporates lexical input into the 
phrase structure tree based on possible structures al- 
lowed by the grammar. Possible structures are deter- 
mined by the ps_view relation, which returns those 
possible instantiations of the PS schema (as described 
in §3) which are well-formed with respect to the rele- 
vant principles of grammar. In general, ps_view will 
return any possible branch structure licensed by the 
grammar, but is usually constrained by partial instan- 
tiation of the query. In cases where multiple analyses 
are possible, the ps_view predicate may use some se- 
lection rule to choose between them 3. The following 
is a specification of the PS interpreter: 
(9) ps_module(X-X0,Node/\[L/LD,R/RD\]) : - 
non_lexical(Node), 
ps.view(Node/\[L,R\]), 
ps_module(X-X1,L/LD), 
ps_module(Xl-X0,R/RD). 
ps.module(X-X0,Node/Daughters) :- 
ps_ec.eval(X-X0,Node/Daughters). 
ps.module(X-X0,Node/Daughters) :- 
psAex_e val( X- X O,N ode/ Daughters). 
As we have discussed above, the ps..module is frozen 
on lexical input represented here as as difference-list. 
This is one way in which we might implement attachment 
principles to account for human preferences, see Crocker \[4\] 
for discussion. 
The top-level of the PS interpreter is broken down 
into three possible cases. The first handles non-lexicai 
nodes, i.e. those of category C or I, since phrase struc- 
ture for these categories is not lexically determined, 
and can be derived 'top-down', strictly from the gram- 
mar. We can, for example, automatically hypothesize 
a Subject specifier and VP complement for Intl. The 
second clause deals with the postulation of empty cat- 
egories, while the third can be considered the 'base' 
case which simply attaches lexical material. Roughly, 
ps.ec_eval attempts to derive a leaf which is a trace. 
This action is then verified by the concurrent Chain 
processor, which determines whether or not the trace 
is licensed (see the following section). This imple- 
ments an approximation of the filler-driven strategy 
for identifying traces, a strategy widely accepted in 
the psycholinguistic literature 4. 
4.3 The Chain-Module Specification 
Just as the phrase structure processor is delayed on 
lexical input, the chain processor is frozen with re- 
spect to phrase structure. The organisation of the 
Chain Module is shown in Figure 4, and is virtually 
identical to that of the PS Module (in Figure 3). How- 
ever rather than recovering branches of phrase struc- 
ture, it recovers links of chains, determining their well- 
formedness with respect to the relevant grammatical 
axioms. 
PS-Tree ~ Interpreter for Chains 
Output Chain Structure Output 
tit 
\[ C-Nodal, C-Node2 \] l Chain-View: 
\[ C-Node, \[l I L/' \x, 
SubJacency: 
\[ C-Nodal, C.Node 2 \] -~ subjacent(C-Nodal,C-Node2) 
Theta-Crlterion: 
\[ C-Node, \[\] \] "~ theta-marked(C-Node) 
A-to-A-bar Constraint: 
\[ C-Node1, C-Node 2 \] ~ not(a-pos(C-Nodel) and 
a-bar-pos( C-Node2 ) ) 
Figure 4: The Chain Module 
For this module, incremental processing is imple- 
mented by 'freezing' with respect to the input tree 
representation. The following code illustrates how the 
top-level of the Chain interpreter can traverse the PS 
tree, such that it is coroutined with the recovery of 
the PS representation: 
4 The is roughly the Active Filler Strateoy \[7\]. For discussion 
on implementing such strategies within the present model see 
\[4\]. 
- 189 - 
(10) chs_module(X/\[L/LD,R/RD\],CS) : - 
chain_int(X/\[L,R\],CS), 
chs_module(L/LD,CS), 
chs.module(R/RD,CS). 
chs_module(X/Leaf, CS) :- 
chain_int(X/Leaf, CS). 
I will assume that cheJodule is frozen such that 
it will only execute if the daughter(s) of the current 
sub-tree is instantiated. Given this, che.~odnle will 
perform a top-down traversal of the PS tree, delaying 
when the daughters are uninstantiated, thus corou- 
tined with the PS-module. The chain_inl~ predicate 
then determines if any action is to be taken, for the 
current branch, by the chain interpreter: 
(11) chain.int(X/\[Satellite,Right\],CS) : - 
visible(X/\[Satellite,Right\],C-Node), 
chain_member(C-Nodes,CS). 
chain_int (X/\[Left,Satellite\],CS) : - 
visible(X/\[Left,Satellite\],C-Node), 
chain.member(C-Nodes,CS). 
The chain ~ut predicate decides whether or not 
the satellite of the current branch is relevant, or 
'visible' to the Chain interpreter, and if so returns 
an appropriate C-Node for that element. The two 
visible entities are antecedents, i.e. arguments (if 
we assume that all arguments form chains, possibly 
of unit length) or elements in an ~ positions (such 
as \[Spec,CP\] or a Chomsky-adjoined position) and 
traces. If a trace or an antecedent is identified, then 
it must be a member of a well-formed chain. The 
chain.~ember predicate postulates new chains for lex- 
ical antecedents, and attempts to append traces to ex- 
isting chains. This operation must in turn satisfy the 
chain_view relation, to ensure the added link obeys 
the relevant grammatical constraints. 
5 Summary and Discussion 
In constructing a computational model of the pro- 
posed theory of processing, we have employed the logic 
programming paradigm which permits the transpar- 
ent distinction between competence and performance. 
At the highest level, we have a simple specification 
of the models organisation, in addition we have em- 
ployed a 'freeze' control strategy which permits us to 
coroutine the individual processors, permitting max- 
imal incremental interpretation. The individual pro- 
cessors consist of specialised interpreters which are in 
turn designed to perform incrementally. The inter- 
preters construct their representations, by incremen- 
tally adding units of structure which are locally well- 
formed with respect to the principles of the module. 
The implementation is intended to allow some flex- 
ibility in specifying the grammatical principles, and 
varying the control strategies of various modules. It 
is possible that some instantiations of the syntactic 
theory will prove more or less compatible with the 
processing model. It is hoped that such results may 
point the way to a more unified theory of grammar 
and processing or will at least shed greater light on 
the nature of their relationship. 
Acknowledgements 
I would like to thank Elisabet Engdahl and Robin 
Cooper for their comments on various aspects of this 
work. This research was conducted under the sup- 
port of an ORS award, an Edinburgh University Stu- 
dentship and the Human Communication Research 
Centre. 
References 
\[1\] N. Chomsky. Barriers. Linguistic Inquiry Mono- 
graph Thirteen, The MIT Press, Cambridge, Mas- 
sachusetts, 1986. 
\[2\] N. Chomsky. Knowledge of Language: Its Nature, 
Origin and Use. Convergence Series, Praeger, 
New York, 1986. 
\[3\] M. Crocker. Inerementality and Modularity in 
a Principle-Based Model of Sentence Process- 
ing. Presented at The Workshop on GB-Parsing, 
Geneva, Switzerland, 1990. 
\[4\] M. Crocker. Multiple Meta-Interpreters in a Log- 
ical Model of Sentence Processing. In Brown and 
Koch, editors, Natural Language Understanding 
and Logic Programming, III, Elsevier Science 
Publishers (North-Holland), (to appear). 
\[5\] M. Crocker. Principle-Based Sentence Process. 
ing: A Cross-Linguistic Account. HCRC/RP 1, 
Human Communication Research Centre, Uni- 
versity of Edinburgh, U.K., March 1990. 
\[6\] J. Fodor. Modularity of Mind. MIT Press, Cam- 
bridge, Massachusetts, 1983. 
\[7\] L. Frazier and C. Clifton. Successive Cyclicity in 
the Grammar and Parser. Language and Cogni, 
tire Processes, 4(2):93-126, 1989. 
\[8\] M. Johnson. Program Transformation Tech- 
niques for Deductive Parsing. In Brown and 
Koch, editors, Natural Language Understanding 
and Logic Programming, III, Elsevier Science 
Publishers (North-Holland), (to appear). 
\[9\] M. Johnson. Use of Knowledge of Lan- 
guage. Journal of Psycholinguistic Research, 
18(1), 1989. 
\[10\] F. Pereira and D. Warren. Parsing as Deduction. 
In Proceedings of Twenty-First Conference of the 
ACL, Cambridge, Massachusetts, 1983. 
\[11\] F. Pereira and S. Shieber. Prolog and Natural- 
Language Analysis. CSLI Lecture Notes, Center 
for the Study of Language and Information, Stan- 
ford, California, 1987. 
\[12\] E. Stabler. Avoid the pedestrian's paradox, un- 
published ms., Dept. of Linguistics, UCLA, 1989. 
\[13\] E. Stabler. Relaxation Techniques for Principle- 
Based Parsing. Presented at The Workshop on 
GB Parsing, Geneva, Switzerland, 1990. 
\[14\] E. Stabler. The Logical Approach to Syntaz. The 
MIT Press, Cambridge, Massachusetts, (forth- coming). 
190 - 
