HORN EXTENDED FEATURE STRUCTURES: 
FAST UNIFICATION WITH NEGATION AND LIMITED DISJUNCTION t 
Stephen J. Hegner 
Department of Computer Science and Electrical Engineering 
Votey Building 
University of Vermont 
Burlington, VT 05405 USA 
telephone: (802)656-3330 
internet: hegner@uvm.edu 
uucp: ..uunet!uvm-gen!hegner 
ABSTRACT 
The notion of a Horn extended feature structure 
(HoXF) is introduced, which is a feature structure 
constrained so that its only allowable extensions are 
those satisfying some set of llorn clauses in feature- 
term logic, lloXF's greatly generalize ordinary fea- 
ture structures in admitting explicit representation of 
negative and implicational constraints. In contradis- 
tinction to the general case in which arbitrary logical 
constraints are allowed (for which the best known al- 
gorithms are exponential), there is a highly tractable 
algorithm for the unification of HoXF's. 
1. PRELIMINARY CONCEPTS 
1.1 Unification-based grammar formalisms 
Unification-based grammar formalisms constitute a 
cornerstone of many of the most important approaches 
to natural-language understanding (Shieber, 1986), 
(Colban, 1988), (Fenstad etal., 1989). The basic idea 
is that the parser generates a number of partial repre- 
sentations of the total parse, which are subsequently 
checked for consistency and combined by a second pro- 
cess known as a unifier. A common form of represen- 
tation for the partial representations is that of/cature 
structures, which are record-like data structures which 
are allowed to grow in three distinct ways: by adding 
missing values, by adding attributes, and by coalescing 
existing attributes (forcing them to be the same). The 
last operation may lead to cyclic structures, which we 
do not exclude. If the feature structure Sz is an ex- 
tension of $1 (i.e., $1 grows into $2 by application of 
some sequence of the above rules), we write $1 E $2 
and say that St subsumes $2. Intuitively, if Sl E: $2, 
S~ contains more information than does Sl. It is easy 
to show that E: is a partial order on the class of all 
feature structures. 
Each feature structure represents partial informa- 
tion generated during the parse. To obtain the total 
picture, these partial components must be combined 
tThe research reported herein was performed while the 
author was visiting the COSMOS Computational Linguistics 
Group of the Mathematics Department at the University of 
Oslo. lie wishes to thank Jens Erik Fenstad and the members 
of that group for providing a stimulating research environment. 
Particular thanks are due Tore Langholm for many invaluable 
discussions regarding the i,,terplay of logic, feature structures, 
and unification. 
into one consistent piece of knowledge. The formal 
process of unification is precisely this operation of com- 
bination. The most general unifier (mgu) $1 LI $2 of 
feature structures Sj and Sa is the least feature struc- 
ture (under E) which is larger than both Sl and $2. 
Such an mgu exists if and only if $1 and $2 are con- 
sistent; that is, if and only if they subsume a common 
feature structure. 
1.2 Unification algorithms and this paper 
While the idea of a most general unifier is a pleasing 
theoretical notion, its real utility rest with the fact 
that there are efficient algorithms for its computation. 
The fastest known algorithm, identified by Ait-Kaci 
(1984), runs in time which is, for all practical pur- 
poses, linear in the size of the input (i.e., the combined 
sizes of the structures to be unified). In proposing any 
extension to the basic framework, a primary considera- 
tion must be the complexity of the ensuing unification 
algorithm. The principal contribution of the research 
summarized here is to provide an extension of ordinary 
feature structures, admitting negation and limited dis- 
junction, while at the same time continuing to admit 
a provably efficient unification algorithm. 
Due to space limitations, we must omit substan- 
tial background material from this paper. Specifically, 
we assume that the reader is familiar with the no- 
tation and definitions surrounding feature structures 
(Shieber, 1986; Fenstad et al., 1989), as well as the 
traditional unification algorithm (Colban, 1990). We 
also have been forced to omit much detail from the 
description and verification of our algorithm. A full 
report on this work will be available in the near fu- 
ture. 
2. UNIFICATION IN THE PRESENCE 
OF CONSTRAINTS 
2.1 Constraints on feature structures Not ev- 
ery feature structure is a possibility as the ultimate 
output of the parsing mechanism. Typically, there are 
constraints which must be observed. One way of en- 
suring this sort of consistency is to build the checks 
right into the grammar, so that the feature structures 
generated are always legitimate substructures of tile 
final output. The CLG formalism (Dumas and Vat- 
lie, 1989) is an example of such a philosophy. |n many 
ways, this is an attractive option~ because it provides a 
- 33 - 
unified context for expressing all aspects of the gram- 
mar. liowever, this approach has the disadvantage 
that it limits the use of independent parsing subalgo- 
rithms whose results are subsequently unified, since 
the consistency checks nmst be performed before the 
feature structures are presented to the unifier. There- 
fore, to maintain such independence, it would be a 
distinct advantage if some of the constraint checking 
could be relegated to the unification process. 
To establish a formal framework in which this is 
possible, we must start by extending our notion of a 
feature structure. Following the ideas of Moshier and 
Rounds (1987) and Langholm (1989), we define an ex- 
tended fcature structure to be a pair (N, K:) in which 
/C is a set of feature structures and N is the least ele- 
ment of/C under the ordering _. (Titus, by definition, 
K: has a least element, and K: determines N.) Think of 
N a.s the "current" feature structure, and/C as the set 
of all structures into which N is allowed to grow. We 
define (N~,K:t) C:~ (N~,/C~) to mean precisely that 
K~ C_ /C~. In other words, the set of all structures 
which N~ can grow into is a subset of those which N~ 
can grow into. (It follows necessarily that N~ ~_ N2 
in this case.) Note that if we identify the ordinary 
feature structure N with the pair (N, IM I N ~ M}), 
we precisely recapture ordinary subsumption. Finally, 
the notion of unification associated with _~ is given 
by 
(Mr,/Ct) LI= (M~,/C:~) = 
(M,/~ 17/C2) if/C~ n/c2 
has a least element M; 
undefined oOmrwise. 
2.2 Logical feature structures with con- 
straints To operate on pairs of the form (N~/C) al- 
gorithmically, we must have in place an appropriate 
representation for the set g:. There are many possible 
choices; ours is to let it be the set of all structures 
satisfying a set of sentences iu a particular logic. The 
logic which we use is a simple modification of the lan- 
guage of Rounds and Ka.sper (1986) (see also (Kasper 
and Rounds, 1990)) admitting negation but only bi- 
nary path equivalences. Specifically, an atomic feature 
term is one of the following. 
FormltJa 
T ± 
(~: a) 
(,~ × f~) 
Semantics 
The identically true term. 
The identically false term. 
The path (nesting of attributes) cz exists 
and terminates with label a. 
The paths cr and /? have a common end 
point (coalesced end points). 
In (a : a), the label a may be T, denoting a miss- 
ing value. The notation (a ~ /~) is borrowed from 
(Langholm, 1989), and has the same semantics as 
{,,B} of(Rounds and Kasper, 1986). A (general)fea- 
tur~ term is b.ilt up from atomic feature terms using 
the connectives ^, v, and -., with the usual semantics. 
In particular, the negation we use is the classical no- 
tion; a structure satisfes (-,~0) if and only if it does 
not satisfy ~. For any set • of feature terms, Mod(&) 
denotes the set of all feature structures for which each 
E r~ is true. For a formal definition of satisfaction, 
we refer the reader to the above-cited references. In- 
tuitively, any set of terms which defines a consistent 
rooted, directed graph is satisfiable. Ilowever, let us 
specifically remark that only nodes with no outgoing 
edges may have labels other than T, that labels other 
than T may occur at at most one end point, that no 
two outgoing edges from the same node may have the 
same label, and that any term of the form (a : .L) is 
equivalent to _L, and so inconsistent. 
Now we define a logical extended feature structure 
(LoXF) to be an extended feature structure iN, K:) 
in which K: = Mod(¢) for some consistent finite 
set ~ of feature terms. In particular, Mod(~) must 
have a least model. We also denote this pair by 
Y(~) = (g.,Mod(~b)). Now Y(~b,) E_, ~'(~2) re- 
duces to Mod(~) C_ Mod(4,a), and 
{ ~(~ u ¢2) undefined if Mod(&a U q~) has a least element under E; otherwise. 
2.3 Remark on negation A full discussign of the 
nature of negation in LoXF's is complex, and will be 
the focus of a separate paper. IIowever, because this 
topic has received a great deal of attention (Moshier 
and Rounds, 1987), (Langholm, 1989), (Dawar and 
Vijay-Shanker, 1990), we feel it essential to remark 
here that ~'(¢~) does not have the "classical" nega- 
tion semantics which can be determined by looking 
solely at the least element. Indeed, the appropriate 
definition is that .~'(~) satisfies -'7' precisely when no 
member of Mod(&) satisfies ¢; in other words, the 
structure N. is not allowed to be extended to satisfy 
~o. 
2.4 Unification algorithms for logical ex- 
tended feature structures In view of the defini- 
tion immediately above, it is easy to see that that any 
unification algorithm for LoXF's must solve the fol- 
lowing two problems in the course of attempting to 
unify ~'(~i) and ~'(~2). 
(ul) It must decide whether or not ~i U q~2 is consis- 
tent; i.e., whether or not there is a feature struc- 
ture satisfying all sentences of both ~i and cb2. 
(u2) In case that 4~I U~2 is satisfiable, it must also de- 
termine if there is a least model, and if so, identify 
it. 
Now it is well known that (ul) is an NP-complete 
problem, even if we disallow negation and path equiva- 
lence (Rounds and Kasper, 1986, Thin. 4). Therefore, 
barring the eventuality that P = NP, we cannot ex- 
pect to allow ~I and ~2 to be arbitrary finite sets of 
feature terms and still have a tractable algorithm for 
unification. One solution, which has been taken by a 
number of authors, such as Kasper (1989) and Eisele 
and D6rre (1988), is to devise clever algorithms which 
apply to the general case and appear empirically to 
work well on "typical" inputs, but still are provably 
- 34 - 
exponential in the worst case. While such work is un- 
deniably of great value, we here propose a companion 
strategy; namely, we restrict attention to pairs {N, ~) 
such that the very nature of • guarantees a tractable 
algorithm. 
3. HORN FEATURE LOGIC 
In the field of mathematicM logic in general, and 
in the computational logic relevant to computer sci- 
ence in particular, Horn clauses play a very special r61e 
(Makowsky, 1987). Indeed, they form the basis for the 
programming language Prolog (Sterling and Shapiro, 
1986) and the database language Datalog (Ceri et ai., 
1989). This is due to the fact that while they possess 
substantial representational power, tractable inference 
algorithms are well known. It is perhaps the main the- 
sis of this work that the utility of llorn clauses carries 
over to computational linguistics as well. 
3.1 Horn feature clauses A feature literal is ei- 
ther an atomic feature term (e.g., (~: a), (~ ~-. /~), 
or _L) or its negation. A feature clause is a finite 
disjunction £lvt~v...vl,n of feature literals. A fea- 
ture clause is florn if at most one of the ti's is not 
negated. A Horn extended feature structure ( lloXF) 
is a LoXF ~'(4,) such that • is a finite set of llorn 
feature clauses. 
3.2 A taxonomy of Horn feature clauses Be- 
fore moving on to a presentation of algorithms on 
tIoXF's, it is appropriate to provide a brief sketch of 
thc utility and limits of restricting our attention: to col- 
lections of lIorn clauses, hnplication here is classical; 
in the case of ordinary propositional logic, we use 
the notation et^~r~^... ^am =~ p to denote the clause 
~O'l v-~0r2v... V'~O'rnVp. Horn feature clauses may then 
be thought of as falling into one of the following four 
categories. 
(lIl) A clause of the form a, consisting of a single 
positive literal, is just a fact. 
(lI2) A clause of the form -~e, consisting of a single 
negative literal, is a negated fact. In terms of 
lloXF's, if -~a E ¢, this means that within ~'(&), 
no extension of N¢ in which a is true is permit- 
ted. As a concrete example, a constraint stating 
that a subject may not have an attribute named 
"tense" would be of this form. 
(H3) A clause of the form ai ^*2 ... am =~ p is called a 
rule or an implication. Numerous examples of the 
utility of implication in linguistics are identified in 
(Wedekind, 1990, Sec. 1.3). Kasper's conditional 
descriptions (Kasper, 1988) are also a form of im- 
plication. More concretely, the requirement that 
a transitive verb requires a direct object is easily 
expressed in this form. 
(114) A clause of the form al^a2^...^am =~ 1 is 
called a compound negation. The formalization 
of the constraint that a verb cannot be both in- 
transitive and take a direct object is an example 
of the use of such a clause, 
The type of knowledge which is not recapturable using 
llorn feature logic is positive disjunction; i.e., formu- 
las of tim form ~rlva2, with both a.l and aa feature 
terms. Of course, this has nothing in particular to 
do with feature-term logic, but is well-known limita- 
tion of Itorn clauses in general. However, in accepting 
this limitation, we also obtain many key properties, 
including tractable inference and the following impor- 
tant property of genericity. 
3.3 Totally generic LoXF'a Let now • be any 
finite set of feature terms. We say that • is totally 
generic if, for any set q of facts (see (H1) above), 
if Mod(O 0 #) is nonempty then it contains a least 
element under E. Intuitively, if we use • to define 
the LoXF ~(~), total genericity says that however 
we extend the base feature structure N¢ (consistently 
with O), we will continue to have a LoXF. Remarkably, 
we have the following. 
3.4 Theorem A set of feature terms ~p is totally 
generic if and only if it is equivalent to a set of Horn 
feature clauses. 
Proof outline: This result is essentially a translation 
of (Makowsky, 1987, Thm. 1.9) to the logic Of feature 
structures. In words, it says that if (and only if) we 
work with lloXF's, condition (u2) on page 4 becomes 
superfluous (except for explicitly identifying the least 
model.) t3 
4. THE EXTENDED UNIFICATION 
ALGORITHM 
It has been shown by Dowling and Gallier (1984) 
that satisfiability for finite sets of propositional IIorn 
formulas can be tested in time linear in the length of 
the formulas. Their algorithms can easily be modified 
to deliver the least model as well. Since unification 
of HoXF's is essentially testing for satisfiability plus 
identifying the least model (see (ul)-u(2) on the previ- 
ous page), a natural approach would be to adapt one 
of their algorithms. Essentially, this is what we do. 
Like theirs, our algorithm is \]orward chaininff, we start 
with the facts and "fire" rules until no more can be 
fired, or until a contradiction appears. However, the 
adaptation is not trivial, because feature-term logic is 
more expressive than propositional logic. In particu- 
lar, feature-term logic contains countably many tau- 
tologies which have no correlates in ordinary proposi- 
tional logic. The main contribution of our algorithm 
is to implicitly recapture the full semantics of these 
tautologies while keeping the time complexity within 
reasonable bounds. Due to space limitations, we can- 
not present tile full formality of the rather complex 
data structures. Rather, to highlight tile key features, 
we step through an annotated example. We focus only 
upon the special problems inherent in the extension 
to feature-term logic, and assume familiarity with the 
forward-chaining algorithm in (Dowling and Gallier, 
1984) and the graph unification algorithm in (Colban, 
1990). 
4.1 An example theory and extended feature 
graplm The set E contains the following eight llorn 
feature clauses. 
(~,) (AA : a). 
(~,) (n: a). 
- 35 - 
(~) (AA : a)^(B : a)=v (CCDDG : t). 
(~) (A : T)^(C: T) =:, (ABDDG: T). 
(~s) (AA.X B)^(ABDDG : T)=} (ABDDEF : T). 
(~) (A13DD : T)^(B : T) =:, (CCD x ABD). 
(~,) (CCDD x ABDD) =} (AC : T). 
(~s) (ACD : T) =v (ACC : t). 
Just as we may represent a set of atomic feature terms 
with a feature graph, so too may we represent, in part, 
a set of llorn feature clauses with an extended feature 
graph. Shown in Figure I below is the initial extended 
feature graph for the set ~, representing the state of 
inference before any deductions are made. 
a 
t 
a • -~ • i • i • i • 
@ °. D • ,-® -,,=. 
c D D a__ 
• i • .~ I, i, • i t 
Figure 1: Initial extended feature structure for ~. 
Every path and every node label which occurs in 
some literal of E is represented. The labels of all edges, 
as well as all non-T node labels, are underscored, de- 
noting that they are virtual, which means that they 
are only possibilities for the minimal model, and not 
yet actually part of it. The root node is denoted by 
®, and nodes with value T are denoted with a .. Note 
that paths with common virtual end labels (e.g., AA 
and B) are not coalesced; virtual nodes and edges are 
never unified. As a result, the predecessors (along any 
directed path) of any actual node or edge is itself ac- 
tual. As inferences are made, edges and nodes become 
actual (depicted by deleting underscores), and actual 
nodes with common labels are ultimately coalesced. 
The final extended feature graph is shown in Figure 
2 below. For easier visibility, actual edges are also 
highlighted with heavier lines. 
A B D 
a 4 ' • ~ • --~ @ 
C / • ' ~ • 
D G : • ----i,- t 
Figure 2: Final extended feature structure for .~.. 
If we delete the remaining virtual nodes and edges, 
we obtain the graphical representation of the least 
model of ::. 
4.2 Computing the minimal model of the ex- 
ample Now let us consider the process of actually 
obtaining the structure of Figure 2 from E. In the 
propositional forward chaining approach, we start by 
pooling the facts that we know -- in this ease {~1, ~2}. 
We then look for rules whose left-hand sides have been 
satisfied. In the example, the left-hand side of~3 is sat- 
isfied, so we may fire that rule and add (CCDDG : t) 
to our list of known facts, exactly as in the proposi- 
tional case. We may also conclude that (AA x B), 
because both are actual paths which terminate with 
the same label a, and non-T labels are unique. The 
representative extended feature graph at this point is 
shown in Figure 3 below. 
A B D D O_ 
a -ql'-,,~- Q ~- • , ~ • D- • ~- • 
(~) • D ql D • 
N "=" C D D G 
II ~ o ~ • .,,,-.,...--i,- • ~ 1~ 
Figure 3: Intcrmcdlate structure for ~. 
There are other things which we may implicitly con- 
clude, and which we must conclude to fire the other 
rules. For example, we may fire rule ~4 at this point, 
because (AA : a) =~ (A : T) and (IJ : a) =¢~ (/3 : T) 
are both tautologies in tile logic of feature terms, and 
so its left-hand side is satisfied. Thus, we may add 
(A:BDDG : T) to our list of known facts. Similarly, 
since, as noted above, (AA ~ 13) holds, we <may fire 
rule ~5 to conclude (ABDDEF : T). Likewise, we 
may now fire rule ~s and conclude (CCD x ABD). 
The representative extended graph structure at this 
pc4nt is shown in Figure 4 below. 
A B D D G 
(D • • ~ il 
C G 
• ~ • • ~ t 
Figure 4: Intermediate structure for E. 
We mr, st eventually invoke a unification at the com- 
mon end point of CCD and ABD. Such unification 
implicitly entails the tautology (CCD x ABD) :~ 
(CCDD x A13DD) and permits us to conclude that 
rule ~7 should fire and add (AC : T) to the set of facts 
of the least model. The result represented by the final 
extended feature graph of Figure 2. Note that rule ~s 
never fires, and that there are virtual edges and nodes 
left at the conclusion of the process. 
4.3 A taxonomy of implicit rules for sets of 
Horn feature clauses As we remarked in the in- 
troduction to this section, to correctly adapt forward 
chaining to the context of IIoXF's, we must implicitly 
iticlude the semantics of countably many tautologies. 
These fall into three classes. 
(il) Whenever an atomic term of the form (or// : a) 
is determined to be true (ap denotes the concate- 
,nation of a and fl), and another term of the form 
- 36 - 
(c, : T) occurs as au antecedent of a ilorn feature 
clause, (with either fl not the empty string or else 
a :fl T), we must be able to automatically make 
the deduction of the tautology (oq~ : a) =~ (~ : T) 
to conclude that (c~ : T) is now true. We call this 
node and path subsumption. In computing the least 
model of =, the deductions (AA: a) =~ CA: T) and 
(B : a) =~ (B : T) are examples of such rules. 
(i2) Whenever we deduce two terms of the form (a : a) 
and (fl : a) to be true, with a ~ T, we must implic- 
itly realize the semantics of the rule (a : a)^(fl : 
a) ~ (a x fl), due to tile constraint that non- 
T labels are unique. We call this label matching. 
In computing the least model of E, tile deduction 
(AA : a)A(B : a) ::*. (AA X B) is a specific example. 
(i3) Whenever we coalesce two paths, we must per- 
form local unification on the subgraph rooted at the 
point of coalescence. More precisely, if we coalesce 
the paths cY and fl, and the atom (~7 : a) is true, we 
re,st deduce that both (cr7 x \[/7) and (f17 : a) are 
true; i.e., we must implicitly realize the compound 
rule (c¢ y. fl)^(c*7 : a) =~ (a'r x f17)^(f17 : a). This 
is just a logical representation of local unification. In 
computing the least model of E, a specific example 
is the deduction (CCD ~ ABD)^(CCDDG : t) 
(CCDDG .~ ABDDG)^(ABDDG : t). 
4.4 Data structures To support these inferences, 
several specific data structures are supported. They 
are sketched below. 
(dl) There is tile list of clauses. Each clause has a 
counter associated with it, indicating the number of 
literals which remain to be fired before its left-hand 
side is satisfied. When this count drops to zero, the 
clause fires and its consequent becomes true. 
(d2) There is a list of atoms which occur in the an- 
tecedents of clauses. With each literal is associated 
a set of pointers, one to each clause of which it is 
an antecedeut literal. When an atom becomes true, 
the appropriate clauses are notified, so they may 
decrement their counters. 
(d3) Tile working extended fealure structure, as illus- 
trated in Figures 1-4, is maintained throughout. 
(d4) For each node in the working extended feature 
structure, a list of atoms is maintained. If the node 
label is a, then each such atom in the list is of the 
form (c~ : a), with c, a path from the root node to the 
node under consideration. When that node becomes 
actual, that atom is notified that is is now satisfied. 
(d5) For each non-T node label a which occurs in 
some atom, a list of all virtual nodes with that la- 
bel is maintained. When one such node becomes 
actual, the other are checked to see if an inference 
of the form (i2) should be made. 
(dr) For each atom of the form (or x fl) occurring 
as an antecedent in some clause, the nodes at the 
ends of tl,ese paths in the working extended feature 
structure are endowed with a common tag. When- 
ever nodes are coalesced, a check for such common 
tags is made, so the appropriate atom may be noti- 
fied that it is now true. 
4.5 Independent processes and unification 
The algorithm also maintains a ready queue of avail- 
able processes. These processes are of three types. 
A process of the form Actual(or : a), when exe- 
cuted, makes the identified path and label actual in 
the extended feature graph. A process of the form 
Coalesce(hi,ha) coalesces the end points of the two 
nodes nl and n2 in the extended feature graph. A pro- 
cess of the form Unify(n) performs a local unification 
at the subgraph rooted at node n, using an algorithm 
such as identified in (Colban, 1990). All processes in 
the ready queue commute; they may be executed in 
any order. 
To unify two distinct sets of terms (perhaps gener- 
ated by independent parts of a parser), we join their 
two extended feature graphs at the root, merge the 
corresponding data structures, and add the command 
Unify(root) to the merged process queue. In other 
words, we perform a unification to match common in- 
formation, and then continue with the inference pro- 
cess. 
4.6 The complexity of the unification algo- 
rithm Define the length of a literal to be the number 
of attribute name and attribute value occurrences in 
it. Thus, for example, length((AB ~ CD)) = 4 and 
length((ABCD : a)) = 5. For a set cb of tlorn feature 
clauses, we further define the following quantities. 
L = The length of ~I,; i.e., the sum of the lengths of 
all literals occurring in 4~. 
P = The number of distinct terms of the form (or 
fl) which occur as the right-hand side of a rule in &. 
(Facts are not considered to be rules here.) 
m = The number of distinct attributes in the in- 
put. (If we collect all of the literMs occurring in 
tile clauses of • and discard any negation to yield a 
large pool of facts, then m is tile number of edges in 
the graph representing the associated feature struc- 
ture. If ~ is a set of positive iiterals to begin with, 
and hence represents an ordinary feature structure, 
then m represents the size of this feature structure.) 
We then have the following theorem. 
4.7 Theorem The worst.case time complexity 
of our IloXF unification algorithm is O(L + 
(P + 1). m. w(m)), where a~(m) is an inverse Acker- 
mann/unction (which grows more slowly than than 
any primitive recursive function - for all practical pur- 
poses w(n) <_ 5). 121 
This may be compared to tile worst-case complex- 
ity of the usual algorithm for unifying ordinary feature 
structures, which is O(m.w(m)). The increase in com- 
plexity over this simpler case is due to two factors. 
(cl) We must read the entire input; since iiterals may 
be repeated, it is possible that L > m; hence tile L 
term. 
(c2) Each time that we deduce that two nodes must 
be coalesced, we must perform a unification. This 
can occur at most P times - the number of times 
that a rule can assert a distinct coalescing of nodes. 
-37- 
4.8 Further remarks on the algorithm Note in 
particular that there are no restrictions on where path 
equivalences (e.g., (or ~. ~)) may occur in Horn feature 
clauses. In particular, unlike (Kasper, 1988), we do 
allow negated path equivalences, llowever, if we dis- 
allow path equivalences as consequents of rules, then 
the complexity of our algorithm becomes essentially 
that of the traditional unification algorithm (see (c2) 
above). It is primarily deducing path equivalences on 
the fly which results in the additional computational 
burden. 
5. CONCLUSIONS, FURTHER DIItEC- 
TIONS~ AND PROJECT STATUS 
5.1 Conclusions and further directions We 
have identified lloXF's as an attractive compromise 
between ordinary feature structures (in which there is 
no way to express constraints on growth) and full logi- 
cal feature theories (for which the unification problem 
is NP-complete). We view lloXF's not as the "best" 
apl~roach, but rather as a tool to be used to buihl 
better overall unification-based grammar formalisms. 
The obvious next step is to develop an integrated 
framework in which IloXF's are employed to handle 
negation and the disjunction arising from implication, 
while other techniques handle more general disjunc- 
tion and term subsumption (Smolka, 1988). Such an 
optimized approach could lead to much faster overall 
handling of negation and disjunction, but further work 
is clearly needed to bear this out. 
5.2 Status of the project While the algorithm 
has been spelled out in considerable detail, we have 
just begun to build an actual implementation of the 
IIoXF unifier in the programming language Scheme. 
We expect to complete the implementation by the 
summer of 1991. 
References 
A/t-Kaci, lla.qsan (1984), A lattice-theoretic ap- 
llroach to coniputation based oil a calculus of partially- 
ordered type structures, PhD thesis, University of 
Pennsylvania, Philadelphia. 
Ceri, Stefano; Gottlob, Georg; and Tanca, Letizia 
(1989), "What you always wanted to know about Dat- 
slog (and never dared to ask)," 1EEE Trans. Knotvl- 
edge Data Engrg., 1,146-166. 
Colban, Erik A. (1988), Simplified unification based 
grammar formalisms, COSMOS Report No. 05, Uni- 
versity of Osio, Department of Mathematics. 
Colban, Erik A. (1990), Unification algorithms, COS- 
MOS Report No. 16, University of Oslo, Department 
of Mathematics. 
Damas, Luis and Varile, Giovanni B. (1989), "CLG: 
a grammar formalism based on constraint resolution," 
in: Martins, Jo5.o P. and Morgado, Ernesto M., eds., 
EPIA 89: dth Portugcse Conference on Artificial In- 
telligence, Lis&m, Portugal, September 1989, Proceed. 
ings, 175-186, Springer-Verlag. 
Dawar, A. and Vijay-Shanker, K. (1990), "An in- 
terpretation of negation in feature structure descrip- 
tions," Computational Linguistics, 16, 11-21. 
Dowling, William F. and Gallicr, Jean |I. (1984), 
"Linear-time algorithms for testing the satisfiability of 
propositional ttorn clauses," J. Logic Programming, 3, 
267-284. 
Eisele, Andreas and DSrre, Jochen (1988), "Unifica- 
tion of disjunctive feature descriptions," in: Proceed- 
ings o\] the £6th Annual Meeting o\] the ACL. 
Fenstad, Jess Erik; Langholm, Tore; and Vestre, 
Espcn (1989), Representations and interpretations, 
COSMOS Report No. 09, University of Oslo, Depart- 
ment of Mathematics, To appear in Proceedings of the 
Workshop on Computational Linguistics and Formal 
Semantics, Lugano, August.September 1988. 
Kasper, Robert T. (1988), "Conditional descriptions 
in functional unification grammar," in: Proceedings 
o/ the £6th Annual Meeting of the ACL, Buffalo, 233- 
240. 
Kasper, Robert T. (1989), "A unification method for 
disjunctive feature descriptions," in: Proceedings o.f 
the ~Sth Annual Meeting o\] the ACL, 235-242. 
Kasper, Robert T. and Rounds, William C. (1990), 
"Tile logic of unification in grammar," Linguistics and 
Phil., 13, 35-58. 
Langholm, Tore (1989), How to say no with feature 
structures, COSMOS Report No. 13, University of 
Oslo, Department of Mathematics. 
Makowsky, Johann A. (1987), "Why Ilorn formu- 
las matter in computer science: initial structures and 
generic examples," J. Comput. System Sci., 34, 266- 
292. 
Mushier, M. Drew and Rounds, William C. (1987), 
"A logic for partially specified data structures," in: 
Con/erence Record ol the 14th Annual ACM POPL 
Symposium, 155-167. 
Rounds, William C. and Kasper, Robert (1986), "A 
complete logical calculus for record structures repre- 
senting linguistic information," in: Proceedings of the 
First IEEE Symposium on Logic in Computer Science, 
38-43. 
Shieber, Stuart M. (1986), An Introduction to 
Unification.Based Approaches to Grammar, Univer- 
sity of Chicago Press. 
Smolka, Gert (1988), A feature logic with sub- 
sorts, LILOG-Report 33, IBM Deutschland GmbH, 
Stuttgart. 
Sterling, Leon and Shapiro, Ehud (1986), The Art o\] 
Prolog, MIT Press. 
Wedekind, Jfirgen (1990), A survey of linguistically 
motivated extensions to unification-based formalisms, 
Deliverable R3,1.A, DYANA. 
- 38 - 
