Compiling Regular Formalisms with Rule Features into 
Finite-State Automata 
George Anton Kiraz 
Bell Laboratories 
Lucent Technologies 
700 Mountain Ave. 
Murray Hill, NJ 07974, USA 
gkiraz@research, bell-labs, tom 
Abstract 
This paper presents an algorithm for the 
compilation of regular formalisms with rule 
features into finite-state automata. Rule 
features are incorporated into the right 
context of rules. This general notion 
can also be applied to other algorithms 
which compile regular rewrite rules into au- 
tomata. 
1 Introduction 
The past few years have witnessed an increased in- 
terest in applying finite-state methods to language 
and speech problems. This in turn generated inter- 
est in devising algorithms for compiling rules which 
describe regular languages/relations into finite-state 
automata. 
It has long been proposed that regular formalisms 
(e.g., rewrite rules, two-level formalisms) accom- 
modate rule features which provide for finer and 
more elegant descriptions (Bear, 1988). Without 
such a mechanism, writing complex grammars (say 
two-level grammars for Syriac or Arabic morphol- 
ogy) would be difficult, if not impossible. Algo- 
rithms which compile regular grammars into au- 
tomata (Kaplan and Kay, 1994; Mohri and Sproat, 
1996; Grimley-Evans, Kiraz, and Pulman, 1996) do 
not make use of this important mechanism. This pa- 
per presents a method for incorporating rule features 
in the resulting automata. 
The following Syriac example is used here, with 
the infamous Semitic root {ktb} 'notion of writ- 
ing'. The verbal pa"el measure 1, /katteb/~ 'wrote 
CAUSATIVE ACTIVE', is derived from the following 
1Syriac verbs are classified under various measures 
(i.e., forms), the basic ones being p'al, pa "el and 'a/'el. 
2Spirantization is ignored here; for a discussion on 
Syriac spirantization, see (Kiraz, 1995). 
morphemes: the pattern {cvcvc} 'verbal pattern', 
the above mentioned root, and the voealism {ae} 
'ACTIVE'. The morphemes produce the following un- 
derlying form: 3 
a e 
\[ \[ */kateb/ C V C V C 
J I I k t b 
/katteb/is derived then by the gemination, implying 
CAUSATIVE, of the middle consonant, \[t\].4 
The current work assumes knowledge of regular 
relations (Kaplan and Kay, 1994). The following 
convention has been adopted. Lexical forms (e.g., 
morphemes in morphology) appear in braces, { }, 
phonological segments in square brackets, \[\], and 
elements of tuples in angle brackets, (). 
Section 2 describes a regular formalism with rule 
features. Section 3 introduce a number of mathe- 
matical operators used in the compilation process. 
Sections 4 and 5 present our algorithm. Finally, sec- 
tion 6 provides an evaluation and some concluding 
remarks. 
2 Regular Formalism with Rule 
Features 
This work adopts the following notation for regular 
formalisms, cf. (Kaplan and Kay, 1994): 
r ( =~, <=,<~ } A___p (1) 
where T, A and p are n-way regular expressions which 
describe same-length relations) (An n-way regu- 
lar expression is a regular expression whose terms 
3This analysis is along the lines of (McCarthy, 1981) 
- based on autosegmental phonology (Goldsmith, 1976). 
4This derivation is based on the linguistic model pro- 
posed by (Kiraz, 1996). 
~More 'user-friendly' notations which allow mapping 
expressions of unequal length (e.g., (Grimley-Evans, Ki- 
raz, and Pulman, 1996)) are mathematically equivalent 
to the above notation after rules are converted into same- 
329 
R1 k:cl:k:0 ::¢, ___ 
R2 b:c3:b:0 =¢. __ 
R3 a:v:0:a => ___ 
R4 e:v:0:e ::~ ___ 
R5 t:c2:t:0 t:0:0:0 ¢:~ ___ 
(\[cat=verb\], \[measure=pa"el\], \[\]) 
R6 t:c~:t:0 ¢¢, ___ 
(\[cat=verb\], \[measure=p'al\], \[\]) 
R7 0:v:0:a ¢:~ ___ t:c2:t:0 a:v:0:a 
Figure 1: Simple Syriac Grammar 
are n-tuples of alphabetic symbols or the empty 
string e. A same-length relation is devoid of e. For 
clarity, the elements of the n-tuple are separated 
by colons: e.g., a:b:c* q:r:s describes the 3-relation 
{ (amq, bmr, cms) \[ m > 0 }. Following current ter- 
minology, we call the first j elements 'surface '6 and 
the remaining elements 'lexical'.) The arrows corre- 
spond to context restriction (CR), surface coercion 
(SC) and composite rules, respectively. A compound 
rule takes the form 
r { ~, ~, ¢, } ~l___pl; ~2__p2;... (2) 
To accommodate for rule features, each rule may 
be associated with an (n -j)-tuple of feature struc- 
tures, each of the form 
\[attributel =vall , attribute,=val2 , . . .\] (3) 
i.e., an unordered set of attribute=val pairs. An 
attribute is an atomic label. A val can be an atom or 
a variable drawn from a predefined finite set of possi- 
ble values, z The ith element in the tuple corresponds 
to the (j z_ i)th element in rule expressions. As a 
way of illustration, consider the simplified grammar 
in Figure 1 with j = 1. 
The four elements of the tuples are: surface, pat- 
tern, root, and vocalism. R1 and R2 sanction the 
first and third consonants, respectively. R3 and R4 
sanction vowels. R5 is the gemination rule; it is 
only triggered if the given rule features are satisfied: 
\[cat=verb\] for the first lexical element (i.e., the pat- 
tern) and \[measure=pa"el\] for the second element 
(i.e., the root). The rule also illustrates that r can 
be a sequence of tuples. The derivation of/katteb/ 
is illustrated below: 
length descriptions at some preprocessing stage. 
6In natural language, usually j = 1. 
tit is also possible to extend the above formalism in 
order to allow val to be a category-feature structure, 
though that takes us beyond finite-state power. 
Sublexicon Entry Feature Structure 
Pattern ClVC2VC3 \[cat=verb\] 
Root ktb \[measure=(p'al,pa"el)t\] 
Voealism ae \[voice=active, 
measure=pa"el\] 
aa \[voice=active, 
measure=p'al\] 
tParenthesis denote disjunction over the given values. 
Figure 2: Simple Syriac Lexicon 
0 \[ a 100 e 0 vocalism 
k I 0 It0 0 b root 
cl I v It20 v c3 pattern 
1 3 5 4 2 
\[ k \] a let e b \]surface 
The numbers between the lexical expressions and the 
surface expression denote the rules in Figure 1 which 
sanction the given lexical-surface mappings. 
Rule features play a role in the semantics of rules: 
a =~ states that if the contexts and rule features 
are satisfied, the rule is triggered; a ¢=: states that 
if the contexts, lexical expressions and rule features 
are satisfied, then the rule is applied. For example, 
although R5 is devoid of context expressions, the 
rule is composite indicating that if the root measure 
is pa "el, then gemination must occur and vice versa. 
Note that in a compound rule, each set of contexts 
is associated with a feature structure of its own. 
What is meant by 'rule features are satisfied'? 
Regular grammars which make use of rule features 
normally interact with a lexicon. In our model, the 
lexicon consists of (n - j) sublexica corresponding 
to the lexical elements in the formalism. Each sub- 
lexical entry is associate with a feature structure. 
Rule features are satisfied if they match the feature 
structures of the lexical entries containing the lexical 
expressions in r, respectively. Consider the lexicon 
in Figure 2 and rule R5 with 7" = t:c.,:t:0 t:0:0:0 and 
the rule features (\[cat=verb\], \[measure=pa"el\], \[\]). 
The lexical entries containing r are {clvc_,vc3} and 
{ktb}, respectively. For the rule to be triggered, 
\[cat=verb\] of the rule must match with \[cat=verb\] 
of the lexical entry {clvc2vc3}, and \[measure=pa"el\] 
of the rule must match with \[measure=(p'al,pa"el)\] 
of the lexical entry {ktb}. 
As a second illustration, R6 derives the simple p'al 
measure,/ktab/. Note that in R5 and R6, 
1. the lexical expressions in both rules (ignoring 
0s) are equivalent, 
2. both rules are composite, and 
330 
3. they have different surface expression in r. 
In traditional rewrite formalism, such rules will be 
contradicting each other. However, this is not the 
case here since R5 and R6 have different rule fea- 
tures. The derivation of this measure is shown below 
(R7 completes the derivation deleting the first vowel 
on the surfaceS): 
l a 101a 10 I~oc~tism 
01ti01b root 
c v Ic2! v Ip . rn 
17632 Ik!0!t !albl  rI ce 
Note that in order to remain within finite-state 
power, both the attributes and the values in feature 
structures must be atomic. The formalism allows a 
value to be a variable drawn from a predefined finite 
set of possible atomic values. In the compilation 
process, such variables are taken as the disjunction 
of all possible predefined values. 
Additionally, this version of rule feature match- 
ing does not cater for rules whose r span over two 
lexical forms. It is possible, of course, to avoid this 
limitation by having rule features match the feature 
structures of both lexical entries in such cases. 
3 Mathematical Preliminaries 
We define here a number of operations which will be 
used in our compilation process. 
If an operator 0p takes a number of arguments 
(at, • •., ak), the arguments are shown as a subscript, 
e.g. 0p(a,,...,~k) - the parentheses are ignored if there 
is only one argument. When the operator is men- 
tioned without reference to arguments, it appears 
on its own, e.g. 0p. 
Operations which are defined on tuples of strings 
can be extended to sets of tuples and relations. For 
example, if S is a tuple of strings and 0p(S) is an 
operator defined on S, the operator can be extended 
to a relation R in the following manner 
op(n) = { Op(3) I s e n } 
Definition3.1 (Identity) Let L be a regu- 
lar language. Id,(L) = {X I X is an 
n-tuple of the form (x,.-., x), x E L } is the n-way 
identity of L. 9 
Remark 3.1 If Id is applied to a string s, we simply 
write Ida(s) to denote the n-tuple (s .... , s}. 
SShort vowels in open unstressed syllables are deleted 
in Syriac. 
9This is a generalization of the operator Id in (Kaplan 
and Kay, 1994). 
Definition 3.2 (Insertion) Let R be a regular re- 
lation over the alphabet E and let m be a set of 
symbols not necessarily in E. Iasertm(R) inserts 
the relation Ida(a) for all a E m, freely throughout 
R. Insert~ I o Insertm(R) = R removes all such 
instances if m is disjoint from E. 1° 
Remark 3.2 We can define another form of Insert 
where the elements in rn are tuples of symbols as fol- 
lowS: Let R be a regular relation over the alphabet 
and let rn be a set of tuples of symbols not nec- 
essarily in E. Insertm(R) inserts a, for all a E m, 
freely throughout R. 
Definition 3.3 (Substitution) Let S and S' be 
same-length n-tuples of strings over the alphabet 
(E × ''' X E), \[ ---- Ida(a ) for some a E E, and 
S = StIS,.I...Sk,k > 1, such that Si does not 
contain I - i.e. Si E ((E x -.. x E) - {I})'. 
Substitute(s, i)(S) = $1S'S,.S' ... Sk substitutes 
every occurrence of I in S with S'. 
Definition 3.4 (Projection) Let S = (st .... , s,,) 
be a tuple of strings, projec'ci(S), for some 
i 6 { 1 ..... n}, denotes the tuple element si. 
Project~-l(S), for some i E { 1 .... , n }, denotes the 
(n - 1)-tuple (Sl .... , si-1, si+l .... , sn). 
The symbol ,-r denotes 'feasible tuples', similar to 
'feasible pairs' in traditional two-level morphology. 
The number of surface expressions, j, is always 1. 
The operator o represents mathematical composi- 
tion, not necessarily the composition of transducers. 
4 Compilation without Rule 
Features 
The current algorithm is motivated by the work of 
(Grimley-Evans, Kiraz, and Puhnan, 1996). tt 
Intuitively, the automata is built by three approx- 
imations as follows: 
1. 
2. 
Accepting rs irrespective of any context. 
Adding context restriction (=~) constraints 
making the automata accept only the sequences 
which appear in contexts described by the 
grammar. 
. Forcing surface coercion constraints (¢=) mak- 
ing the automata accept all and only the se- 
quences described by the grammar. 
1°This is similar to the operator Intro in (Kaplan and 
Kay, 1994). 
11The subtractive approach for compiling rules into 
FSAs was first suggested by Edmund Grimley-Evans. 
331 
4.1 Accepting rs 
Let 7- be the set of all rs in a regular grammar, p be 
an auxiliary boundary symbol (not in the grammar's 
alphabets) and p' = Ida(p). The first approxima- 
tion is described by 
Centers : U (4) 
rET 
Centers accepts the symbols, p', followed by zero 
or more rs, each (if any) followed by p'. In other 
words, the machine accepts all centers described by 
the grammar (each center surrounded by p') irre- 
spective of their contexts. 
It is implementation dependent as to whether T 
includes other correspondences which are not explic- 
itly given in rules (e.g., a set of additional feasible 
centers). 
4.2 Context Restriction Rules 
For a given compound rule, the set of relations in 
which r is invalid is 
Restrict(r) = 7r" rTr* - U 7r')~krPkTr* (5) 
k 
i.e., r in any context minus r in all valid contexts. 
However, since in §4.1 above, the symbol p appears 
freely, we need to introduce it in the above expres- 
sion. The result becomes 
Restrict(v) = Insert{o } o (6) 
k 
The above expression is only valid if r consists of 
only one tuple. However, to allow it to be a sequence 
of such tuples as in R5 in Figure 1, it must be 
1. surrounded by p~ on both sides, and 
2. devoid of p~. 
The first condition is accomplished by simply plac- 
ing p' to the left and right of r. As for the sec- 
ond condition, we use an auxiliary symbol, w, as a 
place-holder representing r, introduce p freely, then 
substitute r in place of w. Formally, let w be an 
auxiliary symbol (not in the grammar's alphabet), 
and let w ~ = Ida(w) be a place-holder representing 
r. The above expression becomes 
Restrict(r) = Substitute(v, w') o (7) 
Insert{~} o 
,'r* p~w ~ ~o ~ ,-r" - U 7r* A k p~J p~p'~ 7r* 
k 
For all rs, we subtract this expression from the 
automaton under construction, yielding 
CR = Centers - U Restrict( ') (S) 
T 
CR now accepts only the sequences of tuples 
which appear in contexts in the grammar (but in- 
cluding the partitioning symbols p~); however, it 
does not force surface coercion constraints. 
4.3 Surface Coercion Rules 
Let r' represent the center of the rule with the cor- 
rect lexical expressions and the incorrect surface ex- 
pressions with respect to ,'r*, 
r' = Proj'ectl(r} × Project~-l(r) (9) 
The coerce relation for a compound rule can be 
simply expressed by l~- 
Coerce(r') = Insert{p}o (10) 
U ,-r* A k p'r'p'pk lr* k 
The two p~s surrounding r ~ ensure that coercion ap- 
plies on at least one center of the rule. 
For all such expressions, we subtract Coerce from 
the automaton under construction, yielding 
SC = CR - U Coerce(v) (11) 
T 
SC now accepts all and only the sequences of tu- 
pies described by the grammar (but including the 
partitioning symbols p~). 
It remains only to remove all instances of p from 
the final machine, determinize and minimize it. 
There are two methods for interpreting transduc- 
ers. When interpreted as acceptors with n-tuples 
of symbols on each transition, they can be deter- 
minized using standard algorithms (Hopcroft and 
Ullman, 1979). When interpreted as a transduc- 
tion that maps an input to an output, they can- 
not always be turned into a deterministic form (see 
(Mohri, 1994; Roche and Schabes, 1995)). 
5 Compilation with Rule Features 
This section shows how feature structures which are 
associated with rules and lexical entries can be in- 
corporated into FSAs. 
12A special case can be added for epenthetic rules. 
332 
Entry Feature Structure 
abcd ./1 
ef fa 
ghi fs 
Figure 3: Lexicon Example 
5.1 Intuitive Description 
We shall describe our handling of rule features with a 
two-level example. Consider the following analysis. 
la\[bl c ldI ~ te \[ f! ~ \[glh\[ i \]1~ \[ Lexical 
1 2 3 4 5 6 7 5 8 9105 \[a!blcldlOlelf!O!g!h!i!OlS""Saee 
The lexical expression contains the lexical forms 
{abcd}, {ef} and {ghi}, separated by a boundary 
symbol, b, which designates the end of a lexical entry. 
The numbers between the tapes represent the rules 
(in some grammar) which allow the given lexical- 
surface mappings. 
Assume that the above lexical forms are associ- 
ated in the lexicon with the feature structures as in 
Figure 3. Further, assume that each two-level rule 
m, 1 < m < 10, above is associated with the fea- 
ture structure Fro. Hence, in order for the above 
two-level analysis to be valid, the following feature 
structures must match 
All the structures ... must match ... 
F1,F2, F3, F4 fl 
F6,F7 f2 
Fs, Fg, Fl o .1:3 
Usually, boundary rules, e.g. rule 5 above, are not 
associated with feature structures, though there is 
nothing stopping the grammar writer from doing so. 
To match the feature structures associated with 
rules and those in the lexicon we proceed as follows. 
Firstly, we suffix each lexical entry in the lexicon 
with the boundary symbol, ~, and it's feature struc- 
ture. (For simplicity, we consider a feature struc- 
ture with instantiated values to be an atomic object 
of length one which can be a label of a transition 
in a FSA.) 13 Hence the above lexical forms become: 
'abcd kfl', 'efbf~.', and 'ghi ~f3'. Secondly, we incor- 
porate a feature structure of a rule into the rule's 
right context, p. For example, if p of rule 1 above is 
b:b c:c, the context becomes 
b:b c:c ,'r* 0:F1 (12) 
(this simplified version of the expression suffices for 
the moment). In other words, in order for a:a to be 
sanctioned, it must be followed by the sequence: 
13As to how this is done is a matter of implementation. 
1. b:b c:c, i.e., the original right context; 
2. any feasible tuple, ,'r*; and 
3. the rule's feature structure which is deleted on 
the surface, 0:F1. 
This will succeed if only if F1 (of rule 1) and fl (of 
the lexical entry) were identical. The above analysis 
is repeated below with the feature structures incor- 
porated into p. 
lalblcldlblS~le fl~lS~lg hli!~!f~lL~ic~t 
12345 675 89105 \[alblcldlO!O!e flOlOlg hlilO!OiSuqace 
As indicated earlier, in order to remain within 
finite-state power, all values in a feature structure 
must be instantiated. Since the formalism allows 
values to be variables drawn from a predefined finite 
set of possible values, variables entered by the user 
are replaced by a disjunction over all the possible 
values. 
5.2 Compiling the Lexicon 
Our aim is to construct a FSA which accepts any 
lexical entry from the ith sublexicon on its j " ith 
tape. 
A lexical entry # (e.g., morpheme) which is asso- 
ciated with a feature structure ¢ is simply expressed 
by/~¢, where k is a (morpheme) boundary symbol 
which is not in the alphabet of the lexicon. The 
expression of sublexicon i with r entries becomes, 
L, -- U#%¢ ~ (13) 
r 
We also compute the feasible feature structures of 
sublexicon i to be 
z, = U (14) 
r 
and the overall feasible feature structures on all sub- 
lexica to be 
• = O" x F1 x F~ x .-- (15) 
The first element deletes all such features on the 
surface. For convenience in later expressions, we in- 
corporate features with ~ as follows 
~¢ - ,T U • (16) 
The overall lexicon can be expressed by, 14 
Lexicon = LI × L~ × ... (17) 
14To make the lexicon describe equal-length relations, 
a special symbol, say 0, is inserted throughout. 
333 
The operator × creates one large lexicon out of 
all the sublexica. This lexicon can be substantially 
reduced by intersecting it with Proj ect~'l (~0).. 
If a two-level grammar is compiled into an au- 
tomaton, denoted by Gram, and a lexicon is com- 
piled into an automaton, denoted by Lez, the au- 
tomaton which enforces lexical constraints on the 
language is expressed by 
L = (Proj,ctl(~)* × Lex) A Gram (18) 
The first component above is a relation which ac- 
cepts any surface symbol on its first tape and the 
lexicon on the remaining tapes. 
5.3 Compiling Rules 
A compound regular rule with m context-pairs and 
m rule features takes the form 
v {==~,<==,¢~} kl___pl;k2--p2;...;Am---p m 
\[¢1, ¢2,..., ¢-~\] (19) 
where v, A ~, and pk, 1 < k < m are like before and 
ck is the tuple of feature structures associated with 
rule k. 
The following modifications to the procedure 
given in section 4 are required. 
Forgetting contexts for the moment, our basic ma- 
chine scans sequences of tuples (from "/-), but re- 
quires that any sequence representing a lexical entry 
be followed by the entry's feature structure (from 
• ). This is achieved by modifying eq. 4 as follows: 
Centers = \[.J (20) 
vET 
The expression accepts the symbols, 9', followed 
by zero or more occurrences of the following: 
1. one or more v, each followed by ~a', and 
2. a feature tuple in • followed by p'. 
In the second and third phases of the compilation 
process, we need to incorporate members of ¢I, freely 
throughout the contexts. For each A k, we compute 
the new left context 
fk = Insert.(A ~) (21) 
The right context is more complicated. It requires 
that the first feature structure to appear to the right 
of v is Ck. This is achieved by the expression, 
7"~ k = Inserto(p k) CI ~'*¢k~r~ (22) 
The intersection with a'*¢k,'r; ensures that the first 
feature structure to appear to the right of v is Ck: 
zero or more feasible tuples, followed by Ck, followed 
by zero or more feasible tuples or feature structures. 
Now we are ready to modify the Restrict relation. 
The first component in eq. 5 becomes 
A = (; U ~O)*vTr~ (23) 
The expression allows ~ to appear in the left and 
right contexts of v; however, at the left of v, the 
expression (Tr tO ~r¢) puts the restriction that the first 
tuple at the left end must be in a', not in ¢. 
The second component in eq. 5 simply becomes 
B = U "r; £k rTCkTr; (24) 
k 
Hence, Restrict becomes (after replacing v with 
w' in eq. 23 and eq. 24) 
Restrict(r) = Substitute(r,w')o (25) 
Insert{~} o 
A-B 
In a similar manner, the Coercer relation be- 
comes 
Coerce(r') = Insert{~}o (26) 
k 
6 Conclusion and Future Work 
The above algorithm was implemented in Prolog and 
was tested successfully with a number of sample- 
type grammars. In every case, the automata pro- 
duced by the compiler were manually checked for 
correctness, and the machines were executed in gen- 
eration mode to ensure that they did not over gen- 
erate. 
It was mentioned that the algorithm presented 
here is based on the work of (Grimley-Evans, Kiraz, 
and Pulman, 1996) rather than (Kaplan and Kay, 
1994). It must be stated, however, that the intu- 
itive ideas behind our compilation of rule features, 
viz. the incorporation of rule features in contexts, 
are independent of the algorithm itself and can be 
also applied to (Kaplan and Kay, 1994) and (Mohri 
and Sproat, 1996). 
One issue which remains to be resolved, how- 
ever, is to determine which approach for compiling 
rules into automata is more efficient: the standard 
method of (Kaplan and Kay, 1994) (also (Mohri and 
Sproat, 1996) which follows the same philosophy) or 
334 
Algorithm Intersection Determini- 
(N 2) zation (2 N) 
KK (n -- i) "J- 3 ~in_-i ki 8 ~'\]~=1 ki 
EKP 1 ± ~"\]n n ,i=t ki 1 ..t. ~i=1 ki 
where n = number of rules in a grammar, 
and ki = number of contexts for rule i, 1 < i < n. 
Figure 4: Statistics of Complex Operation's 
dealt with at the morphotactic level using a unifica- 
tion based formalism. 
Acknowledgments 
I would like to thank Richard Sproat for comment- 
ing on an earlier draft. Many of the anonymous 
reviewers' comments proofed very useful. Mistakes, 
as always, remain mine. 
the subtractive approach of (Grimley-Evans, Kiraz, 
and Pulman, 1996). 
The statistics of the usage of computationally ex- 
pensive operations - viz., intersection (quadratic 
complexity) and determinization (exponential com- 
plexity) - in both algorithms are summarized in Fig- 
ure 4 (KK = Kaplan and Kay, EKP = Grimley- 
Evans, Kiraz and Pulman). Note that complemen- 
tation requires determinization, and subtraction re- 
quires one intersection and one complementation 
since 
A- B = An B (27) 
Although statistically speaking the number of op- 
erations used in (Grimley-Evans, Kiraz, and Pul- 
man, 1996) is less than the ones used in (Kaplan 
and Kay, 1994), only an empirical study can resolve 
the issue as the following example illustrates. Con- 
sider the expression 
A =al Ua2U...Uan 
and the De Morgan's law equivalent 
(28) 
B = ~n~n.-.n~. (29) 
The former requires only one complement which re- 
sults in one determinization (since the automata 
must be determinized before a complement is com- 
puted). The latter not only requires n complements, 
but also n - 1 intersections. The worst-case analy- 
sis clearly indicates that computing A is much less 
expensive than computing B. Empirically, however, 
this is not the case when n is large and ai is small, 
which is usually the case in rewrite rules. The reason 
lies in the fact that the determinization algorithm 
in the former expression applies on a machine which 
is by far larger than the small individual machines 
present in the latter expression, is 
Another aspect of rule features concerns the mor- 
photactic unification of lexical entries. This is best 
aSThis important difference was pointed out by one of 
the anonymous reviewers whom I thank. 

References 
Bear, J. 1988. Morphology with two-level rules and 
negative rule features. In COLING-88: Papers 
Presented to the 12th International Conference on 
Computational Linguistics, volume 1, pages 28- 
31. 
Goldsmith, J. 1976. Autosegmental Phonology. 
Ph.D. thesis, MIT. Published as Autosegmental 
and Metrical Phonology, Oxford 1990. 
Grimley-Evans, E., G. Kiraz, and S. Pulman. 1996. 
Compiling a partition-based two-level formalism. 
In COLING-96: Papers Presented to the 16th 
International Conference on Computational Lin- 
guistics. 
Hopcroft, J. and J. Ullman. 1979. Introduction to 
Automata Theory, Languages, and Computation. 
Addison-Wesley. 
Kaplan, R. and M. Kay. 1994. Regular models of 
phonological rule systems. Computational Lin- 
guistics, 20(3):331-78. 
Kiraz, G. 1995. Introduction to Syriac Spirantiza- 
tion. Bar Hebraeus Verlag, The Netherlands. 
Kiraz, G. \[1996\]. Syriac morphology: From a lin- 
guistic description to a computational implemen- 
tation. In R. Lavenant, editor, VIItum Sympo- 
sium Syriacum 1996, Forthcoming in Orientalia 
Christiana Analecta. Pontificio Institutum Studio- 
rum Orientalium. 
Kiraz, G. \[Forthcoming\]. Computational Ap- 
proach to Nonlinear Morphology: with empha- 
sis on Semitic languages. Cambridge University 
Press. 
McCarthy, J. 1981. A prosodic theory of non- 
concatenative morphology. Linguistic Inquiry, 
12(3):373-418. 
Mohri, M. 1994. On some applications of finite-state 
automata theory to natural language processing. 
Technical report, Institut Gaspard Monge. 
Mohri, M. and S. Sproat. 1996. An efficient com- 
piler for weighted rewrite rules. In Proceedings 
of the 3~th Annual Meeting of the Association for 
Computational Linguistics, pages 231-8. 
Roche, E. and Y. Schabes. 1995. Deterministic 
part-of-speech tagging with finite-state transduc- 
ers. CL, 21(2):227-53. 
