Datasets:

WINGNUS
/

ACL-OCL

	{
	"paper_id": "J06-1004",
	"header": {
	"generated_with": "S2ORC 1.0.0",
	"date_generated": "2023-01-19T03:00:59.425332Z"
	},
	"title": "Finite-State Registered Automata for Non-Concatenative Morphology",
	"authors": [
	{
	"first": "Yael",
	"middle": [],
	"last": "Cohen-Sygal",
	"suffix": "",
	"affiliation": {
	"laboratory": "",
	"institution": "University of Haifa",
	"location": {
	"postCode": "31905",
	"settlement": "Haifa",
	"country": "Israel"
	}
	},
	"email": "yaelc@cs.haifa.ac.il."
	},
	{
	"first": "Shuly",
	"middle": [],
	"last": "Wintner",
	"suffix": "",
	"affiliation": {},
	"email": ""
	}
	],
	"year": "",
	"venue": null,
	"identifiers": {},
	"abstract": "We introduce finite-state registered automata (FSRAs), a new computational device within the framework of finite-state technology, specifically tailored for implementing non-concatenative morphological processes. This model extends and augments existing finite-state techniques, which are presently not optimized for describing this kind of phenomena. We first define the model and discuss its mathematical and computational properties. Then, we provide an extended regular language whose expressions denote FSRAs. Finally, we exemplify the utility of the model by providing several examples of complex morphological and phonological phenomena, which are elegantly implemented with FSRAs.",
	"pdf_parse": {
	"paper_id": "J06-1004",
	"_pdf_hash": "",
	"abstract": [
	{
	"text": "We introduce finite-state registered automata (FSRAs), a new computational device within the framework of finite-state technology, specifically tailored for implementing non-concatenative morphological processes. This model extends and augments existing finite-state techniques, which are presently not optimized for describing this kind of phenomena. We first define the model and discuss its mathematical and computational properties. Then, we provide an extended regular language whose expressions denote FSRAs. Finally, we exemplify the utility of the model by providing several examples of complex morphological and phonological phenomena, which are elegantly implemented with FSRAs.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Abstract",
	"sec_num": null
	}
	],
	"body_text": [
	{
	"text": "Finite-state (FS) technology has been considered adequate for describing the morphological processes of the world's languages since the pioneering works of Koskenniemi (1983) and Kaplan and Kay (1994) . Several toolboxes provide extended regular expression description languages and compilers of the expressions to finite-state automata (FSAs) and transducers (FSTs) (Karttunen et al. 1996; Mohri 1996; van Noord and Gerdemann 2001a) . While FS approaches to most natural languages have generally been very successful, it is widely recognized that they are less suitable for non-concatenative phenomena; in particular, FS techniques are assumed not to be able to efficiently account for the non-concatenative word formation processes that Semitic languages exhibit (Lavie et al. 1988) .",
	"cite_spans": [
	{
	"start": 156,
	"end": 174,
	"text": "Koskenniemi (1983)",
	"ref_id": null
	},
	{
	"start": 179,
	"end": 200,
	"text": "Kaplan and Kay (1994)",
	"ref_id": "BIBREF8"
	},
	{
	"start": 367,
	"end": 390,
	"text": "(Karttunen et al. 1996;",
	"ref_id": "BIBREF9"
	},
	{
	"start": 391,
	"end": 402,
	"text": "Mohri 1996;",
	"ref_id": "BIBREF16"
	},
	{
	"start": 403,
	"end": 433,
	"text": "van Noord and Gerdemann 2001a)",
	"ref_id": "BIBREF20"
	},
	{
	"start": 765,
	"end": 784,
	"text": "(Lavie et al. 1988)",
	"ref_id": "BIBREF15"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "While much of the inflectional morphology of Semitic languages can be rather straightforwardly described using concatenation as the primary operation, the main word formation process in such languages is inherently non-concatenative. The standard account describes words in Semitic languages as combinations of two morphemes: a root and a pattern. 1 The root consists of consonants only, by default three (although longer roots are known). The pattern is a combination of vowels and, possibly, consonants too, with \"slots\" into which the root consonants can be inserted. Words are created by interdigitating roots into patterns: The first consonant of the root is inserted into the first consonantal slot of the pattern, the second root consonant fills the second slot, and the third fills the last slot. After the root combines with the pattern, some morpho-phonological alternations take place, which may be non-trivial but are mostly concatenative.",
	"cite_spans": [
	{
	"start": 348,
	"end": 349,
	"text": "1",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "The major problem that we tackle in this work is medium-distance dependencies, whereby some elements that are related to each other in some deep-level representation (e.g., the consonants of the root) are separated on the surface. While these phenomena do not lie outside the descriptive power of FS systems, na\u00efvely implementing them in existing finite-state calculi is either impossible or, at best, results in large networks that are inefficient to process, as the following examples demonstrate.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Introduction",
	"sec_num": "1."
	},
	{
	"text": "We begin with a simplified problem, namely accounting for circumfixes. Consider three Hebrew patterns: ha a a, hit a a ut, and mi a , where the empty boxes indicate the slots in the patterns into which the consonants of the roots are inserted. Hebrew orthography 2 dictates that these patterns be written h a, ht ut, and m , respectively, i.e., the consonants are inserted into the ' ' slots as one unit (i.e., the patterns can be viewed as circumfixes). An automaton that accepts all the possible combinations of three-consonant stems and these three circumfixes is illustrated in Figure 1 . 3 Given r stems and p circumfixes, the number of its states is (2r + 2)p + 2, i.e., increases linearly with the number of stems and circumfixes. The number of arcs in this automaton is 3rp + 2p, i.e, also O(rp). Evidently, the three basic different paths that result from the three circumfixes have the same body, which encodes the stems. An attempt to avoid the duplication of paths is represented by the automaton of Figure 2 , which accepts the language denoted by the regular expression (ht + h + m)(root)(ut + a + ). The number of states here is 2r + 4, i.e., is independent of the number of circumfixes. The number of arcs is (3r + 2p), that is, O(r + p), and thus, the complexity of the number of arcs is also reduced. Obviously, however, such an automaton over-generates by accepting also invalid words such as m ut. In other words, it ignores the dependencies which hold between prefixes and suffixes of the same circumfix. Since finite-state devices have no",
	"cite_spans": [
	{
	"start": 593,
	"end": 594,
	"text": "3",
	"ref_id": null
	}
	],
	"ref_spans": [
	{
	"start": 582,
	"end": 590,
	"text": "Figure 1",
	"ref_id": "FIGREF0"
	},
	{
	"start": 1012,
	"end": 1020,
	"text": "Figure 2",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Example 1",
	"sec_num": null
	},
	{
	"text": "Over-generating FSA. memory, save for the states, there is no simple and space-efficient way to account for such dependencies.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 2",
	"sec_num": null
	},
	{
	"text": "Consider now a representation of Hebrew where all vowels are explicit, e.g., the pattern hit a e . Consider also the roots r.g.z, b.$.l, and g.b.r. The consonants of a given root are inserted into the ' ' slots to obtain bases such as hitragez, hitba$el, and hitgaber. The finite state automaton of Figure 3 is the minimized automaton accepting the language; it has fifteen states. If the number of three letter roots is r, then a general automaton accepting the combinations of the roots with this pattern will have 4r + 3 states and 5r + 1 arcs. Notice the duplicated arcs which stem from copying the pattern in the different paths.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 299,
	"end": 307,
	"text": "Figure 3",
	"ref_id": "FIGREF1"
	}
	],
	"eq_spans": [],
	"section": "Example 2",
	"sec_num": null
	},
	{
	"text": "Another non-concatenative process is reduplication: The process in which a morpheme or part of it is duplicated. Full reduplication is used as a pluralization process in Malay and Indonesian; partial reduplication is found in Chamorro to indicate intensivity. It can also be found in Hebrew as a diminutive formation of nouns and adjectives: keleb klablab $apan $panpan zaqan zqanqan $axor $xarxar dog puppy rabbit bunny beard goatee black dark qatan qtantan little tiny",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 3",
	"sec_num": null
	},
	{
	"text": "Let \u03a3 be a finite alphabet. The language L = {ww \| w \u2208 \u03a3 * } is known to be trans-regular, therefore no finite-state automaton accepts it. However, the language L n = {ww \| w \u2208 \u03a3 * , \|w\| = n} for some constant n is regular. Recognizing L n is a finite approximation of the general problem of recognizing L. The length of the words in natural languages can in most cases be bounded by some n \u2208 N, hence the amount of reduplication in natural languages is practically limited. Therefore, the descriptive power of L n is sufficient for the amount of reduplication in natural languages (by constructing L n for a small number of different ns). An automaton that accepts L n can be constructed by listing a path for each accepted string (since \u03a3 and n are finite, the number of words in L n is finite). The main drawback of such an automaton is the growth in its size as \|\u03a3\| and n increase: The number of strings in L n is \|\u03a3\| n . Thus, finitestate techniques can account for limited reduplication, but the resulting networks are space-inefficient.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 3",
	"sec_num": null
	},
	{
	"text": "As a final, non-linguistic, motivating example, consider the problem of n-bit incrementation, introduced by Kornai (1996) .",
	"cite_spans": [
	{
	"start": 108,
	"end": 121,
	"text": "Kornai (1996)",
	"ref_id": "BIBREF13"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 3",
	"sec_num": null
	},
	{
	"text": "The goal of this example is to construct a transducer over \u03a3 = {0, 1} whose input is a 32 bit binary number and whose output is the result of adding 1 to the input. A transducer that performs addition by 1 on binary numbers has only 5 states and 12 arcs, 4 but this transducer is neither sequential nor sequentiable. The problem is that since the input is scanned left to right but the carry moves right to left, the output of the first bit has to be delayed, possibly even until the last input bit is scanned. Thus, for an n-bit binary incrementor, 2 n disjunctions have to be considered, and therefore a minimized transducer has to assign a separate state to each combination of bits, resulting in 2 n states and a similar number of transitions.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 4",
	"sec_num": null
	},
	{
	"text": "In this work we propose a novel FS model which facilitates the expression of medium-distance dependencies such as interdigitation and reduplication in an efficient way. Our main motivation is theoretical, i.e., reducing the complexity of the number of states and arcs in the networks; we show that these theoretical contributions result in practical improvements. In Section 3 we define the model formally, show that it is equivalent to FSAs and define many closure properties directly. 5 We then (Section 4) define a regular expression language for denoting FSRAs. In Section 5 we provide dedicated regular expression operators for some non-concatenative phenomena and exemplify the usefulness of the model by efficiently accounting for the motivating examples. In Section 6 we extend FSRAs to transducers. The model is evaluated through an actual implementation in Section 7. We conclude with suggestions for future research.",
	"cite_spans": [
	{
	"start": 487,
	"end": 488,
	"text": "5",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 4",
	"sec_num": null
	},
	{
	"text": "In spite of the common view that FS technology is in general inadequate for describing non-concatenative processes, several works address the above-mentioned problems in various ways. We summarize existing approaches in this section.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "Several works examine the applicability of traditional two-level systems for implementing non-concatenative morphology. Two-Level Morphology was used by Kataja and Koskenniemi (1988) to create a rule system for phonological and morphophonological alternations in Akkadian, accounting for word inflection and regular verbal derivation. As this solution effectively defines lexical representations of word-forms, its main disadvantage is that the final network is the na\u00efve one, suffering from the space complexity problems discussed above. Lavie et al. (1988) examine the applicability of Two-Level Morphology to the description of Hebrew Morphology, and in particular to verb inflection. Their lexicon consists of three parts: verb primary bases (the past tense, third person, singular, masculine), verb prefixes, and verb suffixes. They attempt to describe Hebrew verb inflection as a concatenation of prefix+base+suffix, implementable by the Two-Level model. However, they conclude that \"The Two-Level rules are not the natural way to describe . . . verb inflection process. The only alternative choice . . . is to keep all bases . . . it seems wasteful to save all the secondary bases of verbs of the same pattern.\"",
	"cite_spans": [
	{
	"start": 153,
	"end": 182,
	"text": "Kataja and Koskenniemi (1988)",
	"ref_id": "BIBREF10"
	},
	{
	"start": 539,
	"end": 558,
	"text": "Lavie et al. (1988)",
	"ref_id": "BIBREF15"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "Other works deal with non-concatenative morphology by extending ordinary FSAs without extending their expressivity. The traditional two-level model of Koskenniemi (1983) is expanded into n-tape automata by Kiraz (2000) , following the insight of Kay (1987) and Kataja and Koskenniemi (1988) . The idea is to use more than two levels of expression: The surface level employs one representation, but the lexical form employs multiple representations (e.g., root, pattern) and therefore can be divided into different levels, one for each representation. Elements that are separated on the surface (such as the root's consonants) are adjacent on a particular lexical level. For example, to describe circumfixation using this model, a 4-tape automaton of the form surface, PR pattern, circumfix, stem is constructed, so that each word is represented by 4 levels. The surface level represents the final form of the word. The PR pattern is the pattern in which the stem and the circumfix are combined (P represents the circumfix's position and R the root letter's position), e.g., PRRRP. The circumfix and stem levels represent the circumfix and the stem respectively.",
	"cite_spans": [
	{
	"start": 151,
	"end": 169,
	"text": "Koskenniemi (1983)",
	"ref_id": null
	},
	{
	"start": 206,
	"end": 218,
	"text": "Kiraz (2000)",
	"ref_id": "BIBREF11"
	},
	{
	"start": 246,
	"end": 256,
	"text": "Kay (1987)",
	"ref_id": null
	},
	{
	"start": 261,
	"end": 290,
	"text": "Kataja and Koskenniemi (1988)",
	"ref_id": "BIBREF10"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "For example, combining the Hebrew stem pqd with the circumfix ht-ut will have the 4-level representation shown in Figure 4 . Notice that the symbols representing the circumfix in the PR pattern level (i.e., the occurrences of the symbol 'P'), the circumfix symbols in the circumfix level, and the circumfix symbols in the surface level are located in correlating places in the different levels. The same holds for the stem symbols. In this way, it is clear which symbols of the surface word belong to the circumfix, which belong to the stem, and how they combine together to create the final form of the word. The 4-tape automaton of Figure 5 accepts all the combinations created by circumfixing roots with the three circumfixes of Example 1. Each arc is attributed with a quadruplet, consisting of four correlating symbols in the four levels. Notice that as in FSAs, the paths encoding the roots are duplicated for each circumfix, so that this automaton is as spaceinefficient as ordinary FSAs. Kiraz (2000) does not discuss the space complexity of this model, but the number of states still seems to increase with the number of roots and patterns. Moreover, the n-tape model requires specification of dependencies between symbols in different levels, which may be non-trivial. Walther (2000a) suggests a solution for describing natural language reduplication using finite-state methods. The idea is to enrich finite-state automata with three new operations: repeat, skip, and self loops. Repeat arcs allow moving backwards within a string and thus repeat a part of it (to model reduplication). Skip arcs allow moving forwards in a string while suppressing the spell out of some of its letters; self loop arcs model infixation. In Walther (2000b) , the above technique is used to describe Temiar reduplication, but no complexity analysis of the model is given. Moreover, this technique does not seem to be able to describe interdigitation. Beesley and Karttunen (2000) describe a technique, called compile-replace, for constructing FSTs, which involves reapplying the regular-expression compiler to its own output. The compile-replace algorithm facilitates a compact definition of nonconcatenative morphological processes, but since such expressions compile to the na\u00efve networks, no space is saved. Furthermore, this is a compile-time mechanism rather than a theoretical and mathematically founded solution.",
	"cite_spans": [
	{
	"start": 996,
	"end": 1008,
	"text": "Kiraz (2000)",
	"ref_id": "BIBREF11"
	},
	{
	"start": 1279,
	"end": 1294,
	"text": "Walther (2000a)",
	"ref_id": "BIBREF21"
	},
	{
	"start": 1732,
	"end": 1747,
	"text": "Walther (2000b)",
	"ref_id": "BIBREF22"
	},
	{
	"start": 1941,
	"end": 1969,
	"text": "Beesley and Karttunen (2000)",
	"ref_id": "BIBREF1"
	}
	],
	"ref_spans": [
	{
	"start": 114,
	"end": 122,
	"text": "Figure 4",
	"ref_id": "FIGREF2"
	},
	{
	"start": 634,
	"end": 642,
	"text": "Figure 5",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "Other works extend the FS model by enabling some sort of context-sensitivity. Blank (1985 Blank ( , 1989 ) presents a model, called Register Vector Grammar, introducing contextsensitivity by representing the states and transitions of finite-state automata as ternaryvalued vectors, which need not be fully specified. No formal properties of this model are discussed. In a similar vein, Kornai (1996) introduces vectorized finite-state automata, where both the states and the transitions are represented by vectors of elements of a partially ordered set. The vectors are manipulated by operations of unification and overwriting. The vectors need not be fully determined, as some of the elements can be unknown (free). In this way information can be moved through the transitions by the overwriting operation and traversing these transitions can be sanctioned through the unification operation. As one of the examples of the advantages of this model, Kornai (1996) shows it can efficiently solve the problem of 32-bit binary incrementor (Example 4). Using vectorized finite-state automata, a 32-bit incrementor is constructed where first, using overwriting, the input is scanned and stored in the vectors, and then, using unification, the result is calculated where the carry can be computed from right to left. We return to this example in example 6, where we show how our own model can solve it efficiently. The formalism presented by Kornai (1996) allows a significant reduction in the network size, but its main disadvantage lies in the fact that it significantly deviates from the standard methodology of developing finite-state devices, and integration of vectorized automata with standard ones remains a challenge. Moreover, it is unclear how, for a given problem, the corresponding network should be constructed: Programming with vectorized automata seems to be unnatural, and no regular expression language is provided for them.",
	"cite_spans": [
	{
	"start": 78,
	"end": 89,
	"text": "Blank (1985",
	"ref_id": "BIBREF3"
	},
	{
	"start": 90,
	"end": 104,
	"text": "Blank ( , 1989",
	"ref_id": "BIBREF4"
	},
	{
	"start": 386,
	"end": 399,
	"text": "Kornai (1996)",
	"ref_id": "BIBREF13"
	},
	{
	"start": 949,
	"end": 962,
	"text": "Kornai (1996)",
	"ref_id": "BIBREF13"
	},
	{
	"start": 1435,
	"end": 1448,
	"text": "Kornai (1996)",
	"ref_id": "BIBREF13"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "A more general approach to the design of finite-state machines is introduced by Mohri, Pereira, and Riley (2000) . They introduce an object-oriented library for manipu-lating finite-state devices that is based on the algebraic concepts of rational power series and semirings. This approach facilitates a high degree of generality as the algorithms are defined for the general algebraic notions, which can then be specialized according to the needs of the user. They exemplify the usefulness of this library by showing how to specialize it for the manipulation of weighted automata and transducers. Our work can be seen as another specialization of this general approach, tailored for ideally dealing with our motivating examples.",
	"cite_spans": [
	{
	"start": 80,
	"end": 112,
	"text": "Mohri, Pereira, and Riley (2000)",
	"ref_id": "BIBREF18"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "Several works introduce the notion of registers, whether for solving similar problems or motivated by different considerations. Krauwer and des Tombe (1981) refer to transducers with a finite number of registers when comparing transducers and context free grammars with respect to their capabilities to describe languages. They sketch a proof showing that such transducers are equivalent to ordinary finite-state transducers. However, they never formally define the model and do not discuss its ability to efficiently implement non-concatenative natural languages phenomena. Moreover, they do not show how the closure properties can be implemented directly on these registered transducers, and do not provide any regular language denoting such transducers.",
	"cite_spans": [
	{
	"start": 128,
	"end": 156,
	"text": "Krauwer and des Tombe (1981)",
	"ref_id": "BIBREF14"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "Motivated by different considerations, Kaminski and Francez (1994) present a computational model which extends finite state automata to the case of infinite alphabets. This model is limited to recognizing only regular languages over infinite alphabets while maintaining closure under Kleene star and boolean operations, with the exception of closure under complementation. The familiar automaton is augmented with registers, used to store alphabet symbols, whose number is fixed for each automaton and can vary from one automaton to another. The model is designed to deal with infinite alphabets, and therefore it cannot distinguish between different symbols; it can identify different patterns but cannot distinguish between different symbols in the pattern as is often needed in natural languages. Our solution is reminiscent of Kaminski and Francez (1994) in the sense that it augments finite-state automata with finite memory (registers) in a restricted way, but we avoid the above-mentioned problem. In addition, our model supports a register alphabet that differs from the language alphabet, allowing the information stored in the registers to be more meaningful. Moreover, our transition relation is a more simplified extension of the standard one in FSAs, rendering our model a conservative extension of standard FSAs and allowing simple integration of existing networks with networks based on our model.",
	"cite_spans": [
	{
	"start": 39,
	"end": 66,
	"text": "Kaminski and Francez (1994)",
	"ref_id": "BIBREF7"
	},
	{
	"start": 831,
	"end": 858,
	"text": "Kaminski and Francez (1994)",
	"ref_id": "BIBREF7"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "Finally, Beesley (1998) directly addresses medium-distance dependencies between separated morphemes in words. He proposes a method, called flag diacritics, which adds features to symbols in regular expressions to enforce dependencies between separated parts of a string. The dependencies are forced by different kinds of unification actions. In this way, a small amount of finite memory is added, keeping the total size of the network relatively small. Unfortunately, this method is not formally defined, nor are its mathematical and computational properties proved. Furthermore, flag diacritics are manipulated at the level of the extended regular expressions, although it is clear that they are compiled into additional memory and operators in the networks themselves. The presentations of Beesley (1998) and Beesley and Karttunen (2003) do not explicate the implementation of such operators and do not provide an analysis of their complexity. Our approach is similar in spirit, but we provide a complete mathematical and computational analysis of such extended networks, including a proof that the model is indeed regular and constructions of the main closure properties. We also provide dedicated regular expression operations for non-concatenative processes and show how they are compiled into extended networks, thereby accounting for the motivating examples.",
	"cite_spans": [
	{
	"start": 9,
	"end": 23,
	"text": "Beesley (1998)",
	"ref_id": "BIBREF0"
	},
	{
	"start": 792,
	"end": 806,
	"text": "Beesley (1998)",
	"ref_id": "BIBREF0"
	},
	{
	"start": 811,
	"end": 839,
	"text": "Beesley and Karttunen (2003)",
	"ref_id": "BIBREF2"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Related Work",
	"sec_num": "2."
	},
	{
	"text": "We define a new model, finite-state registered automata (FSRA), aimed at facilitating the expression of various non-concatenative morphological phenomena in an efficient way. The model augments finite-state automata with finite memory (registers) in a restricted way that saves space but does not add expressivity. The number of registers is finite, usually small, and eliminates the need to duplicate paths as it enables the automaton to \"remember\" a finite number of symbols. In addition to being associated with an alphabet symbol, each arc is also associated with an action on the registers. There are two kinds of actions, read and write. The read action, denoted R, allows traversing an arc only if a designated register contains a specific symbol. The write action, denoted W, allows traversing an arc while writing a specific symbol into a designated register. In this section we define FSRAs and show that they are equivalent to standard FSAs (Section 3.1). We then directly define several closure operations over FSRAs (Section 3.2) and provide some optimizations in Section 3.3. We conclude this section with a discussion of minimization (Section 3.4).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Finite-state Registered Automata",
	"sec_num": "3."
	},
	{
	"text": "A finite-state registered automaton (FSRA) is a tuple",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A = Q, q 0 , \u03a3, \u0393, n, \u03b4, F , where:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r Q is a finite set of states.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r q 0 \u2208 Q is the initial state. r \u03a3 is a finite alphabet (the language alphabet).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r n \u2208 N (indicating the number of registers). r \u0393 is a finite alphabet including the symbol '#' (the registers alphabet).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "We use meta-variables u i , v i to range over \u0393 and u, v to range over \u0393 n .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r The initial content of the registers is # n , meaning that the initial value of all the registers is 'empty'.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r \u03b4 \u2286 Q \u00d7 \u03a3 \u222a { } \u00d7 {R, W} \u00d7 {0, 1, 2, . . . , n \u2212 1} \u00d7 \u0393 \u00d7 Q is the transition relation.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "The intuitive meaning of \u03b4 is as follows:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "- (s, \u03c3, R, i, \u03b3, t) \u2208 \u03b4 where i > 0 implies that if",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A is in state s, the input symbol is \u03c3, and the content of the i-th register is \u03b3, then A may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "- (s, \u03c3, W, i, \u03b3, t) \u2208 \u03b4 where i > 0 implies that if",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A is in state s and the input symbol is \u03c3, then the content of the i-th register is changed into \u03b3 (overwriting whatever was there before) and A may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "- (s, \u03c3, R, 0, #, t)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "implies that if A is in state s and the input symbol is \u03c3, then A may enter state t. Notice that the content of register number 0 is always #. We use the shorthand notation (s, \u03c3, t) for such transitions.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r F \u2286 Q is the set of final states.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A configuration of A is a pair (q, u), where q \u2208 Q and u \u2208 \u0393 n (q is the current state and u represents the registers content). The set of all configurations of A is denoted by Q c . The pair q c 0 = (q 0 , # n ) is called the initial configuration, and configurations with the first component in F are called final configurations. The set of final configurations is denoted by F c .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Let u = u 0 u 1 . . . u n\u22121 and v = v 0 v 1 . . . v n\u22121 . Given a symbol \u03b1 \u2208 \u03a3 \u222a { } and an FSRA A, we say that a configuration (s, u) produces a configuration (t, v), denoted (s, u) \u03b1,A (t, v)",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": ", iff either one of the following holds:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r There exists i, 0 \u2264 i \u2264 n \u2212 1, and there exists \u03b3 \u2208 \u0393, such that (s, \u03b1, R, i, \u03b3, t) \u2208 \u03b4 and u = v and u i = v i = \u03b3; or r There exists i, 0 \u2264 i \u2264 n \u2212 1, and there exists \u03b3 \u2208 \u0393, such that (s, \u03b1, W, i, \u03b3, t) \u2208 \u03b4 and for all k, k \u2208 {0, 1, ..., n \u2212 1}, such that k = i, u k = v k and v i = \u03b3.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Informally, a configuration c 1 produces a configuration c 2 iff the automaton can move from c 1 to c 2 when scanning the input \u03b1 (or without any input, when \u03b1 = ) in one step. If the register operation is R, then the contents of the registers in the two configurations must be equal, and in particular the contents of the designated register in the two configurations should be the expected symbol (\u03b3). If the register operation is W, then the contents of the registers in the two configurations is equal except for the designated register, whose contents in the produced configuration should be the expected symbol (\u03b3).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A run of A on w is a sequence of configurations c 0 , ..., c r such that c 0 = q c 0 , c r \u2208 F c , and for every k, 1 \u2264 k \u2264 r, c k\u22121 \u03b1 k ,A c k and w = \u03b1 1 ...\u03b1 r . An FSRA A accepts a word w if there exists a run of A on w. Notice that \|w\| may be less than r since some of the \u03b1 i may be . The language recognized by an FSRA A, denoted by L(A), is the set of words over \u03a3 * accepted by A.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Consider again example 1. We construct an efficient FSRA accepting all and only the possible combinations of stems and circumfixes. If the number of stems is r, we define an FSRA A = Q, q 0 , \u03a3, \u0393, 2, \u03b4, {q f } where:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 5",
	"sec_num": null
	},
	{
	"text": "r Q = {q 0 , q 1 , . . . , q 2r+2 , q f } r \u03a3 = {a, b, c, . . . , z, ht, ut} r \u0393 = {ht ut, h a, m , #} r \u03b4 = {(q 0 , ht, W, 1, ht ut, q 1 ), (q 0 , h, W, 1, h a, q 1 )} \u222a {(q 0 , m, W, 1, m , q 1 ), (q 2r+2 , ut, R, 1, ht ut, q f )} \u222a {(q 2r+2 , a, R, 1, h a, q f ), (q 2r+2 , , R, 1, m , q f )} \u222a {(q 1 , \u03b1 1 , q i ), (q i , \u03b1 2 , q i+1 ), (q i+1 , \u03b1 3 , q 2r+2 ) \| 2 \u2264 i \u2264 2r and \u03b1 1 \u03b1 2 \u03b1 3 is the i-th stem}.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 5",
	"sec_num": null
	},
	{
	"text": "This automaton is shown in Figure 6 . The number of its states is 2r + 4 (like the FSA of Figure 2 ), that is, O(r), and in particular independent of the number of circumfixes. The number of arcs is also reduced from O(r \u00d7 p), where p indicates the number of circumfixes, to O(r + p).",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 27,
	"end": 35,
	"text": "Figure 6",
	"ref_id": "FIGREF4"
	},
	{
	"start": 90,
	"end": 98,
	"text": "Figure 2",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Example 5",
	"sec_num": null
	},
	{
	"text": "Consider again example 2. The FSRA of Figure 7 also accepts the same language. This automaton has seven states and will have seven states for any number of roots. The number of arcs is also reduced to 3r + 3.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 38,
	"end": 46,
	"text": "Figure 7",
	"ref_id": "FIGREF5"
	}
	],
	"eq_spans": [],
	"section": "Example 6",
	"sec_num": null
	},
	{
	"text": "Next, we show that finite-state registered automata and standard finite state automata recognize the same class of languages. Trivially, every finite-state automaton has an equivalent FSRA: Every FSA is also an FSRA since every transition (s, \u03c3, t) in an FSRA is a shorthand notation for (s, \u03c3, R, 0, #, t). The other direction is also simple.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 6",
	"sec_num": null
	},
	{
	"text": "Every FSRA has an equivalent finite-state automaton.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 1",
	"sec_num": null
	},
	{
	"text": "We prove this by constructing an equivalent FSA to a given FSRA. The construction is based on the fact that in FSRAs the number of registers is finite, as are the sets \u0393 and Q, the register alphabet and states, respectively. Hence the number of configurations is finite. The FSA's states are the configurations of the FSRA, and the transition function simulates the 'produces' relation. Notice that this relation holds between configurations depending on \u03a3 only, similarly to the transition function in an FSA. The constructed FSA is non-deterministic, with possible -moves. The formal proof is suppressed.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 1",
	"sec_num": null
	},
	{
	"text": "The number of configurations in A is \|Q\| \u00d7 \|\u0393\| n , hence the growth in the number of states when constructing A from A might be in the worst case exponential in the number of registers. In other words, the move from FSAs to FSRAs can yield an exponential reduction in the size of the network. As we show below, the reduction in the number of states can be even more dramatic.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 1",
	"sec_num": null
	},
	{
	"text": "The FSRA model defined above allows only one register operation on each transition. We extend it to allow up to k register operations on each transition, where k is determined for each automaton separately. The register operations are defined as a sequence (rather than a set), in order to allow more than one operation on the same register over one transition. This extension allows further reduction of the network size for some automata as well as other advantages that will be discussed presently.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 1",
	"sec_num": null
	},
	{
	"text": "An order-k finite-state registered automaton (FSRA-k) is a tuple A = Q, q 0 , \u03a3, \u0393, n, k, \u03b4, F , where: r Q, q 0 , \u03a3, \u0393, n, F and the initial content of the registers are as before. r k \u2208 N (indicating the maximum number of register operations allowed on each arc).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r Let Actions \u0393 n = {R, W} \u00d7 {0, 1, 2, . . . , n \u2212 1} \u00d7 \u0393. Then \u03b4 \u2286 Q \u00d7 \u03a3 \u222a { } \u00d7 \uf8eb \uf8ed k j=1 a 1 , ..., a j \| for all i, 1 \u2264 i \u2264 j, a i \u2208 Actions \u0393 n \uf8f6 \uf8f8 \u00d7 Q",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "is the transition relation. \u03b4 is extended to allow each transition to be associated with a series of up to k operations on the registers. Each operation has the same meaning as before.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "The register operations are executed in the order in which they are specified. Thus, (s, \u03c3, a 1 , ..., a i , t) \u2208 \u03b4 where i \u2264 k implies that if A is in state s, the input symbol is \u03c3 and all the register operations a 1 , ..., a i are executed successfully, then A may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Given a \u2208 Actions \u0393 n we define a relation over \u0393 n , denoted u a v for u, v \u2208 \u0393 n . We define u a v where ",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "u = u 0 . . . u n\u22121 and v = v 0 . . . v",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r if a = (R, i, \u03b3) for some i, 0 \u2264 i \u2264 n \u2212 1 and for some \u03b3 \u2208 \u0393, then u = v and u i = v i = \u03b3.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r if a = (W, i, \u03b3) for some i, 0 \u2264 i \u2264 n \u2212 1 and for some \u03b3 \u2208 \u0393, then for all",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "k \u2208 {0, 1, . . . , n \u2212 1} such that k = i, u k = v k and v i = \u03b3.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "This relation is extended to series over Actions \u0393 n . Given a series a 1 , ..., a p \u2208 (Actions \u0393 n ) p where p \u2208 N, we define a relation over \u0393 n denoted u a 1 ,...,a p v for u, v \u2208 \u0393 n . We define u a 1 ,...,a p v iff the following holds:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r if p = 1, then u a 1 v.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r if p > 1, then there exists w \u2208 \u0393 n such that u a 1 w and w a 2 ,...,a p v.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Let u, v \u2208 \u0393 n . Given a symbol \u03b1 \u2208 \u03a3 \u222a { } and an FSRA-k A, we say that a configuration (s, u) produces a configuration",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "(t, v), denoted (s, u) \u03b1,A (t, v), iff there exist a 1 , . . . , a p \u2208 (Actions \u0393 n ) p for some p \u2208 N such that (s, \u03b1, a 1 , . . . , a p , t) \u2208 \u03b4 and u a 1 ,...,a p v.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A run of A on w is a sequence of configurations c 0 , ..., c r such that c 0 = q c 0 , c r \u2208 F c , and for every l, 1 \u2264 l \u2264 r, c l\u22121 \u03b1 l ,A c l and w = \u03b1 1 ...\u03b1 r . An FSRA-k A accepts a word w if there exists a run of A on w. The language recognized by an FSRA-k A, denoted by L(A), is the set of words over \u03a3 * accepted by A.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Consider the Arabic nouns qamar (moon), kitaab (book), $ams (sun), and daftar (notebook). The definite article in Arabic is the prefix al, which is realized as al when preceding most consonants; however, the 'l' of the prefix assimilates to the first consonant of the noun when the latter is 'd', '$', etc. Furthermore, Arabic distinguishes between definite and indefinite case markers. The FSRA-2 of Figure 8 accepts all the nominative definite and indefinite forms of the above nouns. In order to account for the assimilation, register 2 stores information about the actual form of the definite article. Furthermore, to ensure that definite nouns occur with the correct case ending, register 1 stores information of whether or not a definite article was seen. FSRA-k and FSRAs recognize the same class of languages. Trivially, every FSRA has an equivalent FSRA-k: Every FSRA is an FSRA-k for k = 1. The other direction is also simple.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 401,
	"end": 409,
	"text": "Figure 8",
	"ref_id": "FIGREF6"
	}
	],
	"eq_spans": [],
	"section": "Example 7",
	"sec_num": null
	},
	{
	"text": "Every FSRA-k has an equivalent FSRA.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 2",
	"sec_num": null
	},
	{
	"text": "We show how to construct an equivalent FSRA (or FSRA-1) A given an FSRA-k A. Each transition in A is replaced by a series of transitions in A', each of which performs one operation on the registers. The first transition in the series deals with the new input symbol and the rest are -transitions. This construction requires additional states to enable the addition of transitions. Each transition in A that is replaced requires the addition of as many states as the number of register operations performed on this transition minus one. The formal construction is suppressed.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 2",
	"sec_num": null
	},
	{
	"text": "In what follows, the term FSRA will be used to denote FSRA-k. Simple FRSA will be referred to as FSRA-1. For the sake of emphasis, however, the term FSRA-k will still be used in some cases.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 2",
	"sec_num": null
	},
	{
	"text": "FSRA is a very space-efficient finite-state device. The next theorem shows how ordinary finite-state automata can be encoded efficiently by the FSRA-2 model. Given a finite-state automaton A, an equivalent FSRA-2 A is constructed. A has three states and two registers (in fact, only one register is used since register number 0 is never addressed). One state functions as a representative for the final states in A, another one functions as a representative for the non-final states in A, and the third as an initial state. The register alphabet consists of the states of A and the symbol '#'. Each arc in A has an equivalent arc in A with two register operations. The first reads the current state of A from the register and the second writes the new state into the register. If the source state of a transition in A is a final state, then the source state of the corresponding transition in A will be the final states representative; if the source state of a transition in A is a non-final state, then the source state of the corresponding transition in A will be the non-final states representative. The same holds also for the target states. The purpose of the initial state is to write the start state of A into the register. In this way A simulates the behavior of A. Notice that the number of arcs in A equals the number of arcs in A plus one, i.e., while FSRAs can dramatically reduce the number of states, compared to standard FSAs, a reduction in the number of arcs is not guaranteed.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 2",
	"sec_num": null
	},
	{
	"text": "Every finite-state automaton has an equivalent FSRA-2 with three states and two registers.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 3",
	"sec_num": null
	},
	{
	"text": "Let A = Q, q 0 , \u03a3, \u03b4, F be an FSA and let f : Q \u2192 q f , q nf be a total function defined by ",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 1",
	"sec_num": null
	},
	{
	"text": "f (q) = q f q \u2208 F q nf q / \u2208 F Construct an FSRA-2 A = Q , q 0 , \u03a3 , \u0393 , 2, 2, \u03b4 , F ,",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 1",
	"sec_num": null
	},
	{
	"text": "r Q = {q 0 , q nf , q f }. q",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 1",
	"sec_num": null
	},
	{
	"text": "r \u03a3 = \u03a3 r \u0393 = Q \u222a {#} r F = {q f } r \u03b4 = {(f (s), \u03c3, (R, 1, s), (W, 1, t) , f (t)) \| (s, \u03c3, t) \u2208 \u03b4} \u222a {(q 0 , , (W, 1, q 0 ) , f (q 0 ))}",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 1",
	"sec_num": null
	},
	{
	"text": "The formal proof that L(A) = L(A ) is suppressed.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 1",
	"sec_num": null
	},
	{
	"text": "The equivalence shown in the previous section between the classes of languages recognized by finite-state automata and finite-state registered automata immediately implies that finite-state registered automata maintain the closure properties of regular languages. Applying the regular operations to finite-state registered automata can be easily done by converting them first into finite-state automata. However, as shown above, such a conversion may result in an exponential increase in the size of the automaton, invalidating the advantages of this model. Therefore, we show how some of these operations can be defined directly for FSRAs. The constructions are mostly based on the standard constructions for FSAs with some essential modifications. In what follows, let",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Closure Properties",
	"sec_num": "3.2"
	},
	{
	"text": "A 1 = Q 1 , q 1 0 , \u03a3 1 , \u0393 1 , n 1 , k 1 , \u03b4 1 , F 1 and A 2 = Q 2 , q 2 0 , \u03a3 2 , \u0393 2 , n 2 , k 2 , \u03b4 2",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Closure Properties",
	"sec_num": "3.2"
	},
	{
	"text": ", F 2 be finite-state registered automata.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Closure Properties",
	"sec_num": "3.2"
	},
	{
	"text": "Two FSRAs, A 1 , A 2 , are unioned into an FSRA A in the same way as in FSAs: by adding a new initial state and connecting it with -arcs to each of the (former) initial states of A 1 , A 2 . The number of registers and the maximal number of register operations per arc in A is the maximum of the corresponding values in A 1 , A 2 . Notice that in any specific run of A, the computation goes through just one of the original automata; therefore the same set of registers can be used for strings of L(A 1 ) or L(A 2 ) as needed.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Union.",
	"sec_num": "3.2.1"
	},
	{
	"text": "A = Q, q 0 , \u03a3, \u0393, n, k, \u03b4, F to recognize L(A 1 ) \u2022 L(A 2 )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Concatenation. We show two different constructions of an FSRA",
	"sec_num": "3.2.2"
	},
	{
	"text": ". Concatenation in finite-state automata is achieved by leaving only the accepting states of the second automaton as accepting states and adding an -arc from every accepting state of the first automaton to the initial state of the second automaton. Doing just this in FSRA is insufficient because using the same registers might cause undesired effects: The result might be affected by the content left in the registers after dealing with a substring from L(A 1 ). Thus, this basic construction is used with care. The first alternative is to employ more registers in the FSRA. In this way when dealing with a substring from L(A 1 ) the first n 1 registers are used, and when moving to deal with a substring from L(A 2 ) the next n 2 registers are used. The second alternative is to use additional register operations that clear the content of the registers before handling the next substring from L(A 2 ). This solution may be less intuitive but will be instrumental for Kleene closure below.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Concatenation. We show two different constructions of an FSRA",
	"sec_num": "3.2.2"
	},
	{
	"text": "The construction is based on the concatenation construction. Notice that it cannot be based on the first alternative (adding registers) due to the fact that the number of iterations in Kleene star is not limited, and therefore the number of registers needed cannot be bounded. Thus, the second alternative is used: Register operations are added to delete the content of registers. The construction is done by turning the initial state into a final one (if it is not already final) and connecting each of the final states to the initial state with an -arc that is associated with a register operation that deletes the contents of the registers, leaving them ready to handle the next substring.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Kleene Closure.",
	"sec_num": "3.2.3"
	},
	{
	"text": "For the intersection construction, assume that A 1 and A 2 are -free (we show an algorithm for removing -arcs in Section 3.3.1). The following construction simulates the runs of A 1 and A 2 simultaneously. It is based on the basic construction for intersection of finite-state automata, augmented by a simulation of the registers and their behavior. Each transition is associated with two sequences of operations on the registers, one for each automaton. The number of the registers is the sum of the number of registers in the two automata. In the intersection automaton the first n 1 registers are designated to simulate the behavior of the registers of A 1 and the next n 2 registers simulate the behavior of A 2 . In this way a word can be accepted by the intersection automaton iff it can be accepted by each one of the automata separately. Notice that register operations from \u03b4 1 and \u03b4 2 cannot be associated with the same register. This guarantees that no information is lost during the simulation of the two intersected automata.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Intersection.",
	"sec_num": "3.2.4"
	},
	{
	"text": "Ordinary FSAs are trivially closed under complementation. However, given an FSA A whose language is L(A), the minimal FSA recognizing the complement of L(A) can be exponentially large. More precisely, for any integer n > 2, there exists a non-deterministic finite-state automaton (NFA) with n states A, such that any NFA that accepts the complement of L(A) needs at least 2 n\u22122 states (Holzer and Kutrib 2002) . We have no reason to believe that FSRAs will demonstrate a different behavior; therefore, we maintain that in the worst case, the best approach for complementing an FSRA would be to convert it into FSA and complement the latter. We therefore do not provide a dedicated construction for this operator. Notice that this kind of arc might occur in an FSRA by its definition. Given an FSRA that might contain -arcs, an equivalent FSRA without -arcs can be constructed. The construction is based on the algorithm for -removal in finite-state automata, but the register operations that are associated with the -arc have to be dealt with, and this requires some care. The resulting FSRA has one more state than the original, and some additional arcs may be added, too.",
	"cite_spans": [
	{
	"start": 385,
	"end": 409,
	"text": "(Holzer and Kutrib 2002)",
	"ref_id": "BIBREF6"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Complementation.",
	"sec_num": "3.2.5"
	},
	{
	"text": "The main problem is -loops; while these can be easily removed in standard FSAs, here such loops can be associated with register operations which must be accounted for. The number of possible sequences of register operations along an -loop is unbounded, but it is easy to prove that there are only finitely many equivalence classes of such sequences: Two sequences are in the same equivalence class if and only if they have the same effect on the state of the machine; since each machine has a finite number of configurations (see theorem 1), there are only finitely many such equivalence classes.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Optimizations",
	"sec_num": "3.3"
	},
	{
	"text": "Therefore, the basic idea behind the construction is as follows: If there exists an -path from q 1 to q 2 with the register operations a over its arcs, and an arc (q 2 , \u03c3, b , q 3 ) Figure 9 removal paradigm.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 183,
	"end": 191,
	"text": "Figure 9",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Optimizations",
	"sec_num": "3.3"
	},
	{
	"text": "where \u03c3 = , and an -path from q 3 to q 4 with the register operations c over its arcs, then the equivalent -free network will include the arcs (q 2 , \u03c3, b , q 3 ), (q 1 , \u03c3, a, b , q 3 ), (q 2 , \u03c3, b, c , q 4 ), and (q 1 , \u03c3, a, b, c , q 3 ), with all the -arcs removed. This is illustrated in Figure 9 . Notice that if q 1 and q 2 are the same state, then states q 2 and q 3 will be connected by two parallel arcs differing in their associated register operations; the same holds for states q 2 and q 4 . Similarly, when q 3 and q 4 are the same state. In addition to the above changes, special care is needed for the case in which the empty word is accepted by the original automaton. The formal construction is similar in spirit to the -removal paradigm in weighted automata (Mohri 2000) , where weights along an -path need to be gathered. Therefore, we suppress the formal construction and the proof of its correctness.",
	"cite_spans": [
	{
	"start": 778,
	"end": 790,
	"text": "(Mohri 2000)",
	"ref_id": "BIBREF17"
	}
	],
	"ref_spans": [
	{
	"start": 294,
	"end": 302,
	"text": "Figure 9",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Optimizations",
	"sec_num": "3.3"
	},
	{
	"text": "In FSRAs, traversing an arc depends not only on the input symbol but also on satisfying the series of register operations. Sometimes, a given series of register operations can never be satisfied, and thus the arc to which it is attached cannot be traversed. For example, the series of register operations (W, 1, a), (R, 1, b) can never be satisfied, hence an arc of the form (q 1 , \u03c3, (W, 1, a), (R, 1, b) , q 2 ) is redundant. In addition, the constructions of Sections 3.2 and 3.3.1 might result in redundant states and arcs that can never be reached or can never lead to a final state. Moreover, in many cases a series of register operations can be minimized into a shorter series with the same effect. For example, the series of register operations (W, 1, a) , (R, 1, a) , (W, 1, b) is equal in its effect to the series (W, 1, b) . Therefore, we show an algorithm for optimizing a given FSRA by minimizing the series of register operations over its arcs and removing redundant arcs and states.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 396,
	"end": 405,
	"text": "(R, 1, b)",
	"ref_id": "FIGREF0"
	},
	{
	"start": 753,
	"end": 762,
	"text": "(W, 1, a)",
	"ref_id": "FIGREF0"
	},
	{
	"start": 765,
	"end": 774,
	"text": "(R, 1, a)",
	"ref_id": "FIGREF0"
	},
	{
	"start": 777,
	"end": 786,
	"text": "(W, 1, b)",
	"ref_id": "FIGREF0"
	},
	{
	"start": 824,
	"end": 833,
	"text": "(W, 1, b)",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Optimizing Register Operations.",
	"sec_num": "3.3.2"
	},
	{
	"text": "For a given FSRA A = Q, q 0 , \u03a3, \u0393, n, \u03b4, F , we construct an equivalent FSRA A = Q, q 0 , \u03a3, \u0393, n, \u03b4 , F = Opt(A), such that \u03b4 is created from \u03b4 by removing redundant arcs and by optimizing all the series of register operations. We begin by ( a) = true iff the series of register operations a is satisfiable, i.e., there exists a configuration of register contents for which all the operations in the series can be executed successfully. Determining whether sat i ( a) = true by exhaustively checking all the vectors in \u0393 n may be inefficient. Therefore, we show a necessary and sufficient condition for determining whether sat i ( a) = true for some a \u2208 Actions \u0393 n + \|i , which can be checked efficiently. In addition, this condition will be useful in optimizing the series of register operations as will be shown later. A series of register operations over the i-th register is not satisfiable if either one of the following holds:",
	"cite_spans": [
	{
	"start": 242,
	"end": 246,
	"text": "( a)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Optimizing Register Operations.",
	"sec_num": "3.3.2"
	},
	{
	"text": "r A write operation is followed by a read operation expecting a different value.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Optimizing Register Operations.",
	"sec_num": "3.3.2"
	},
	{
	"text": "r A read operation is immediately followed by a read operation expecting a different value. Notice that if i = 0, then by the definition of FSRAs, all the register operations in the series are the same operation, which is (R, 0, #); and this operation can never fail. In addition, if all the operations in the series are write operations, then again, by the definition of FSRAs, these operations can never fail. If none of the two conditions of the theorem holds, then the series of register operations is satisfiable.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Optimizing Register Operations.",
	"sec_num": "3.3.2"
	},
	{
	"text": "a = (op 1 , i, \u03b3 1 ), (op 2 , i, \u03b3 2 ), . . . , (op s , i, \u03b3 s ) \u2208 Actions \u0393 n + \|i , sat i ( a) =",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 4 For all",
	"sec_num": null
	},
	{
	"text": "We now show how to optimize a series of operations over a given register. An optimized series is defined only over satisfiable series of register operations in the following way:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 4 For all",
	"sec_num": null
	},
	{
	"text": "r If all the operations are write operations, then leave only the last one (since it will overwrite all its predecessors).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 4 For all",
	"sec_num": null
	},
	{
	"text": "r If all the operations are read operations, then by theorem 4, they are all the same operation, and in this case just leave one of them.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 4 For all",
	"sec_num": null
	},
	{
	"text": "r If there are both read and write operations, then distinguish between two cases:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 4 For all",
	"sec_num": null
	},
	{
	"text": "-If the first operation is a write operation, leave only the last write operation in the series.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 4 For all",
	"sec_num": null
	},
	{
	"text": "If the first operation is a read operation, leave the first operation (which is read) and the last write operation in the series. If the last write operation writes into the register the same symbol that the read operation required, then the write is redundant; leave only the read operation.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "-",
	"sec_num": null
	},
	{
	"text": "Define a function min i :",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Actions \u0393 n + \|i \u2212\u2192 Actions \u0393 n + \|i . Let a = (op 1 , i, \u03b3 1 ), . . . , (op s , i, \u03b3 s ) . If sat i ( a) = true then: r If for all k, 1 \u2264 k \u2264 s, op k = W, define min i ( a) = (W, i, \u03b3 s ) . r If for all k, 1 \u2264 k \u2264 s, op k = R then define min i ( a) = (R, i, \u03b3 s ) .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r If there exists m, 1 \u2264 m \u2264 s such that op m = W and if there exists t, 1 \u2264 t \u2264 s, such that op t = R then:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "min i ( a) = \uf8f1 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f2 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f3 (W, i, \u03b3 j ) if op 1 = W and for all k, j < k \u2264 s, op k = R (R, i, \u03b3 1 ), (W, i, \u03b3 j )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "if op 1 = R and for all k, j < k \u2264 s, op k = R and \u03b3 1 = \u03b3 j (R, i, \u03b3 1 ) if op 1 = R and if there exists",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 61,
	"end": 73,
	"text": "(R, i, \u03b3 1 )",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "j, 1 \u2264 j \u2264 s, such that for all k, j < k \u2264 s, op k = R and \u03b3 1 = \u03b3 j",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "The formal proof that min i ( a) is the minimal equivalent series of register operations of a is suppressed.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "We now show how to optimize a series of register operations. Define a function min :",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Actions \u0393 n + \u2212\u2192 Actions \u0393 n + \u222a {null}. For all a \u2208 Actions \u0393 n + define min( a) = b",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "where b is obtained from a by:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r Each subseries a i of a, consisting of all the register operations on the i-th register, is checked for satisfaction. If sat i ( a i ) = false then the arc cannot be traversed and min( a) = b = null. If sat i ( a i ) = true then a i is replaced in a by min( a i ). Notice that the order of the minimized subseries in the complete series is unimportant as they operate on different registers.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r If there exists i = 0, such that a i is not empty, then the subseries a 0 consisting only of operations of the form (R, 0, #) is deleted from a. min( a) = null Opt(A) is optimized with respect to register operations.",
	"cite_spans": [
	{
	"start": 147,
	"end": 154,
	"text": "min( a)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "A = Q, q 0 , \u03a3, \u0393, n, \u03b4, F , construct an equivalent FSRA A = Q, q 0 , \u03a3, \u0393, n, \u03b4 , F = Opt(A) where \u03b4 = q 1 , \u03c3, min( a) , q 2 \| q 1 , \u03c3, a , q 2 \u2208 \u03b4 and",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Finally, given an FSRA",
	"sec_num": null
	},
	{
	"text": "Like FSAs, FSRAs may have states that can never be reached or can never lead to a final state. These states (and their connected arcs) can be removed in the same way they are removed in FSAs. In sum, FSRA optimization is done in two stages:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Finally, given an FSRA",
	"sec_num": null
	},
	{
	"text": "Minimizing the series of register operations over the FSRA transitions.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "1.",
	"sec_num": null
	},
	{
	"text": "Removing redundant states and arcs.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "2.",
	"sec_num": null
	},
	{
	"text": "Notice that stage 1 must be performed before stage 2 as it can result in further reduction in the size of the network when performing the second stage. For a given FSRA A, define OPT(A) as the FSRA obtained from Opt(A) by removing all the redundant states and transitions. An FSRA A is optimized if OPT(A) = A (notice that OPT(A) is unique, i.e., if B = OPT(A) and C = OPT(A), then B = C).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "2.",
	"sec_num": null
	},
	{
	"text": "FSRAs can be minimized along three different axes: states, arcs, and registers. Reduction in the number of registers can always be achieved by converting an FSRA to an FSA (Section 3.1), eliminating registers altogether. Since FSRAs are inherently nondeterministic (see the discussion of linearization below), their minimization is related to the problem of non-deterministic finite-state automata (NFA) minimization, which is known to be NP-hard. 6 However, while FSRA arc minimization is NP-hard, FSRA state minimization is different. Recall that in theorem 3 we have shown that any FSA has an equivalent FSRA-2 with 3 states and 2 registers. It thus follows that any FSRA has an equivalent FSRA-2 with 3 states (simply convert the FSRA to an FSA and then convert it to an FSRA-2 with 3 states). Notice that minimizing an FSRA in terms of states or registers can significantly increase the number of arcs. As many implementations of finite-state devices use space that is a function of the number of arcs, the benefit that lies in such minimization is limited. Therefore, a different minimization function, involving all the three axes, is called for. We do not address this problem in this work. As for arc minimization, we cite the following theorem. As its proof is most similar to the corresponding proof on NFA, we suppress it.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "FSRA Minimization",
	"sec_num": "3.4"
	},
	{
	"text": "FSRA arc minimization is NP-hard.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 5",
	"sec_num": null
	},
	{
	"text": "The main advantage of finite-state devices is their linear recognition time. In finitestate automata, this is achieved by determinizing the network, ensuring that the transition relation is a function. In FSRAs, in contrast, a functional transition relation does not guarantee linear recognition time, since multiple possible transitions can exist for a given state and a given input symbol. For example, given an FSRA A = Q, q 0 , \u03a3, \u0393, n, k, \u03b4, F , and some q, q 1 , q 2 \u2208 Q and \u03c3 \u2208 \u03a3, two arcs such as (q, \u03c3, (W, 1, a) , q 1 ), (q, \u03c3, (W, 1, b) , q 2 ) \u2208 \u03b4 do not hamper the functionality of the FSRA transition relation. However, they do imply that for the state q and for the same input symbol (\u03c3), more than one possible arc can be traversed. We use deterministic to denote FSRAs in which the transition relation is a function, and a new term, linearized, is used to denote FSRAs for which linear recognition time is guaranteed.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 512,
	"end": 521,
	"text": "(W, 1, a)",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Theorem 5",
	"sec_num": null
	},
	{
	"text": "Generally, a FSRA is linearized if it is optimized, -free, and given a current state and a new input symbol, and at most one transition can be traversed. Thus, if the transition relation includes two arcs of the form (q, \u03c3, a , q 1 ), (q, \u03c3, b , q 2 ) , then a and b must be a contradicting series of register operations. Two series of register operations are contradicting if at most one of them is satisfiable. Since the FSRA is optimized, each series of register operations is a concatenation of subseries, each operating on a different register; and the subseries operating on the i-th register must be either empty or",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 217,
	"end": 251,
	"text": "(q, \u03c3, a , q 1 ), (q, \u03c3, b , q 2 )",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Theorem 5",
	"sec_num": null
	},
	{
	"text": "(W, i, \u03b3) or (R, i, \u03b3) or (R, i, \u03b3 1 ), (W, i, \u03b3 2 ) . (W, i, \u03b3) contradicts neither (R, i, \u03b3) nor (R, i, \u03b3 1 ), (W, i, \u03b3 2 ) . (R, i, \u03b3) and (R, i, \u03b3 1 ), (W, i, \u03b3 2 )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 5",
	"sec_num": null
	},
	{
	"text": "are contradicting only if \u03b3 = \u03b3 1 .",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 5",
	"sec_num": null
	},
	{
	"text": "An FSRA A = Q, q 0 , \u03a3, \u0393, n, k, \u03b4, F , is linearized if it is optimized, -free, and for all (q, \u03c3, a , q 1 ), (q, \u03c3, b , q 2 ) \u2208 \u03b4 such that a = b , where",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "a = (op 1 1 , i 1 1 , \u03b3 1 1 ), . . . , (op 1 k , i 1 k , \u03b3 1 k ) and b = (op 2 1 , i 2 1 , \u03b3 2 1 ), . . . , (op 2 m , i 2 m , \u03b3 2 m )",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": ", there exists j 1 , 1 \u2264 j 1 \u2264 k and there exists j 2 , 1 \u2264 j 2 \u2264 m, such that op 1 j 1 = op 2 j 2 = R, i 1 j 1 = i 2 j 2 and \u03b3 1 j 1 = \u03b3 2 j 2 . A na\u00efve algorithm for converting a given FSRA into an equivalent linearized one is to convert it to an FSA and then determinize it. In the worst case, this results in an exponential increase in the network size. As the following theorem shows, FSRA linearization is NP-complete.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "FSRA linearization is NP-complete.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Theorem 6",
	"sec_num": null
	},
	{
	"text": "Evidently, given an FSRA A, it can be verified in polynomial time that A is linearized. Therefore, FSRA linearization is in NP.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 2",
	"sec_num": null
	},
	{
	"text": "Let \u03c6 be a CNF formula with m clauses and n variables. Construct an FSRA A such that L(A) = { } if \u03c6 is satisfiable, otherwise L(A) = \u2205. Let x 1 , . . . , x n be the variables of \u03c6. Define A = Q, q 0 , \u03a3, \u0393, n, 1, \u03b4, F , such that:",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 2",
	"sec_num": null
	},
	{
	"text": "r Q = {q 0 , q 1 , . . . , q n+m } r F = {q n+m } r \u03a3 is irrelevant (choose any \u03a3). r \u0393 = {T, F}. \u2022 \u03b4 = {(q i\u22121 , , (W, i, T), q i ) \| 1 \u2264 i \u2264 n} \u222a {(q i\u22121 , , (W, i, F), q i ) \| 1 \u2264 i \u2264 n} \u222a {(q n+i\u22121 , , (R, j, T), q n+i ) \| 1 \u2264 i \u2264 m and x j occurs in the i-th clause} \u222a {(q n+i\u22121 , , (R, j, F), q n+i ) \| 1 \u2264 i \u2264 m and x j occurs in the i-th clause}",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 2",
	"sec_num": null
	},
	{
	"text": "Notice that each path in A is of length m + n. The first n arcs in the path write an assignment into the registers, then it is possible to traverse the remaining m arcs in the path only if the assignment stored into the registers satisfies \u03c6.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 2",
	"sec_num": null
	},
	{
	"text": "For example, for the CNF formula ( Figure 10 is constructed. Observe that the number of states and arcs in this FSRA is O(mn). Now, linearize A into an FSRA A and assume this can be done in polynomial time. By the definition of linearized FSRA, A does not contain -arcs. Therefore, \u2208 L(A ) iff the initial state of A is also a final one. Hence, \u03c6 is satisfiable iff the initial state of A is also a final one.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 35,
	"end": 44,
	"text": "Figure 10",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Proof 2",
	"sec_num": null
	},
	{
	"text": "x 1 \u2228 x 2 \u2228 x 5 ) \u2227 (x 1 \u2228 x 2 ) \u2227 (x 3 \u2228 x 4 \u2228 x 5 ), the FSRA of",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Proof 2",
	"sec_num": null
	},
	{
	"text": "Regular expressions are a formal way for defining regular languages. Regular language operations construct regular expressions in a convenient way. Several toolboxes (software packages) provide extended regular expression description languages and compil-",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "A Regular Expression Language for FSRAs",
	"sec_num": "4."
	},
	{
	"text": "FSRA for a given CNF formula.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "ers of the expressions to finite-state devices, automata, and transducers (see Section 1). We provide a regular expression language for constructing FSRAs, the denotations of whose expressions are FSRAs. In the following discussion we assume the regular expression syntax of XFST (Beesley and Karttunen 2003) for basic expressions. 7",
	"cite_spans": [
	{
	"start": 280,
	"end": 308,
	"text": "(Beesley and Karttunen 2003)",
	"ref_id": "BIBREF2"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 10",
	"sec_num": null
	},
	{
	"text": "Let Actions \u0393 n = {R, W} \u00d7 {0, 1, 2, . . . , n \u2212 1} \u00d7 \u0393,",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "where n is the number of registers and \u0393 is the register alphabet. If R is a regular expression and a \u2208 Actions \u0393 n + is a series of register operations, then the following are also regular expressions: a R, a R, a R, and a R.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "We now define the denotation of each of the above expressions. Let R be a regular expression whose denotation is the FSRA A, and let a \u2208 Actions \u0393 n + . The denotation of a R is an FSRA A obtained from A by adding a new node, q, which becomes the initial node of A , and an arc from q to the initial node of A; this arc is labeled by and associated with a. Notice that in the regular expression a R, R and a can contain operations on joint registers. In some cases, one would like to distinguish between the registers used in a and in R. Usually, it is up to the user to correctly manipulate the usage of registers, but in some cases automatic distinction seems desirable. For example, if R includes a circumfix operator (see below), its corresponding FSRA will contain register operations created automatically by the operator. Instead of remembering that circumfixation always uses register 1, one can simply distinguish between the registers of a and R via the a R operator. This operator has the same general effect as the previous one, but the transition relation in its FSRA uses fresh registers that are added to the machine.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "In a similar way, the operators a R and a R are translated into networks. The difference between these operators and the previous ones is that here, the register operations in a are executed after traversing all the arcs in the FSRA denoted by R. Using these additional operators, it is easy to show that every FSRA has a corresponding regular expression denoting it, by a trivial modification of the construction presented by Kleene (1956) .",
	"cite_spans": [
	{
	"start": 427,
	"end": 440,
	"text": "Kleene (1956)",
	"ref_id": "BIBREF12"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Consider the case of vowel harmony in Warlpiri (Sproat 1992) , where the vowel of suffixes agrees in certain aspects with the vowel of the stem to which it is attached.",
	"cite_spans": [
	{
	"start": 47,
	"end": 60,
	"text": "(Sproat 1992)",
	"ref_id": "BIBREF20"
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "A simplified account of the phenomenon is that suffixes come in two varieties, one with 'i' vowels and one with 'u' vowels. Stems whose last vowel is 'i' take suffixes of the first variety, whereas stems whose last vowel is 'u' or 'a' take the other variety. The following examples are from Sproat (1992) (citing Nash (1980) % words ending in 'u' define LexA [m i n i j a];",
	"cite_spans": [
	{
	"start": 291,
	"end": 304,
	"text": "Sproat (1992)",
	"ref_id": "BIBREF20"
	},
	{
	"start": 305,
	"end": 324,
	"text": "(citing Nash (1980)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "% words ending in 'a' ! Join all the lexicons and write to register 1 'u' or 'i' ! according to the stem's last vowel.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "define Stem [<(W,1,i)> LexI] \| [<(W,1,u)> [LexU \| LexA]]",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "; ! Traverse the arc only if the scanned symbol is the content of ! register 1.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "define V [<(R,1,i)> i] \| [<(R,1,u)> u]; define PROP [+ k V l V]; % PROP suffix define ERG [+ l V]; % ERG suffix define Then [+ l k V];",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "% suffix indicating 'then' define Me",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "[+ j V]; % suffix indicating 'me' define They [+ l V]; % suffix indicating 'they' ! define the whole network define WarlpiriExample Stem PROP ERG Then Me They;",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "Register 1 stores the last vowel of the stem, eliminating the need to duplicate paths for each of the different cases. The lexicon is divided into three separate lexicons (LexI, LexU, LexA), one for each word ending ('i', 'u', or 'a' respectively) . The separate lexicons are joined into one (the variable Stem) and when reading the last letter of the base word, its type is written into register 1. Then, when suffixing the lexicon base words, the variable V uses the the content of register 1 to determine which of the symbols 'i', 'u' should be scanned and allows traversing the arc only if the correct symbol is scanned. Note that this solution is applicable independently of the size of the lexicon, and can handle other suffixes in the same way.",
	"cite_spans": [
	{
	"start": 216,
	"end": 247,
	"text": "('i', 'u', or 'a' respectively)",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 8",
	"sec_num": null
	},
	{
	"text": "Consider again Example 7. The FSRA constructed for Arabic nominative definite and indefinite nouns can be denoted by the following regular expression: ! Read the definite article (if present). ! Store in register 1 whether the noun is definite or indefinite. ! Store in register 2 the actual form of the definite article. The variable Prefix denotes the arcs connecting the first two states of the FSRA, in which the definite article (if present) is scanned and information indicating whether the word is definite or not is saved into register 1. In addition, if the word is definite then register 2 stores the actual form of the definite article. The lexicon is divided into several parts: The Base variable denotes nouns that do not trigger assimilation. Other variables ($Base, dBase) denote nouns that trigger assimilation, where for each assimilation case, a different lexicon is constructed. Each part of the lexicon deals with both its definite and indefinite nouns by allowing traversing the arcs only if the register content is appropriate. The variable Suffix denotes the correct suffix, depending on whether the noun is definite or indefinite. This is possible using the information that was stored in register 1 by the variable Prefix.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 9",
	"sec_num": null
	},
	{
	"text": "We demonstrated in examples 5 and 6 that FSRAs can model some non-concatenative phenomena more efficiently than standard finite-state devices. We now introduce new regular expression operators, accounting for our motivating linguistic phenomena, and show how expressions using these operators are compiled into the appropriate FSRA.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Linguistic Applications",
	"sec_num": "5."
	},
	{
	"text": "We introduce a dedicated regular expression operator for circumfixation and show how expressions using this operator are compiled into the appropriate FSRA. The operator accepts a regular expression, denoting a set of bases, and a set of circumfixes, each of which is a pair of regular expressions (prefix, suffix). It yields as a result an FSRA obtained by applying each circumfix to each of the bases. The main purpose of this operator is to deal with cases in which the circumfixes are pairs of strings, but it is defined such that the circumfixes can be arbitrary regular expressions.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Circumfixes",
	"sec_num": "5.1"
	},
	{
	"text": "Let \u03a3 be a finite set such that , {, }, , , \u2297 / \u2208 \u03a3. We define the \u2297 operation to be of the form",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "R \u2297 { \u03b2 1 \u03b3 1 \u03b2 2 \u03b3 2 . . . \u03b2 m \u03b3 m }",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "where: m \u2208 N is the number of circumfixes; R is a regular expression over \u03a3 denoting the set of bases; and \u03b2 i , \u03b3 i for 1 \u2264 i \u2264 m are regular expressions over \u03a3 denoting the prefix and suffix of the i-th circumfix, respectively. Notice that R, \u03b2 i , \u03b3 i may denote infinite sets. To define the denotation of this operator, let A \u03b2 i , A \u03b3 i be the FSRAs denoted by \u03b2 i , \u03b3 i , respectively. The operator yields an FSRA constructed by concatenating three FSRAs. The first is the FSRA constructed from the union of the FSRAs A i ; this arc is labeled by and associated with (W, 1, \u03b2 i \u03b3 i ) (register 1 is used to store the circumfix). In addition, the register operations of the FSRA A \u03b2 i are shifted by one register in order not to cause undesired effects by the use of register 1. The second FSRA is the FSRA denoted by the regular expression R (again, with one register shift) and the third is constructed in the same way as the first one, the only difference being that the FSRAs are those denoted by \u03b3 1 , . . . , \u03b3 m and the associated register operation is (R, 1, \u03b2 i \u03b3 i ) . Notice that the concatenation operation, defined in Section 3.2.2, adjusts the register operations in the FSRAs to be concatenated, to avoid undesired effects caused by using joint registers. We use this operation to concatenate the three FSRAs, leaving register 1 unaffected (to handle the circumfix).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "Consider the participle-forming combinations in German, e.g., the circumfix ge-t. A simplified account of the phenomenon is that German verbs in their present form take an n suffix but in participle form they take the circumfix ge-t. The following examples are from Sproat (1992): s\u00e4useln 'rustle' ges\u00e4uselt 'rustled' br\u00fcsten 'brag' gebr\u00fcstet 'bragged'",
	"cite_spans": [
	{
	"start": 266,
	"end": 332,
	"text": "Sproat (1992): s\u00e4useln 'rustle' ges\u00e4uselt 'rustled' br\u00fcsten 'brag'",
	"ref_id": null
	}
	],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 10",
	"sec_num": null
	},
	{
	"text": "The FSRA of Figure 11 , which accepts the four forms, is denoted by the regular expression",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 12,
	"end": 21,
	"text": "Figure 11",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Example 10",
	"sec_num": null
	},
	{
	"text": "[s\u00e4 u s e l \| b r\u00fc s t e] \u2297 { n g e t }",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 10",
	"sec_num": null
	},
	{
	"text": "This regular expression can be easily extended to accept more German verbs in other forms. More circumfixation phenomena in other languages such as Indonesian and Arabic can be modeled in the same way using this operator.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 10",
	"sec_num": null
	},
	{
	"text": "Participle-forming combinations in German.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 11",
	"sec_num": null
	},
	{
	"text": "Interdigitation FSRA -general.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 12",
	"sec_num": null
	},
	{
	"text": "r \u0393 = {\u03b2 i \| 1 \u2264 i \u2264 k} \u222a {\u03b1 i \| 1 \u2264 i \u2264 m} \u222a {#}. r \u03b4 = {(q 0 , \u03b2 i1 , W, 1, \u03b2 i , q 1 )\| 1 \u2264 i \u2264 k} \u222a {(q 1 , \u03b1 i1 , W, 2, \u03b1 i , q 2 )\| 1 \u2264 i \u2264 m} \u222a {(q 2j\u22122 , \u03b2 ij , R, 1, \u03b2 i , q 2j\u22121 )\| 1 \u2264 i \u2264 k , 2 \u2264 j \u2264 n + 1} \u222a {(q 2j\u22121 , \u03b1 ij , R, 2, \u03b1 i , q 2j )\| 1 \u2264 i \u2264 m , 2 \u2264 j \u2264 n}",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 12",
	"sec_num": null
	},
	{
	"text": "This FSRA is shown in Figure 12 . It has 3 registers, where register 1 remembers the pattern and register 2 remembers the root. Notice that the FSRA will have 3 registers and 2n + 2 states for any number of roots and patterns. The number of arcs is k \u00d7 (n + 1) + m \u00d7 n. In the (default) case of trilateral roots, for m roots and k patterns the resulting machine has a constant number of states and O(k + m) arcs.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 22,
	"end": 31,
	"text": "Figure 12",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Figure 12",
	"sec_num": null
	},
	{
	"text": "In the general case, where \u03b1 ij and \u03b2 ij can be arbitrary regular expressions, the construction of the FSRA denoted by this operation is done in the same way as in the case of circumfixes with two main adjustments. The first is that in this case the final FSRA is constructed by concatenating 2n + 1 intermediate FSRAs (n FSRAs for the n parts of the roots and n + 1 FSRAs for the n + 1 parts of the patterns). The second is that here, 2 registers are used to remember both the root and the pattern. We suppress the detailed description of the construction.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 12",
	"sec_num": null
	},
	{
	"text": "Consider again the Hebrew roots r. $.m, p.&.l, p.q.d Figure 13 . The -arc was added only for the convenience of the drawing. It should be noted that like other processes of derivational morphology, Hebrew word formation is highly idiosyncratic: Not all roots combine with all patterns, and there is no systematic way to determine when such combinations will be realized in the language. Yet, this does not render our proposed operators useless: One can naturally characterize classes of roots and classes of patterns for which all the combinations exist. Furthermore, even when such a characterization is difficult to come by, the splice operator can be used, in combination with other extended regular expression operators, to define complex expressions for generating the required language. This is compatible with the general approach for using finite-state techniques, implementing each phenomenon independently and combining them together using closure properties.",
	"cite_spans": [
	{
	"start": 35,
	"end": 52,
	"text": "$.m, p.&.l, p.q.d",
	"ref_id": null
	}
	],
	"ref_spans": [
	{
	"start": 53,
	"end": 62,
	"text": "Figure 13",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Example 12",
	"sec_num": null
	},
	{
	"text": "We now return to the reduplication problem as was presented in example 3. We extend the finite-state registered model to efficiently accept L n = {ww \| w \u2208 \u03a3 * , \|w\| = n}, a finite instance of the general problem, which is arguably sufficient for describing reduplication in natural languages. Using FSRAs as defined above does not improve space efficiency, because a separate path for each reduplication is still needed. Notice that the different symbols in L n have no significance except the pattern they create. Therefore, FSRAs are extended in order to be able to identify a pattern without actually distinguishing between different symbols in it. The extended model, FSRA, is obtained from the FSRA-1 model by adding a new symbol, '', assumed not to belong to \u03a3, and by forcing \u0393 to be equal to \u03a3. The '*' indicates equality between the input symbol and the designated register content, eliminating the need to duplicate paths for different symbols.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Reduplication",
	"sec_num": "5.3"
	},
	{
	"text": "Interdigitation example.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 13",
	"sec_num": null
	},
	{
	"text": "Let * / \u2208 \u03a3. An FSRA* is an FSRA-1 where \u03a3 = \u0393 (and thus includes '#') and the transition function is extended to be \u03b4",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "\u2286 Q \u00d7 \u03a3 \u222a { , * } \u00d7 {R, W} \u00d7 {0, 1, 2, . . . , n \u2212 1} \u00d7 \u03a3 \u222a { * } \u00d7 Q.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "The extended meaning of \u03b4 is as follows: r (s, \u03c3, R, i, * , t) \u2208 \u03b4 and (s, * , R, i, \u03c3, t) \u2208 \u03b4 for \u03c3 = imply that if the automaton is in state s, the input symbol is \u03c3 and the content of the i-th register is the same \u03c3, then the automaton may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r (s, \u03c3, R, i, \u03b3, t) \u2208 \u03b4, (s, \u03c3, W, i, \u03b3, t) \u2208 \u03b4",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r (s, \u03c3, W, i, * , t) \u2208 \u03b4 and (s, * , W, i, \u03c3, t) \u2208 \u03b4 for \u03c3 = imply that if the automaton is in state s and the input symbol is \u03c3, then the content of the i-th register is changed to \u03c3, and the automaton may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r (s, * , R, i, * , t) \u2208 \u03b4 implies that if the automaton is in state s, the input symbol is some \u03c3 \u2208 \u03a3 and the content of the i-th register is the same \u03c3, then the automaton may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "r (s, * , W, i, * , t) \u2208 \u03b4 implies that if the automaton is in state s and the input symbol is some \u03c3 \u2208 \u03a3, then the content of the i-th register is changed to the same \u03c3, and the automaton may enter state t.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "With this extended model we can construct an efficient registered automaton for L n : The number of registers is n+1. Registers 1, ..., n remember the first n symbols to be duplicated. Figure 14 depicts an extended registered automaton that accepts L n for n = 4. Notice that the number of states depends only on n and not on the size of \u03a3. Figure 15 schematically depicts an extended registered automaton that accepts L n for some n \u2208 N. The language {ww \| \|w\| \u2264 n} for some n \u2208 N can be generated by a union of FSRA*, each one generating L n for some i \u2264 n. Since n is usually small in natural language reduplication, the resulting automaton is manageable, and in any case, considerably smaller than the na\u00efve automaton.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 185,
	"end": 194,
	"text": "Figure 14",
	"ref_id": "FIGREF0"
	},
	{
	"start": 341,
	"end": 350,
	"text": "Figure 15",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "In example 7, FSRAs are used to model assimilation in Arabic nominative definite nouns. Using the FSRA* model defined above, further reduction in the network size can be achieved. The FSRA* of Figure 16 accepts all the nominative definite forms of the Arabic nouns kitaab, qamar, and daftar (more nouns can be added in a similar way). Register 1 stores information about the actual form of the definite article, to ensure that assimilation occurs when needed and only then. Notice that in this FSRA, in contrast to automata, but the FSRT solution is more intuitive and is based on existing finite-state techniques.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 193,
	"end": 202,
	"text": "Figure 16",
	"ref_id": "FIGREF0"
	}
	],
	"eq_spans": [],
	"section": "Assimilation",
	"sec_num": "5.4"
	},
	{
	"text": "It is easy to show that FSRTs, just like FSRAs, are equivalent to their non-registered counterparts. It immediately implies that FSRTs maintain the closure properties of regular relations. As in FSRAs, implementing the closure properties directly on FSRTs is essential for benefiting from their space efficiency. The common operators such as union, concatenation, etc., are implemented in the same ways as in FSRAs. A direct implementation of FSRT composition is a na\u00efve extension of ordinary transducer composition, based on the intersection construction of FSRAs. We explicitly define these operations in Cohen-Sygal (2004).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Assimilation",
	"sec_num": "5.4"
	},
	{
	"text": "In order to practically compare the space and time performance of FSRAs and FSAs, we have implemented the special operators introduced in Sections 4 and 5 for circumfixation and interdigitation, as well as direct construction of FSRAs. We have compared FSRAs with ordinary FSAs by building corresponding networks for circumfixation, interdigitation, and n-bit incrementation. For circumfixation, we constructed networks for the circumfixation of 1,043 Hebrew roots and 4 circumfixes. For interdigitation we constructed a network accepting the splicing of 1,043 roots into 20 patterns. For n-bit incrementation we constructed networks for 10-bit, 50-bit, and 100-bit incrementors. Table 1 displays the size of each of the networks in terms of states, arcs, and actual file size. Clearly, FSRAs provide a significant reduction in the network size. In particular, we could not construct an n-bit incrementor FSA for any n greater than 100 as a result of memory problems, whereas using FSRAs we had no problem constructing networks even for n = 50, 000.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 680,
	"end": 687,
	"text": "Table 1",
	"ref_id": "TABREF9"
	}
	],
	"eq_spans": [],
	"section": "Implementation and Evaluation",
	"sec_num": "7."
	},
	{
	"text": "In addition, we compared the recognition times of the two models. For that purpose, we used the circumfixation, interdigitation, 10-bit incrementation, and 50-bit incrementation networks to analyze 200, 1,000, and 5,000 words. As can be seen in Table 2 , time performance is comparable for the two models, except for interdigitation, where FSAs outperform FSRAs by a constant factor. The reason is that in this network the usage of registers is massive and thereby, there is a higher cost to the reduction of the network size, in terms of analysis time. This is an instance of the common tradeoff of time versus space: FSRAs improve the network size at the cost of slower analysis time in some cases. When using finite-state devices for natural language processing, often the generated networks become too large to be practical. In such cases, using FSRAs can make network size manageable. Using the closure constructions one can build desired networks of reasonable size, and at the end decide whether to convert them to ordinary FSAs, if time performance is an issue.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 245,
	"end": 252,
	"text": "Table 2",
	"ref_id": "TABREF10"
	}
	],
	"eq_spans": [],
	"section": "Implementation and Evaluation",
	"sec_num": "7."
	},
	{
	"text": "In this work we introduce finite-state registered networks (automata and transducers), an extension of finite-state networks which adds a limited amount of memory, in the form of registers, to each transition. We show how FSRAs can be used to efficiently model several non-concatenative morphological phenomena, including circumfixation, root and pattern word formation in Semitic languages, vowel harmony, and limited reduplication.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "The main advantage of finite-state registered networks is their space efficiency. We show that every FSA can be simulated by an equivalent FSRA with three states and two registers. For the motivating linguistic examples, we show a significant decrease in the number of states and the number of transitions. For example, to account for all the possible combinations of r roots and p patterns, an ordinary FSA requires O(r \u00d7 p) arcs whereas an FSRA requires only O(r + p). As a non-linguistic example, we show a transducer that computes n-bit increments of binary numbers. While an ordinary (sequential) FST requires O(2 n ) states and arcs, an FSRT which guarantees linear recognition time requires only O(n) states and arcs.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "In spite of their efficiency, finite-state registered networks are equivalent, in terms of their expressive power, to ordinary finite state networks. We provide an algorithm for converting FSRAs to FSAs and prove the equivalence of the models. Furthermore, we provide direct constructions of the main closure properties of FSAs for FSRAs, including concatenation, union, intersection, and composition.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "In order for finite-state networks to be useful for linguistic processing, we provide a regular expression language denoting FSRAs. In particular, we provide a set of extended regular expression operators that denote FSRAs and FSRTs. We demonstrate the utility of the operators by accounting for a variety of complex morphological and phonological phenomena, including circumfixation (Hebrew and German), root-andpattern (Hebrew), vowel harmony (Warlpiri), assimilation (Arabic), and limited reduplication. These dedicated operators can be used in conjunction with standard finite state calculi, thereby providing a complete set of tools for the computational treatment of non-concatenative morphology.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "This work opens a variety of directions for future research. An immediate question is the conversion of FSAs to FSRAs. While it is always possible to convert a given FSA to an FSRA (simply add one register which is never used), we believe that it is possible to automatically convert space inefficient FSAs to more compact FSRAs. A pre-requisite is a clear understanding of the parameters for minimization: These include the number of states, arcs, and registers, and the size of the register alphabet. For a given FSRA, the number of states can always be reduced to a constant (theorem 3) and registers can be done away with entirely (by converting the FSRA to an FSA, Section 3.1). In contrast, minimizing the number of arcs in an FSRA is NP-hard (Section 3.4). A useful conversion of FSAs to FSRAs must minimize some combination of these parameters, and while it may be intractable in general, it can be practical in many special cases. In particular, the case of finite languages (acyclic FSAs) is both of practical importance and -we conjecture -can result in good compaction.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "More work is also needed in order to establish more properties of FSRTs. In particular, we did not address issues such as sequentiality or sequentiability for this model. Similarly, FSRA * can benefit from further research. All the closure constructions for FSRA * s can be done in a similar way to FSRAs, with the exception of intersection. For intersection, we believe that the use of predicates (van Noord and Gerdemann 2001b) can be beneficial. Furthermore, the use of predicates can be beneficial for describing natural language reduplication where the reduplication is not as bounded as the example we deal with in this work. In addition, the FSRA * model can be extended into transducers.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "Finally, in Section 7 we discuss an implementation of FSRAs. Although we have used this system to construct networks for several phenomena, we are interested in constructing a network for describing the complete morphology of a natural language containing many non-concatenative phenomena, e.g., Hebrew. A morphological analyzer for Hebrew, based on finite-state calculi, already exists (Yona and Wintner 2005), but is very space-inefficient and, therefore, hard to maintain. It would be beneficial to compact such a network using FSRTs, and to inspect the time versus space tradeoff on such a comprehensive network.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Conclusions",
	"sec_num": "8."
	},
	{
	"text": "Many of the vowels are not explicitly depicted in the Hebrew script. 3 This is an over-simplified example; in practice, the process of combining roots with patterns is highly idiosyncratic, like other derivational morphological processes.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "",
	"sec_num": null
	},
	{
	"text": "A complete explanation of the construction can be found in http://www.xrce.xerox.com/competencies/ content-analysis/fsCompiler/fsexamples.html#Add1. 5 Many of the formal proofs and constructions, especially the ones that are similar to the case of standard FSAs, are suppressed; seeCohen-Sygal (2004) for the complete proofs and constructions.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "",
	"sec_num": null
	},
	{
	"text": "While this theorem is a part of folklore, we were unable to find a formal proof. We explicitly prove this theorem inCohen-Sygal (2004).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "",
	"sec_num": null
	},
	{
	"text": "In particular, concatenation is denoted by juxtaposition and is denoted by 0.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "",
	"sec_num": null
	}
	],
	"back_matter": [
	{
	"text": "We are grateful to Dale Gerdemann for his help and inspiration. We thank Victor Harnik and Nissim Francez for their comments on an earlier version of this paper. We are also thankful to the anonymous reviewers, whose comments helped substantially to improve this article. This research was supported by The Israel Science Foundation (grant no. 136/01).",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Acknowledgments",
	"sec_num": null
	},
	{
	"text": "Consider again Example 5. The FSRA accepting all the possible combinations of stems and the Hebrew circumfixes h-a, ht-ut, mcan be denoted by the regular expression R \u2297 { h a ht ut m } where R denotes an FSA accepting the roots.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Example 11",
	"sec_num": null
	},
	{
	"text": "Next, we define a dedicated operator for interdigitation. It accepts a set of regular expressions, representing a set of roots, and a list of patterns, each of which containing exactly n slots. It yields as a result an FSRA denoting the set containing all the strings created by splicing the roots into the slots in the patterns. For example, consider the Hebrew roots r.$.m, p.&.l, p.q.d and the Hebrew patterns hit a e , mi a , ha a a. The roots are all trilateral, and the patterns have three slots each. Given these two inputs, the new operator yields an FSRA denoting the set {hitra$em, hitpa&el, hitpaqed, mir$am, mip&al, mipqad, har$ama, hap&ala, hapqada}.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Interdigitation",
	"sec_num": "5.2"
	},
	{
	"text": "Let \u03a3 be a finite set such that , {, }, , , \u2295 / \u2208 \u03a3. We define the splice operation to be of the formr n \u2208 N is the number of slots (represented by ' ') in the patterns into which the roots letters should be inserted.r m \u2208 N is the number of roots to be inserted. r k \u2208 N is the number of patterns. r \u03b1 ij , \u03b2 ij are regular expressions (including regular expressions denoting FSRAs).The left set is a set of roots to be inserted into the slots in the right set of patterns. For the sake of brevity, \u03b2 i and \u03b1 i are used as shorthand notations for \u03b2 i1 \u03b2 i2 ... \u03b2 i(n+1) and \u03b1 i1 \u03b1 i2 ...\u03b1 in , respectively.Consider first the case where \u03b1 ij \u2208 \u03a3 \u222a { } for 1 \u2264 i \u2264 m and 1 \u2264 j \u2264 n and \u03b2 ij \u2208 \u03a3 \u222a { } for 1 \u2264 i \u2264 k and 1 \u2264 j \u2264 n + 1. In this case the splice operation yields as a result an FSRA-1 the FSRA of Figure 8 , the definite Arabic article al is not scanned as one symbol but as two separate symbols.",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 808,
	"end": 816,
	"text": "Figure 8",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Definition",
	"sec_num": null
	},
	{
	"text": "We extend the FSRA model to finite-state registered transducers (FSRT), denoting relations over two finite alphabets. The extension is done by adding to each transition an output symbol. This facilitates an elegant solution to the problem of binary incrementors which was introduced in Example 4.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Finite-state Registered Transducers",
	"sec_num": "6."
	},
	{
	"text": "Consider again the 32-bit incrementor example introduced in Example 4. Recall that a sequential transducer for an n-bit binary incrementor would require 2 n states and a similar number of transitions. Using the FSRT model, a more efficient n-bit transducer can be constructed. A 4-bit FSRT incrementor is shown in Figure 17 . The first four transitions copy the input string into the registers, then the input is scanned (using the registers) from right to left (as the carry moves), calculating the result, and the last four transitions output the result (in case the input is 1 n , an extra 1 is added in the beginning). Notice that this transducer guarantees linear recognition time, since from each state only one arc can be traversed in each step, even when there are -arcs. In the same way, an n-bit transducer can be constructed for all n \u2208 N. Such a transducer will have n registers, 3n + 1 states and 6n arcs. The FSRT model solves the incrementor problem in much the same way it is solved by vectorized finite-state",
	"cite_spans": [],
	"ref_spans": [
	{
	"start": 314,
	"end": 323,
	"text": "Figure 17",
	"ref_id": null
	}
	],
	"eq_spans": [],
	"section": "Example 13",
	"sec_num": null
	},
	{
	"text": "FSRA* for Arabic nominative definite nouns.",
	"cite_spans": [],
	"ref_spans": [],
	"eq_spans": [],
	"section": "Figure 16",
	"sec_num": null
	}
	],
	"bib_entries": {
	"BIBREF0": {
	"ref_id": "b0",
	"title": "Constraining separated morphotactic dependencies in finite-state grammars",
	"authors": [
	{
	"first": "Kenneth",
	"middle": [
	"R"
	],
	"last": "Beesley",
	"suffix": ""
	}
	],
	"year": 1998,
	"venue": "Proceedings of FSMNLP-98",
	"volume": "",
	"issue": "",
	"pages": "118--127",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Beesley, Kenneth R. 1998. Constraining separated morphotactic dependencies in finite-state grammars. In Proceedings of FSMNLP-98, pages 118-127, Bilkent, Turkey.",
	"links": null
	},
	"BIBREF1": {
	"ref_id": "b1",
	"title": "Finite-state non-concatenative morphotactics",
	"authors": [
	{
	"first": "Kenneth",
	"middle": [
	"R"
	],
	"last": "Beesley",
	"suffix": ""
	},
	{
	"first": "Lauri",
	"middle": [],
	"last": "Karttunen",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "Proceedings of the Fifth Workshop of the ACL Special Interest Group in Computational Phonology, SIGPHON-2000",
	"volume": "",
	"issue": "",
	"pages": "1--12",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Beesley, Kenneth R. and Lauri Karttunen. 2000. Finite-state non-concatenative morphotactics. In Proceedings of the Fifth Workshop of the ACL Special Interest Group in Computational Phonology, SIGPHON-2000, pages 1-12, Luxembourg.",
	"links": null
	},
	"BIBREF2": {
	"ref_id": "b2",
	"title": "Finite-State Morphology",
	"authors": [
	{
	"first": "Kenneth",
	"middle": [
	"R"
	],
	"last": "Beesley",
	"suffix": ""
	},
	{
	"first": "Lauri",
	"middle": [],
	"last": "Karttunen",
	"suffix": ""
	}
	],
	"year": 2003,
	"venue": "",
	"volume": "",
	"issue": "",
	"pages": "",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Beesley, Kenneth R. and Lauri Karttunen. 2003. Finite-State Morphology. CSLI Publications.",
	"links": null
	},
	"BIBREF3": {
	"ref_id": "b3",
	"title": "A new kind of finite-state automaton: Register vector grammar",
	"authors": [
	{
	"first": "Glenn",
	"middle": [
	"D"
	],
	"last": "Blank",
	"suffix": ""
	}
	],
	"year": 1985,
	"venue": "Proceedings of the International Joint Conference on Artificial Intelligence",
	"volume": "",
	"issue": "",
	"pages": "749--755",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Blank, Glenn D. 1985. A new kind of finite-state automaton: Register vector grammar. In Proceedings of the International Joint Conference on Artificial Intelligence, pages 749-755, UCLA.",
	"links": null
	},
	"BIBREF4": {
	"ref_id": "b4",
	"title": "A finite and real-time processor for natural language",
	"authors": [
	{
	"first": "Glenn",
	"middle": [
	"D"
	],
	"last": "Blank",
	"suffix": ""
	}
	],
	"year": 1989,
	"venue": "Communications of the ACM",
	"volume": "32",
	"issue": "10",
	"pages": "1174--1189",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Blank, Glenn D. 1989. A finite and real-time processor for natural language. Communications of the ACM, 32(10):1174-1189.",
	"links": null
	},
	"BIBREF5": {
	"ref_id": "b5",
	"title": "Computational implementation of non-concatenative morphology",
	"authors": [
	{
	"first": "Yael",
	"middle": [],
	"last": "Cohen-Sygal",
	"suffix": ""
	}
	],
	"year": 2004,
	"venue": "",
	"volume": "",
	"issue": "",
	"pages": "",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Cohen-Sygal, Yael. 2004. Computational implementation of non-concatenative morphology. Master's thesis, Department of Computer Science, University of Haifa, Israel.",
	"links": null
	},
	"BIBREF6": {
	"ref_id": "b6",
	"title": "State complexity of basic operations on nondeterministic finite automata",
	"authors": [
	{
	"first": "Markus",
	"middle": [],
	"last": "Holzer",
	"suffix": ""
	},
	{
	"first": "Martin",
	"middle": [],
	"last": "Kutrib",
	"suffix": ""
	}
	],
	"year": 2002,
	"venue": "Implementation and Application of Automata, 7th International Conference",
	"volume": "2608",
	"issue": "",
	"pages": "148--157",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Holzer, Markus and Martin Kutrib. 2002. State complexity of basic operations on nondeterministic finite automata. In Jean-Marc Champarnaud and Denis Maurel, editors, Implementation and Application of Automata, 7th International Conference, CIAA 2002, volume 2608 of Lecture Notes in Computer Science, Springer, pages 148-157.",
	"links": null
	},
	"BIBREF7": {
	"ref_id": "b7",
	"title": "Finite memory automata",
	"authors": [
	{
	"first": "Michael",
	"middle": [],
	"last": "Kaminski",
	"suffix": ""
	},
	{
	"first": "Nissim",
	"middle": [],
	"last": "Francez",
	"suffix": ""
	}
	],
	"year": 1994,
	"venue": "Theoretical Computer Science",
	"volume": "134",
	"issue": "2",
	"pages": "329--364",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kaminski, Michael and Nissim Francez. 1994. Finite memory automata. Theoretical Computer Science, 134(2):329-364.",
	"links": null
	},
	"BIBREF8": {
	"ref_id": "b8",
	"title": "Regular models of phonological rule systems",
	"authors": [
	{
	"first": "Ronald",
	"middle": [
	"M"
	],
	"last": "Kaplan",
	"suffix": ""
	},
	{
	"first": "Martin",
	"middle": [],
	"last": "Kay",
	"suffix": ""
	}
	],
	"year": 1994,
	"venue": "Computational Linguistics",
	"volume": "20",
	"issue": "3",
	"pages": "331--378",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kaplan, Ronald M. and Martin Kay. 1994. Regular models of phonological rule systems. Computational Linguistics, 20(3):331-378.",
	"links": null
	},
	"BIBREF9": {
	"ref_id": "b9",
	"title": "Regular expressions for language engineering",
	"authors": [
	{
	"first": "Lauri",
	"middle": [],
	"last": "Karttunen",
	"suffix": ""
	},
	{
	"first": "Jean-Pierre",
	"middle": [],
	"last": "Chanod",
	"suffix": ""
	},
	{
	"first": "Gregory",
	"middle": [],
	"last": "Grefenstette",
	"suffix": ""
	},
	{
	"first": "Anne",
	"middle": [],
	"last": "Schiller",
	"suffix": ""
	}
	],
	"year": 1996,
	"venue": "Natural Language Engineering",
	"volume": "2",
	"issue": "4",
	"pages": "305--328",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Karttunen, Lauri, Jean-Pierre Chanod, Gregory Grefenstette, and Anne Schiller. 1996. Regular expressions for language engineering. Natural Language Engineering, 2(4):305-328.",
	"links": null
	},
	"BIBREF10": {
	"ref_id": "b10",
	"title": "Finite-state description of Semitic morphology: A case study of ancient Akkadian",
	"authors": [
	{
	"first": "Laura",
	"middle": [],
	"last": "Kataja",
	"suffix": ""
	},
	{
	"first": "Kimmo",
	"middle": [],
	"last": "Koskenniemi",
	"suffix": ""
	}
	],
	"year": 1987,
	"venue": "Proceedings of the Third Conference of the European Chapter of the Association for Computational Linguistics",
	"volume": "",
	"issue": "",
	"pages": "2--10",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kataja, Laura and Kimmo Koskenniemi. 1988. Finite-state description of Semitic morphology: A case study of ancient Akkadian. In Proceedings of COLING 88, International Conference on Computational Linguistics, pages 313-315, Budapest. Kay, Martin. 1987. Nonconcatenative finite-state morphology. In Proceedings of the Third Conference of the European Chapter of the Association for Computational Linguistics, pages 2-10, Copenhagen, Denmark.",
	"links": null
	},
	"BIBREF11": {
	"ref_id": "b11",
	"title": "Multitiered nonlinear morphology using multitape finite automata: A case study on Syriac and Arabic",
	"authors": [
	{
	"first": "George",
	"middle": [],
	"last": "Kiraz",
	"suffix": ""
	},
	{
	"first": "",
	"middle": [],
	"last": "Anton",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "Computational Linguistics",
	"volume": "26",
	"issue": "1",
	"pages": "77--105",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kiraz, George Anton. 2000. Multitiered nonlinear morphology using multitape finite automata: A case study on Syriac and Arabic. Computational Linguistics, 26(1):77-105.",
	"links": null
	},
	"BIBREF12": {
	"ref_id": "b12",
	"title": "Representation of events in nerve nets and finite automata",
	"authors": [
	{
	"first": "S",
	"middle": [
	"C"
	],
	"last": "Kleene",
	"suffix": ""
	}
	],
	"year": 1956,
	"venue": "Automata Studies",
	"volume": "",
	"issue": "",
	"pages": "3--42",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kleene, S. C. 1956. Representation of events in nerve nets and finite automata. In C. E. Shannon and J. McCarthy, editors, Automata Studies. Princeton University Press, pages 3-42.",
	"links": null
	},
	"BIBREF13": {
	"ref_id": "b13",
	"title": "Two-Level Morphology: A General Computational Model for Word-Form Recognition and Production. The Department of General Linguistics",
	"authors": [
	{
	"first": "Andr\u00e1s",
	"middle": [],
	"last": "Kornai",
	"suffix": ""
	}
	],
	"year": 1983,
	"venue": "Proceedings of the Workshop on Extended Finite-State Models of Languages in the 12th European Conference on Artificial Intelligence",
	"volume": "",
	"issue": "",
	"pages": "36--41",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Kornai, Andr\u00e1s. 1996. Vectorized finite-state automata. In Proceedings of the Workshop on Extended Finite-State Models of Languages in the 12th European Conference on Artificial Intelligence, pages 36-41, Budapest. Koskenniemi, Kimmo. 1983. Two-Level Morphology: A General Computational Model for Word-Form Recognition and Production. The Department of General Linguistics, University of Helsinki.",
	"links": null
	},
	"BIBREF14": {
	"ref_id": "b14",
	"title": "Transducers and grammars as theories of language",
	"authors": [
	{
	"first": "Steven",
	"middle": [],
	"last": "Krauwer",
	"suffix": ""
	},
	{
	"first": "Louis",
	"middle": [],
	"last": "Des Tombe",
	"suffix": ""
	}
	],
	"year": 1981,
	"venue": "Theoretical Linguistics",
	"volume": "8",
	"issue": "",
	"pages": "173--202",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Krauwer, Steven and Louis des Tombe. 1981. Transducers and grammars as theories of language. Theoretical Linguistics, 8:173-202.",
	"links": null
	},
	"BIBREF15": {
	"ref_id": "b15",
	"title": "On the applicability of two-level morphology to the inflection of Hebrew verbs",
	"authors": [
	{
	"first": "Alon",
	"middle": [],
	"last": "Lavie",
	"suffix": ""
	},
	{
	"first": "Alon",
	"middle": [],
	"last": "Itai",
	"suffix": ""
	},
	{
	"first": "Uzzi",
	"middle": [],
	"last": "Ornan",
	"suffix": ""
	},
	{
	"first": "Mori",
	"middle": [],
	"last": "Rimon",
	"suffix": ""
	}
	],
	"year": 1988,
	"venue": "",
	"volume": "",
	"issue": "",
	"pages": "",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Lavie, Alon, Alon Itai, Uzzi Ornan, and Mori Rimon. 1988. On the applicability of two-level morphology to the inflection of Hebrew verbs. Technical Report 513, Department of Computer Science, Technion, 32000 Haifa, Israel.",
	"links": null
	},
	"BIBREF16": {
	"ref_id": "b16",
	"title": "On some applications of finite-state automata theory to natural language processing",
	"authors": [
	{
	"first": "Mehryar",
	"middle": [],
	"last": "Mohri",
	"suffix": ""
	}
	],
	"year": 1996,
	"venue": "Natural Language Engineering",
	"volume": "2",
	"issue": "1",
	"pages": "61--80",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Mohri, Mehryar. 1996. On some applications of finite-state automata theory to natural language processing. Natural Language Engineering, 2(1):61-80.",
	"links": null
	},
	"BIBREF17": {
	"ref_id": "b17",
	"title": "Generic epsilon-removal algorithm for weighted automata",
	"authors": [
	{
	"first": "Mehryar",
	"middle": [],
	"last": "Mohri",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "5th International Conference",
	"volume": "2088",
	"issue": "",
	"pages": "230--242",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Mohri, Mehryar. 2000. Generic epsilon-removal algorithm for weighted automata. In Sheng Yu and Andrei Paun, editors, 5th International Conference, CIAA 2000, volume 2088, Springer-Verlag, pages 230-242.",
	"links": null
	},
	"BIBREF18": {
	"ref_id": "b18",
	"title": "The design principles of a weighted finite-state transducer library",
	"authors": [
	{
	"first": "Mehryar",
	"middle": [],
	"last": "Mohri",
	"suffix": ""
	},
	{
	"first": "Fernando",
	"middle": [],
	"last": "Pereira",
	"suffix": ""
	},
	{
	"first": "Michael",
	"middle": [],
	"last": "Riley",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "Theoretical Computer Science",
	"volume": "231",
	"issue": "1",
	"pages": "17--32",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Mohri, Mehryar, Fernando Pereira, and Michael Riley. 2000. The design principles of a weighted finite-state transducer library. Theoretical Computer Science, 231(1):17-32.",
	"links": null
	},
	"BIBREF19": {
	"ref_id": "b19",
	"title": "Topics in Warlpiri Grammar",
	"authors": [
	{
	"first": "David",
	"middle": [],
	"last": "Nash",
	"suffix": ""
	}
	],
	"year": 1980,
	"venue": "",
	"volume": "",
	"issue": "",
	"pages": "",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Nash, David. 1980. Topics in Warlpiri Grammar. Ph.D. thesis, Massachusetts Institute of Technology.",
	"links": null
	},
	"BIBREF20": {
	"ref_id": "b20",
	"title": "An extendible regular expression compiler for finite-state approaches in natural language processing",
	"authors": [
	{
	"first": "Richard",
	"middle": [
	"W"
	],
	"last": "Sproat",
	"suffix": ""
	},
	{
	"first": "M",
	"middle": [
	"A"
	],
	"last": "Cambridge",
	"suffix": ""
	},
	{
	"first": "Gertjan",
	"middle": [],
	"last": "Van Noord",
	"suffix": ""
	},
	{
	"first": "Dale",
	"middle": [],
	"last": "Gerdemann",
	"suffix": ""
	}
	],
	"year": 1992,
	"venue": "Automata Implementation, 4th International Workshop on Implementing Automata, WIA'99",
	"volume": "",
	"issue": "",
	"pages": "263--286",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Sproat, Richard W. 1992. Morphology and Computation. MIT Press, Cambridge, MA. van Noord, Gertjan and Dale Gerdemann. 2001a. An extendible regular expression compiler for finite-state approaches in natural language processing. In O. Boldt and H. J\u00fcrgensen, editors, Automata Implementation, 4th International Workshop on Implementing Automata, WIA'99, Potsdam, Germany, Revised Papers, number 2214 in Lecture Notes in Computer Science. Springer. van Noord, Gertjan and Dale Gerdemann. 2001b. Finite state transducers with predicates and identity. Grammars, 4(3):263-286.",
	"links": null
	},
	"BIBREF21": {
	"ref_id": "b21",
	"title": "Finite-state reduplication in one-level prosodic morphology",
	"authors": [
	{
	"first": "Markus",
	"middle": [],
	"last": "Walther",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "Proceedings of the First Conference of the North American Chapter of the Association for Computational Linguistics",
	"volume": "",
	"issue": "",
	"pages": "296--302",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Walther, Markus. 2000a. Finite-state reduplication in one-level prosodic morphology. In Proceedings of the First Conference of the North American Chapter of the Association for Computational Linguistics, pages 296-302, Seattle.",
	"links": null
	},
	"BIBREF22": {
	"ref_id": "b22",
	"title": "Temiar reduplication in one-level prosodic morphology",
	"authors": [
	{
	"first": "Markus",
	"middle": [],
	"last": "Walther",
	"suffix": ""
	},
	{
	"first": "Shuly",
	"middle": [],
	"last": "Wintner",
	"suffix": ""
	}
	],
	"year": 2000,
	"venue": "Proceedings of the ACL-2005 Workshop on Computational Approaches to Semitic Languages",
	"volume": "",
	"issue": "",
	"pages": "13--21",
	"other_ids": {},
	"num": null,
	"urls": [],
	"raw_text": "Walther, Markus. 2000b. Temiar reduplication in one-level prosodic morphology. In Proceedings of SIGPHON, Workshop on Finite-State Phonology, pages 13-21, Luxembourg. Yona, Shlomo and Shuly Wintner. 2005. A finite-state morphological grammar of Hebrew. In Proceedings of the ACL-2005 Workshop on Computational Approaches to Semitic Languages, Ann Arbor.",
	"links": null
	}
	},
	"ref_entries": {
	"FIGREF0": {
	"type_str": "figure",
	"text": "Na\u00efve FSA with duplicated paths.",
	"num": null,
	"uris": null
	},
	"FIGREF1": {
	"type_str": "figure",
	"text": "FSA for the pattern hit a e .",
	"num": null,
	"uris": null
	},
	"FIGREF2": {
	"type_str": "figure",
	"text": "-tape representation for the Hebrew word htpqdut.",
	"num": null,
	"uris": null
	},
	"FIGREF3": {
	"type_str": "figure",
	"text": "automaton for circumfixation example.",
	"num": null,
	"uris": null
	},
	"FIGREF4": {
	"type_str": "figure",
	"text": "FSRA for circumfixation.",
	"num": null,
	"uris": null
	},
	"FIGREF5": {
	"type_str": "figure",
	"text": "FSRA for the pattern hit a e .",
	"num": null,
	"uris": null
	},
	"FIGREF6": {
	"type_str": "figure",
	"text": "FSRA-2 for Arabic nominative definite and indefinite nouns.",
	"num": null,
	"uris": null
	},
	"FIGREF7": {
	"type_str": "figure",
	"text": "3.3.1 -removal. An -arc in an FSRA is an arc of the form (s, , a , t) where a is used as a meta-variable over Actions \u0393 n + (i.e., a represents a vector of register operations).",
	"num": null,
	"uris": null
	},
	"FIGREF8": {
	"type_str": "figure",
	"text": ". . . , A \u03b2 m , where each A \u03b2 i is an FSRA obtained from A \u03b2 i by adding a new node, q, which becomes the initial node of A \u03b2 i , and an arc from q to the initial node of A \u03b2",
	"num": null,
	"uris": null
	},
	"FIGREF9": {
	"type_str": "figure",
	"text": "where \u03c3, \u03b3 = * imply the same as before.",
	"num": null,
	"uris": null
	},
	"FIGREF10": {
	"type_str": "figure",
	"text": "Reduplication for n = 4.",
	"num": null,
	"uris": null
	},
	"FIGREF11": {
	"type_str": "figure",
	"text": "Figure 17 4-bit incrementor using FSRT.",
	"num": null,
	"uris": null
	},
	"TABREF0": {
	"text": "n\u22121 iff the following holds:",
	"num": null,
	"html": null,
	"type_str": "table",
	"content": "<table/>"
	},
	"TABREF1": {
	"text": "For example, nominative case is realized as the suffix u on definite nouns, un on indefinite nouns. Examples of the different forms of",
	"num": null,
	"html": null,
	"type_str": "table",
	"content": "<table><tr><td>Arabic nouns are:</td><td/><td/></tr><tr><td>word</td><td colspan=\"2\">nominative definite nominative indefinite</td></tr><tr><td>qamar</td><td>'alqamaru</td><td>qamarun</td></tr><tr><td>kitaab</td><td>'alkitaabu</td><td>kitaabun</td></tr><tr><td>$ams</td><td>'a$$amsu</td><td>$amsun</td></tr><tr><td>daftar</td><td>'addaftaru</td><td>daftarun</td></tr></table>"
	},
	"TABREF3": {
	"text": "0 is the initial state, q f is the final states representative, and q nf is the non-final states representative",
	"num": null,
	"html": null,
	"type_str": "table",
	"content": "<table/>"
	},
	"TABREF9": {
	"text": "Space comparison between FSAs and FSRAs.",
	"num": null,
	"html": null,
	"type_str": "table",
	"content": "<table><tr><td>Operation</td><td>Network type</td><td>States</td><td>Arcs</td><td>Registers</td><td>File size</td></tr><tr><td>Circumfixation</td><td>FSA</td><td>811</td><td>3,824</td><td>-</td><td>47kB</td></tr><tr><td colspan=\"2\">(4 circumfixes, 1,043 roots) FSRA</td><td>356</td><td>360</td><td>1</td><td>16kB</td></tr><tr><td>Interdigitation</td><td>FSA</td><td>12,527</td><td>31,077</td><td>-</td><td>451kB</td></tr><tr><td>(20 patterns, 1,043 roots)</td><td>FSRA</td><td>58</td><td>3,259</td><td>2</td><td>67kB</td></tr><tr><td>10-bit incrementor</td><td>Sequential FST</td><td>268</td><td>322</td><td>-</td><td>7kB</td></tr><tr><td/><td>FSRT</td><td>31</td><td>60</td><td>10</td><td>2kB</td></tr><tr><td>50-bit incrementor</td><td>Sequential FST</td><td>23,328</td><td>24,602</td><td>-</td><td>600kB</td></tr><tr><td/><td>FSRT</td><td>151</td><td>300</td><td>50</td><td>8kB</td></tr><tr><td>100-bit incrementor</td><td colspan=\"3\">Sequential FST 176,653 181,702</td><td>-</td><td>4.73Mb</td></tr><tr><td/><td>FSRT</td><td>301</td><td>600</td><td>100</td><td>17kB</td></tr></table>"
	},
	"TABREF10": {
	"text": "Time comparison between FSAs and FSRAs.",
	"num": null,
	"html": null,
	"type_str": "table",
	"content": "<table><tr><td/><td/><td colspan=\"3\">200 words 1,000 words 5,000 words</td></tr><tr><td>Circumfixation</td><td>FSA</td><td>0.01s</td><td>0.02s</td><td>0.08s</td></tr><tr><td colspan=\"2\">(4 circumfixes, 1,043 roots) FSRA</td><td>0.01s</td><td>0.02s</td><td>0.09s</td></tr><tr><td>Interdigitation</td><td>FSA</td><td>0.01s</td><td>0.02s</td><td>1s</td></tr><tr><td>(20 patterns, 1,043 roots)</td><td>FSRA</td><td>0.35s</td><td>1.42s</td><td>10.11s</td></tr><tr><td>10-bit incrementor</td><td>Sequential FST</td><td>0.01s</td><td>0.05s</td><td>0.17s</td></tr><tr><td/><td>FSRT</td><td>0.01s</td><td>0.06s</td><td>0.23s</td></tr><tr><td>50-bit incrementor</td><td>Sequential FST</td><td>0.13s</td><td>0.2s</td><td>0.59s</td></tr><tr><td/><td>FSRT</td><td>0.08s</td><td>0.4s</td><td>1.6s</td></tr></table>"
	}
	}
	}
	}