Memoization of Coroutined Constraints 
Mark Johnson 
Cognitive and Linguistic Sciences, Box 1978 
Brown University 
Providence, l~I 02912, USA 
Mark_Johnson~Brown.edu 
Jochen DSrre* 
Institut fiir maschinelle Sprachverarbeitung 
Universit~it Stuttgart 
D-70174 Stuttgart, Germany 
Jochen.Doerre~ims.uni-stuttgart.de 
Abstract 
Some linguistic constraints cannot be effec- 
tively resolved during parsing at the loca- 
tion in which they are most naturally intro- 
duced. This paper shows how constraints 
can be propagated in a memoizing parser 
(such as a chart parser) in much the same 
way that variable bindings are, providing a 
general treatment of constraint coroutining 
in memoization. Prolog code for a sim- 
ple application of our technique to Bouma 
and van Noord's (1994) categorial gram- 
mar analysis of Dutch is provided. 
1 Introduction 
As the examples discussed below show, some lin- 
guistic constraints cannot be effectively resolved du- 
ring parsing at the location in which they are most 
naturally introduced. In a backtracking parser, a 
natural way of dealing with such constraints is to 
coroutine them with the other parsing processes, re- 
ducing them only when the parse tree is sufficiently 
instantiated so that they can be deterministically 
resolved. Such parsers are particularly easy to im- 
plement in extended versions of Prolog (such as Pro- 
loglI, SICStus Prolog and Eclipse) which have such 
coroutining facilities built-in. Like all backtracking 
parsers, they can exhibit non-termination and expo- 
nential parse times in situations where memoizing 
parsers (such as chart parsers) can terminate in po- 
lynomial time. Unfortunately, the coroutining ap- 
proach, which requires that constraints share varia- 
bles in order to communicate, seems to be incompa- 
tible with standard memoization techniques, which 
*This research was largely conducted at the Institut 
ffir maschinelle Sprachverarbeitung in Stuttgart. We 
would like to thank Andreas Eisele, Pascal van Hen- 
tenryck, Martin Kay, Fernando Pereira, Edward Stabler 
and our colleagues at the Institut ffir maschinelle Sprach- 
verarbeitung for helpful comments and suggestions. All 
remaining errors are our own. The Prolog code presen- 
ted in this paper is available via anonymous ftp from Ix.cog.brown.edu as/pub/lernrna.tar.Z 
require systematic variable-renaming (i.e., copying) 
in order to avoid spurious variable binding. 
For generality, conciseness and precision, we for- 
malize our approach to memoization and constraints 
within H6hfeld and Smolka's (1988) general theory 
of Constraint Logic Programming (CLP), but we 
discuss how our method can be applied to mote stan- 
dard chart parsing as well. This paper extends our 
previous work reported in DSrre (1993) and John- 
son (1993) by generalizing those methods to arbi- 
trary constraint systems (including feature-structure 
constraints), even though for reasons of space such 
systems are not discussed here. 
2 Lexical rules in Categorial 
Grammar 
This section reviews Bouma and van Noord's (1994) 
(BN henceforth) constraint-based categorial gram- 
mar analysis of modification in Dutch, which we use 
as our primary example in this paper. However, 
the memoizing CLP interpreter presented below has 
also been applied to GB and HPSG parsing, both of 
which benefit from constraint coroutining in parsing. 
BN can explain a number of puzzling scope phe- 
nomena by proposing that heads (specifically, verbs) 
subcategorize for adjuncts as well as arguments (rat- 
her than allowing adjuncts to subcategorize for the 
arguments they modify, as is standard in Categorial 
Grammar). For example, the first reading of the 
Dutch sentence 
(1) Frits opzettelijk Marie lijkt te ontwijken 
deliberately seems avoid 
'Fritz deliberately seems to avoid Marie' 
'Fritz seems to deliberately avoid Marie' 
is obtained by the analysis depicted in Figure 1. The 
other reading of this sentence is produced by a de- 
rivation in which the adjunct addition rule 'A' adds 
an adjunct to lijkt re, and applies vacuously to ont- 
wijken. 
It is easy to formalize this kind of grammar in pure 
Prolog. In order to simplify the presentation of the 
proof procedure interpreter below, we write clauses 
100 
Marie 
opzettelijk NP2 VPI\ADV\NP2 
lijkt te 
VPt/VP.___.__.___~I A ontwijken 
(VPI\ADV\ VPI"/yP1pI\ADV\NP2)NP2)/D(V D v(V~NP2)VP'\NP2 A 
Frits ADV VPt\ADV 
NP1 VP1 
Figure 1: The BN analysis of (1). In this derivation 'VPI' abbreviates 'S\NPI', 'A' is a lexieal rule which 
adds adjuncts to verbs, 'D' is a lexical 'division' rule which enables a control or raising verb to combine with 
arguments of higher arity, and 'D' is a unary modal operator which diacritically marks infinitival verbs. 
as 'H : :- B' where H is an atom (the head) and B 
is a list of atoms (the negative literals). 
The atom x(Cat, Left, Right) is true iff the sub- 
string between the two string positions Left and 
Right can be analyzed as belonging to category Cat. 
(As is standard, we use suffixes of the input string 
for string positions). 
The modal operator '~' is used to diacritically 
mark untensed verbs (e.g., ontwijken), and prevent 
them from combining with their arguments. Thus 
untensed verbs must combine with other verbs which 
subcategorize for them (e.g., lijkt re), forcing all 
verbs to appear in a 'verb cluster' at the end of a 
clause. 
For simplicity we have not provided a semantics 
here, but it is easy to add a 'semantic interpretation' 
as a fourth argument in the usual manner. The for- 
ward and backward application rules are specified as 
clauses of x/3. Note that the application rules are 
left-recursive, so a top-down parser will in general 
fail to terminate with such a grammar. 
:- op(990, xfx, ::- ). 
:- op(400, yfx, \ ). 
:- op(300, fy, # ). 
X Clause operator 
X Backward combinator 
X Modal operator b' 
x(X, Left, Right) ::- \[ ~ Forward application 
x(X/Y, Left, Mid), 
x(Y, Mid, Right) \]. 
x(X, Left, Right) ::- \[ ~ Backward application 
x(Y, Left, Mid), 
x(X\Y, Mid, Right) \]. 
x(I, \[Word\[Words\], Words) ::- \[ 
lex(Word, X) \]. 
Lexical entries are formalized using a two place re- 
lation lex(W0rd, Cat), which is true if Cat is a ca- 
tegory that the lexicon assigns to Word. 
lex('Frits', np) ::- ~. 
lex('Marie', np) ::- \[\]. 
lex(opzettelijk, adv) ::- D. 
lex(ont2ijken, #I ) ::- \[ 
add_adjunots(s~np~np, I ) \]. 
lex(lijkt_te, I / #Y ) ::- \[ 
add_adjuncts((s\np)/(s\np), IO), 
division(IO, I/Y ) \]. 
The add_adjuncts/2 and division/2 predicates 
formalize the lexical rules 'A' (which adds adjuncts 
to verbs) and 'D' (the division rule). 
add_adjuncts(s, s) ::- ~. 
add_adjuncts(I, Y\adv) ::- \[ 
add_adjuncts(I, Y) \]. 
add_adjuncts(I\£, Y\A) ::- \[ 
add_adjuncts(X, Y) \]. 
add_adjuncts(I/A, T/A) ::- \[ 
add_adjunc~s(l, T) 3. 
division(I, I) ::- \[\]. 
division(XO/YO, (I\Z)/(Y\Z)) ::- \[ 
division(IO/YO, I/Y) \]. 
Note that the definitions of add_adjuncSs/2 and division/2 
are recursive, and have an infinite num- 
ber of solutions when only their first arguments are 
instantiated. This is necessary because the num- 
ber of adjuncts that can be associated with any 
given verb is unbounded. Thus it is infeasible 
to enumerate all of the categories that could be 
associated with a verb when it is retrieved from 
the lexicon, so following BN, we treat the predica- 
tes add_adjlmcts/2 and division/2 as coroutined 
constraints which are only resolved when their se- 
cond arguments become sufficiently instantiated. 
As noted above, this kind of constraint corouti- 
ning is built-in to a number of Prolog implemen- 
tations. Unfortunately, the left recursion inherent 
in the combinatory rules mentioned earlier dooms 
any standard backtracking top-down parser to non- 
termination, no matter how coroutining is applied to 
101 
the lexical constraints. As is well-known, memoizing 
parsers do not suffer from this deficiency, and we 
present a memoizing interpreter below which does 
terminate. 
3 The Lemma Table proof procedure 
This section presents a coroutining, memoizing CLP 
proof procedure. The basic intuition behind our ap- 
proach is quite natural in a CLP setting like the one 
of HShfeld and Smolka, which we sketch now. 
A program is a set of definite clauses of the form 
p(x) ql(Xl) ^... ^ q.(X.) ^ ¢ 
where the Xi are vectors of variables, p(X) and 
qi(Xi) are relational atoms and ¢ is a basic cons- 
traint coming from a basic constraint language C. ¢~ 
will typically refer to some (or all) of the variables 
mentioned. The language of basic constraints is clo- 
sed under conjunction and comes with (computable) 
notions of consistency (of a constraint) and entail- 
ment (¢1 ~c ¢2) which have to be invariant under 
variable renaming} Given a program P and a goal 
G, which is a conjunction of relational atoms and 
constraints, a P-answer of G is defined as a consi- 
stent basic constraint ¢ such that ¢ --+ G is valid in 
every model of P. SLD-resolution is generalized in 
this setting by performing resolution only on rela- 
tional atoms and simplifying (conjunctions of) basic 
constraints thus collected in the goal list. When fi- 
nally only a consistent basic constraint remains, this 
is an answer constraint ¢. Observe that this use of 
basic constraints generalizes the use of substitutions 
in ordinary logic programming and the (simplifica- 
tion of a) conjunction of constraints generalizes uni- 
fication. Actually, pure Prolog can be viewed as a 
syntactically sugared variant of such a CLP language 
with equality constraints as basic constraints, where 
a standard Prolog clause 
p(T) ~- ql (T,),..., qn (T,) 
is seen as an abbreviation for a clause in which 
the equality constraints have been made explicit by 
means of new variables and new equalities 
p(X) ,--- X=T, XI--T,,...,Xn=T,, q,(x,,). 
Here the Xl are vectors of variables and the T/ are 
vectors of terms. 
Now consider a standard memoizing proof proce- 
dure such as Earley Deduction (Pereira and War- 
ren 1983) or the memoizing procedures described 
by Tamaki and Sato (1986), Vieille (1989) or War- 
ren (1992) from this perspective. Each memoized 
goal is associated with a set of bindings for its ar- 
guments; so in CLP terms each memoized goal is a 
1This essentially means that basic constraints can be 
recast as first-order predicates. 
conjunction of a single relational atom and zero or 
more equality constraints. A completed (i.e., ato- 
mic) clause p(T) with an instantiated argument T 
abbreviates the non-atomic clause p(X) ~ X - T, 
where the equality constraint makes the instantia- 
tion specific. Such equality constraints are 'inheri- 
ted' via resolution by any clause that resolves with 
the completed clause. 
In the CLP perspective, variable-binding or equa- 
lity constraints have no special status; informally, 
all constraints can be treated in the same way that 
pure Prolog treats equality constraints. This is the 
central insight behind the Lemma Table proof proce- 
dure: general constraints are permitted to propagate 
into and out of subcomputations in the same way 
that Earley Deduction propagates variable bindings. 
Thus the Lemma Table proof procedure generalizes 
Earley Deduction in the following ways: 
1. Memoized goals are in general conjunctions of 
relational atoms and constraints. This allows 
constraints to be passed into a memoized sub- 
computation. 
We do not use this capability in the categorial 
grammar example (except to pass in variable 
bindings), but it is important in GB and HPSG 
parsing applications. For example, memoized 
goals in our GB parser consist of conjunctions 
of X' and ECP constraints. Because the X' 
phrase-structure rules freely permit empty ca- 
tegories every string has infinitely many well- 
formed analyses that satisfy the X' constraints, 
but the conjoined ECP constraint rules out all 
but a very few of these empty nodes. 
2. Completed clauses can contain arbitrary ne- 
gative literals (rather than just equality cons- 
traints, as in Earley Deduction). This allows 
constraints to be passed out ofa memoized sub- 
computation. 
In the categorial grammar example, the 
add_adjuncts/2 and division/2 associated 
with a lexical entry cannot be finitely resolved, 
as noted above, so e.g., a clause 
x(#X, \[onl:wijken\], r-I) ::- 
\[ add_adjuncl;s(s\np\np, Z ) \]. 
. 
is classified as a completed clause; the 
add_adjuncts/2 constraint in its body is inhe- 
rited by any clause which uses this lemma. 
Subgoals can be selected in any order (Earley 
Deduction always selects goals in left-to-right 
order). This allows constraint eoroutining wi- 
thin a memoized subcomputation. 
In the categorial grammar example, a cate- 
gory becomes more instantiated when it com- 
bines with arguments, allowing eventually the 
add_adjuncts/2 and division/2 to be deter- 
ministically resolved. Thus we use the flexibility 
102 
in the selection of goals to run constraints whe- 
never their arguments are sufficiently instantia- 
ted, and delay them otherwise. 
4. Memoization can be selectively applied (Earley 
Deduction memoizes every computational step). 
This can significantly improve overall efficiency. 
In the categorial grammar example only x/3 
goals are memoized (and thus only these goals 
incur the cost of table management). 
The 'abstraction' step, which is used in most me- 
moizing systems (including complex feature gram- 
mar chart parsers where it is somewhat confusingly 
called 'restriction', as in Shieber 1985), receives an 
elegant treatment in a CLP approach; an 'abstrac- 
ted' goal is merely one in which not all of the equality 
constraints associated with the variables appearing 
in the goal are selected with that goal. 2 
For example, because of the backward application 
rule and the left-to-right evaluation our parser uses, 
eventually it will search at every left string position 
for an uninstantiated category (the variable Y in the 
clause), we might as well abstract all memoized goals 
of the form x(C, L, R) to x(_, L, _), i.e., goals in which 
the category and right string position are uninstan- 
tinted. Making the equality constraints explicit, we 
see that the abstracted goal is obtained by merely 
selecting the underlined subset of these below: 
x(Xl,X2, X3),Xl = C, X2 = L, Xa = R. 
While our formal presentation does not discuss ab- 
straction (since it can be implemented in terms of 
constraint selection as just described), because our 
implementation uses the underlying Prolog's unifi- 
cation mechanism to solve equality constraints over 
terms, it provides an explicit abstraction operation. 
Now we turn to the specification of the algorithm 
itself, beginning with the basic computational enti- 
ties it uses. 
Definition 1 A (generalized) goal is a multiset of 
relational atoms and constraints. A (generalized) 
clause Ho 4-- Bo is an ordered pair of generalized 
goals, where /fro contains at least one relational 
atom. A relational interpretation .4 (see HShfeld 
and Smolka 1988 for definition) satisfies a goal G iff 
.A satisfies each element of G, and it satisfies a clause 
H0 *--- B0 iff either .A fails to satisfy some element of 
B0 or .A satisfies each element of H0. 
2After this paper was accepted, we discovered that a 
more general formulation of abstraction is required for 
systems using a hierarchy of types, such as typed feature 
structure constraints (Carpenter 1992). In applications 
of the Lemma Table Proof Procedure to such systems it 
may be desirable to abstract from a 'strong' type cons- 
tralnt in the body of a clause to a logically 'weaker' type 
constraint in the memoized goal. Such a form of ab- 
straction cannot be implemented using the selection rule 
alone. 
This generalizes the standard notion of clause by 
allowing the head H0 to consist of more than one 
atom. The head H0 is interpreted conjunctively; i.e., 
if each element of B0 is true, then so is each element 
of H0. The standard definition of resolution extends 
unproblematically to such clauses. 
Definition 2 We say that a clause co - H0 ~ B0 
resolves with a clause cl = Ht ~-- BI on a non-empty 
set ofliterals C C_ Bo iff there is a variant Cl ~ of el of 
the form C *--- BI' such that V(co)NV(Bx') C V(C) 
(i.e., the variables common to e0 and BI ~ also appear 
in C, so there is no accidental variable sharing). 
If Co resolves with Cl on C, then the clause 
H0 ~ (B0 - C) U Bx' is called a resolvent of co with 
C 1 On C. 
Now we define items, which are the basic computa- 
tional units that appear on the agenda and in the 
lemma tables, which record memoized subcomputa- 
tions. 
Definition 3 An item is a pair (t, c) where c is a 
clause and t is a tag, i.e., one of program, solution or 
table(B) for some goal B. A lemma table for a goal 
G is a pair (G, La) where La is a finite list of items. 
The algorithm manipulates a set T of lemma tables 
which has the property that the first components of 
any two distinct members of T are distinct. This 
justifies speaking of the (unique) lemma table in T 
for a goal G. 
Tags are associated with clauses by a user- 
specified control rule, as described below. The tag 
associated with a clause in an item identifies the ope- 
ration that should be performed on that clause. The 
solution tag labels 'completed' clauses, the program 
tag directs the proof procedure to perform a non- 
memoizing resolution of one of the clanse's negative 
literals with program clauses (the particular nega- 
tive literal is chosen by a user-specified selection rule, 
as in standard SLD resolution), and the table(B) tag 
indicates that a subcomputation with root goal B 
(which is always a subset of the clause's negative 
literals) should be started. 
Definition 4 A control rule is a function from clau- 
ses G *-- B to one of program, solution or table(C) for 
some goal C C B. A selection rule is a function from 
clauses G *-- B where B contains at least one rela- 
tional atom to relational atoms a, where a appears 
in B. 
Because program steps do not require memoization 
and given the constraints on the control rule just 
mentioned, the list LG associated with a lemma 
table (G, LG) will only contain items of the form 
(t, G ,-- B) where t is either solution or table(C) for 
some goal C C_ B. 
Definition 5 To add an item an item e = 
(t, H ~ B) to its table means to replace the table 
(H, L) in T with (H, JelL\]). 
103 
Input A non-empty goal G, a program P, a selection rule S, and a control rule R. 
Output A set of goals G' for which RiG' ) = solution and P ~ G *-- G'. 
Global Data Structures A set T of lemma tables and a set A of items called the agenda. 
Algorithm Set T := {(G, 0)} and A := ((program, G *-- G)}. 
Until A is empty, do: 
Remove an item e = it, c) from A. 
Case t of 
program For each clause p E P such that c resolves with p on S(c), choose a corresponding resolvent 
e' and add iRic'), c') to A. 
table(B) Add e to its table, s 
If T contains a table (B', L) where B' is a variant of B then for each item (solution, d) E L such 
that c resolves with d on B choose a corresponding resolvent d' and add iR(c"), d') to A. 
Otherwise, add a new table i B, ¢) to T, and add (program, B ~-- B) to the agenda. 
solution Add e to its table. 
Let e = H ~ B. Then for each item of the form (tabh(H'), d) in any table in T where H' is a 
variant of H and c' resolves with c on H', choose a corresponding resolvent d' and add (R(d'), d') 
to A. 
Set r := {B: (solution, G *-- B) E L,/G, L) E T}. 
Figure 2: The Lemma Table algorithm 
The formal description of the Lemma Table proof 
procedure is given in Figure 2. We prove the so- 
undness and completeness of the proof procedure in 
DSrre and Johnson (in preparation). In fact, so- 
undness is easy to show, since all of the operations 
are resolution steps. Completeness follows from the 
fact that Lemma Table proofs can be 'unfolded' into 
standard SLD search trees (this unfolding is well- 
founded because the first step of every table-initiated 
subcomputation is required to be a program reso- 
lution), so completeness follows from HShfeld and 
Smolka's completeness theorem for SLD resolution 
in CLP. 
4 A worked example 
Returning to the categorial grammar example above, 
the control rule and selection rule are specified by 
the Prolog code below, which can be informally 
described as follows. All x/3 literals are classi- 
fied as 'memo' literals, and add_adjuncts/2 and 
division/2 whose second arguments are not suf- 
ficiently instantiated are classified as 'delay' literals. 
If the clause contains a memo literal G, then the con- 
trol rule returns tablei\[G\]). Otherwise, if the clause 
contains any non-delay literals, then the control rule 
3In order to handle the more general form of abstrac- 
tion discussed in footnote 2 which may be useful with ty- 
ped feature structure constraints, replace B with a(B) 
in this step, where a(B) is the result of applying the 
abstraction operation to B. 
The abstraction operation should have the property 
that a(B) is exactly the same as B, except that zero or 
more constraints in B are replaced with logically weaker 
constraints. 
returns program and the selection rule chooses the 
left-most such literal. If none of the above apply, 
the control rule returns solution. To simplify the in- 
terpreter code, the Prolog code for the selection rule 
and tableiG ) output of the control rule also return 
the remaining literals along with chosen goal. 
:- ensure_loaded(library(lists)). 
:- op(990, fx, \[delay, memo\]). 
delay division(_, X/Y) :- var(l), var(Y). 
delay add_adjuncts(_, X/Y) :- vat(X), vat(Y). 
memo x( ..... ). 
control(GsO, Control) :- 
memo(G), select(G, CeO, Gs) 
-> Control = table(\[G\], Gs) ; 
member(G, GsO), \+ delay(G) 
-> Control = program ; 
Control = solution. 
selection(GsO, G, Gs) :- 
select(G1, GsO, Gel), \+ delay(Gl) 
-> G = Gl, Ca = Gel. 
Because we do not represent variable binding as ex- 
plicit constraints, we cannot implement 'abstraction' 
by means of the control rule and require an explicit 
abstraction operation. The abstraction operation 
here unbinds the first and third arguments of x/3 
goals, as discussed above. 
abetraction(\[x(_,Left,_)\], \[x(_,Left,_)\]). 
104 
0.1\[o\] e 
0.211\] T 
0.311\] T 
0.411\] P 
0.514\] s 
0.6\[2,5\] W 
1.716\] P 
1.817\] T 
1.917\] T 
1.1017\] P 
1.111101 S 
0.1216,11\] S 
0.1312,12\] W 
2.14113\] P 
2.15114\] W 
2.161141 T 
0.1713,12\] T 
1.1819,11\] T 
0.1913,5\] T 
x(A, \[l_t, o\], B) ~-- x(A, \[l_t, o\], B). 
x(A, \[l_t, o\], B) ~-- x(A/C, \[l_t, o\], D), x(C, D, B). 
x(A, \[l_t, o\], B) ~ x(C, \[l_t, o\], D), x(A\C, D, B). 
x(A, \[l_t, o\], \[o\]) *-- lex(l_t, A). 
x(A/#B, \[l_t, o\], \[o\]) ~-- add(s\np/(s\np), C), div(C, A/B). 
x(A, \[l_t, o\], B) ~ add(s\np/(s\np), C), div(C, A/D), x(#D, \[o\], B). 
x(A, \[o\], B) ~ x(A, \[o\], S). 
x(A, \[o\], B) *-- x(A/C, \[o\], D), x(C, D, B). 
x(A, \[o\], B) ~-- x(C, \[o\], D), x(A\C, D, S). 
x(A, \[o\], 4) ~- lex(o, A). 
x(#A, \[o\], ~) ~- add(s\np\np, A). 
x(A, \[l_t, o\], 0) ~'- add(s\np\np, S), add(s\np/(s\np), C), div(C, A/B). 
x(A, \[Lt, o\], B) *-- add(s\np\np, C), add(s\np/(s\np), D), div(D, A/E/C), x(E, Q, B). 
x(A, 0, B) ~- x(A, 0, B). 
x(A, 0, B) ~- x(A/C, Q, D), x(C, D, B). 
x(h, 4, B) +-- x(C, 4, D), x(A\C, D, B). 
x(A, \[l_t, o\], B) ~-- add(s\np\np, C), add(s\np/(s\np), D), div(D, E/C), x(A\E, ~, B). 
x(A, \[o\], B) ~-- add(s\np\np, C), x(A\#C, ~, B). 
x(A, \[l_t, o\], B) ~ add(s\np/(s\np), C), div(C, D/E), x(A\(D/#E), \[o\], B). 
Figure 3: The items produced during the proof of x(¢, \[lijkLte,on~wijkenJ ,=) using the control and 
selection rules specified in the text. The prefix t.n\[a\] T identifies the table t to which this item belongs, 
assigns this item a unique identifying number n, provides the number(s) of the item(s) a which caused this 
item to be created, and displays its tag T (P for 'program', T for 'table' and S for 'solution'). The selected 
literal(s) are shown underlined. To save space, 'add_adjuncts' is abbreviated by 'add', 'division' by 'div', 
'lijkt_te' by 'It', and 'ontwijken' by 'o'. 
Figure 3 depicts the proof of a parse of the verb clu- 
ster in (1). Item 1 is generated by the initial goal; 
its sole negative literal is selected for program reso- 
lution, producing items 2-4 corresponding to three 
program clauses for x/3. Because items 2 and 3 con- 
tain 'memo' literals, the control rule tags them table; 
there already is a table for a variant of these goals 
(after abstraction). Item 4 is tagged program bec- 
ause it contains a negative literal that is not 'memo' 
or 'delay'; the resolution of this literal with the pro- 
gram clauses for lex/3 produces item 5 containing 
the constraint literals associated with lijkt re. Both 
of these are classified as 'delay' literals, so item 5 is 
tagged solution, and both are 'inherited' when item 5 
resolves with the table-tagged items 2 and 3, produ- 
cing items 6 (corresponding to a right application 
analysis with lijkt te as functor) and item 19 (cor- 
responding to a left application analysis with ont. 
wijken as functor) respectively. Item 6 is tagged 
table, since it contains a x/3 literal; because this 
goal's second argument (i.e., the left string position) 
differs from that of the goal associated with table 0, 
a new table (table 1) is constructed, with item 7 as 
its first item. 
The three program clauses for x/3 are used to re- 
solve the selected literal in item 7, just as in item 1, 
yielding items 8-10. The lex/3 literal in item 10 is 
resolved with the appropriate program clause, pro- 
ducing item 11. Just as in item 5, the second argu- 
ment of the single literal in item 11 is not sufficiently 
instantiated, so item 11 is tagged solution, and the 
unresolved literal is 'inherited' by item 12. Item 12 
contains the partially resolved analysis of the verb 
complex. Items 13-16 analyze the empty string; 
notice that there are no solution items for table 2. 
Items 17-19 represent partial alternative analyses of 
the verb cluster where the two verbs combine using 
other rules than forward application; again, these 
yield no solution items, so item 12 is the sole analy- 
sis of the verb cluster. 
5 A simple interpreter 
This section describes an implementation of the 
Lemma Table proof procedure in Prolog, designed 
for simplicity rather than efficiency. Tables are 
stored in the Prolog database, and no explicit agenda 
is used. The dynamic predicate goal_Cable(G, I) 
records the initial goals G for each table subcompu- 
tation and that table's identifying index I (a number 
assigned to each table when it is created). The dy- 
namic predicate table_solution(I, S) records all of 
the solution items generated for table I so far, and 
table_paxent(I, T) records the table items T, called 
'parent items' below, which are 'waiting' for additio- 
nal solution items from table I. 
The 'top level' goal is prove(G, Cs), where G is 
105 
a single atom (the goal to be proven), and Cs is 
a list of (unresolved) solution constraints (different 
solutions are enumerated through backtracking). 
prove/2 starts by retracting the tables associa- 
ted with previous computations, asserting the table 
entry associated with the initial goal, and then calls 
take_action/2 to perform a program resolution on 
the initial goal. After all succeeding steps are com- 
plete, prove/2 returns the solutions associated with 
table 0. 
prove(Goal, _Constraints) :- 
retractall (goal_gable(_, _) ), 
retractall (table_solut ion (_, _) ), 
retractall (gable_parent (_, _) ), 
regractall (counter (_)), 
assert(goal_gable( \[Goal\], O)), 
¢ake_acgion(proEram , \[Goal\] : :-\[Goal\], O), 
fail. 
prove(Goal, Constraints) :- 
table_solution(O, \[Goal\] : :-Constraints). 
The predicate take_action(L, C, I) processes items. 
L is the item's label, C its clause and I is the in- 
dex of the table it belongs to. The first clause 
calls complete/2 to resolve the solution clause with 
any parent items the table may have, and the third 
clause constructs a parent item term (which enco- 
des both the clause, the tabled goal, and the in- 
dex of the table the item belongs to) and calls insert_into_table/2 
to insert it into the appro- 
priate table. 
take_action(solution, Clause, Index) :- 
assert (Cable_solution(Index, Clause)), 
findall(P, gable_parent (Index, P), 
Paren¢Items), 
member (ParentIgem, ParenCItems), 
complete (ParentItem, Clause). 
take_acCion(proEram , Head: :-Goal, Index) :- 
selection(Goal, Selected, Bodyl), 
Selected : :- HodyO, 
append(BodyO, Bodyl, Body), 
control(Body, Action), 
take_action(Action, Head: :-Body, Index). 
take_action(table(Goal, Other), Head : : -_Body, 
Index) :- 
ins err_into_table (Goal, 
¢ableItem(Head, Goal, Other, Index)). 
complete/2 takes an item labeled table and a clause, 
resolves the head of the clause with the item, and 
calls control/2 and take_action/3 to process the 
resulting item. 
complete(tableItem(Head, Goal, Body1, Index), 
Goal: :-BodyO) :- 
append(BodyO, Bodyl, Body), 
control (Body, Action), 
take_action(Action, Head: :-Body, Index). 
The first clause insert_into_table/2 checks to see 
if a table for the goal to be tabled has already been 
constructed (numbervars/3 is used to ground a copy 
of the term). If an appropriate table does not exist, 
the second clause calls create_table/3 to construct 
one. 
insert_into_table(Goal, ParentItem) :- 
copy_term(Goal, GoalCopy), 
numbervars (GoalCopy, O, _), 
goal_table (GoalCopy, Index), 
!, 
assert (table_parent (Index, ParentIgem) ), 
findall(Sol, table_solution(Index, Sol), 
Solutions), !, 
member(Solutlon, Solutions), 
complege(ParengItem, SQlugion). 
insert_into_table (GoalO, ParentICem) :- 
absgraction(GoalO, Goal), !, 
create_gable(Goal, ParengItem, Index), 
¢ake_action(proEram, Goal: :-Goal, Index). 
create_table/3 performs the necessary database 
manipulations to construct a new table for the goal, 
assigning a new index for the table, and adding ap- 
propriate entries to the indices. 
create_table(Goal, ParentI¢~, Index) :- 
(retract(councer(IndexO)) -> true 
; IndexO=O), 
Index is IndexO+l, 
assert (counter (Index)), 
assert(goal_table(Goal , Index)), 
as sert (table_parent (Index, ParentItem) ). 
6 Conclusion 
This paper has presented a general framework which 
allows both constraint coroutining and memoizs- 
tion. To achieve maximum generality we stated 
the Lemma Table proof procedure in HShfeld and 
Smolka's (1988) CLP framework, but the basic 
idea--that arbitrary constraints can be allowed to 
propagate in essentially the same way that variable 
bindings do--can be applied in most approaches to 
complex feature based parsing. For example, the 
technique can be used in chart parsing: in such a 
system an edge consists not only of a dotted rule 
and associated variable bindings (i.e., instantiated 
feature terms), but also contains zero or more as 
yet unresolved constraints that are propagated (and 
simplified if sufficiently instantiated) during applica- 
tion of the fundamental rule. 
At a more abstract level, the identical propagation 
of both variable bindings and more general cons- 
traints leads us to question whether there is any 
principled difference between them. While still preli- 
minary, our research suggests that it is often possible 
106 
to reexpress complex feature based grammars more 
succinctly by using more general constraints. 

References 
G. Bouma and G. van Noord. Constraint-Based Ca- 
tegorial Grammar. In Proceedings of the 3Pnd An- 
nual Meeting of the ACL, New Mexico State Uni- 
versity, Las Cruces, New Mexico, 1994. 
B. Carpenter. The Logic of Typed Feature Structu- 
res. Cambridge Tracts in Theoretical Computer 
Science 32. Cambridge University Press. 1992. 
J. DSrre. Generalizing Earley deduction for 
constraint-based grammars. In J. D6rre 
(ed.), Computational Aspects of Constraint-Based 
Linguistic Description I, DYANA-2 deliverable 
RI.~.A. ESPRIT, Basic Research Project 6852, 
July 1993. 
J. DSrre and M. Johnson. Memoization and co- 
routined constraints, ms. Institut fiir maschinelle 
Sprachverarbeitung, Universit~it Stuttgart. 
M. HShfeld and G. Smolka. Definite Relations over 
Constraint Languages. LILOG Report 53, IWBS, 
IBM Deutschland, Postfach 80 08 80, 7000 Stutt- 
gart 80, W. Germany, October 1988. (available 
on-line by anonymous ftp from /duck.dfki.uni- 
sb.de:/pub/papers) 
M. Johnson. Memoization in Constraint Logic 
Programming. Presented at First Workshop on 
Principles and Practice of Constraint Program- 
ming, April P8-30 1993, Newport, Rhode Island. 
F. C. Pereira and D. H. Warren. Parsing as Deduc- 
tion. In Proceedings of the Plst Annual Meeting of 
the ACL, Massachusetts Institute of Technology, 
pp. 137-144, Cambridge, Mass., 1983. 
S. M. Shieber. Using Restriction to Extend Par- 
sing Algorithms for Complex-Feature-Based For- 
malisms. In Proceedings of the 23rd Annual Mee- 
ting of the Association for Computational Lingui- 
stics, pp. 145-152, 1985. 
Tamaki, H. and T. Sato. "OLDT resolution with 
tabulation", in Proceedings of Third Internatio- 
nal Conference on Logic Programming, Springer- 
Verlag, Berlin, pages 84-98. 1986. 
Vieille, L. "Recursive query processing: the power of 
logic", Theoretical Computer Science 69, pages 1- 
53. 1989. 
Warren, D. S. "Memoing for logic programs", in 
Communications of the ACM 35:3, pages 94-111. 
1992. 
