Computing and classifying reduplication with 2-way finite-state transducers

This article describes a novel approach to the computational modeling of reduplication. Reduplication is often treated as a stumbling block within finite-state treatments of morphology because they cannot adequately capture the productivity of unbounded copying (total reduplication) and because they cannot describe bounded copying (partial reduplication) without a large increase in the number of states. We provide a comprehensive typology of reduplicative processes and show that an understudied type of finite-state machine, 2-way deterministic finite-state transducers (2-way D-FSTs), captures virtually all of them. Furthermore, the 2-way D-FSTs have few states, are in practice easy to design and debug, and are linguistically motivated in terms of the transducer’s origin semantics or segment alignment. Most of these processes, and their corresponding 2-way D-FSTs, are available in an online database of reduplication (RedTyp). We classify these 2- way D-FSTs according to the concatenation of known subclasses of regular relations and show that the majority fall into the Concatenated Output Strictly Local (C-OSL) class. Other cases require higher subclasses but are still definable by 2-way D-FSTs.


INTRODUCTION
Reduplication is a cross-linguistically common word-formation process involving copying. Given a word, reduplication can copy either a bounded (1a) or unbounded (1b) number of segments. The symbol ∼ marks the boundary between the two copies.
Although reduplication is well-studied, it is a computationally challenging process (Sproat 1992). In computational linguistics, most morphological and phonological processes can be analyzed with finitestate calculus in terms of rational languages and transductions (Kaplan and Kay 1994;Beesley and Karttunen 2003). However, reduplicative processes cannot be easily modeled with the same finite-state systems. For total reduplication, this is because those finite-state systems cannot express unbounded copying in the first place (Culy 1985). As for partial reduplication, those finite-state systems are often described as unwieldy because of the state explosion caused by partial reduplication (Roark and Sproat 2007, 54). Section 2 of this article explains why reduplication is computationally challenging while reviewing previous computational approaches to this linguistic phenomenon.
In this context, the primary contribution of this article is to show that a specific understudied type of finite-state technology can account for virtually all reduplicative processes. This type of transducer is known as a 2-way Finite-State Transducer or 2-way FST (Savitch 1982;Engelfriet and Hoogeboom 2001;Filiot and Reynier 2016). 2 In theoretical computer science, 2-way FSTs are known to be able to model unbounded copying (Engelfriet and Hoogeboom 2001). To our knowledge, we are the first to apply 2-way FSTs to computational linguistics. 3 The FSTs used in most of computational linguistics are more accurately called 1-way FSTs. They can only read the input once in one direction. 2-way FSTs are more expressive because the read head can move back and forth on the input tape. On the other hand, the write head can only move forward on the output tape. For this reason, they are less expressive than Turing machines. It is this back-andforth movement of the read head that allows 2-way FSTs to adequately model reduplication without the difficulties faced by 1-way FSTs. This article introduces deterministic 2-way finite-state transducers (2-way D-FSTs) in Section 3, along with their formal definition (Section 3.1), illustrative examples of reduplication (Section 3.2), and their computational properties (Section 3.3).
The fact that the 2-way FSTs used in this article are deterministic is significant. It is well known that deterministic 1-way FSTs are less expressive than non-deterministic 1-way FSTs (Elgot and Mezei 1965;Schützenberger 1975;Choffrut 1977;Mohri 1997;Heinz and Lai 2013). Similarly, 2-way D-FSTs are less expressive than non-deterministic 2-way FSTs (Culik and Karhumäki 1986). Consequently, the empirical result that reduplication can be modeled with deterministic 2-way FSTs is in line with work which shows that various phonological and morphological processes can be described with deterministic finite-state technology Gainor et al. 2012;Heinz and Lai 2013;Chandlee 2014;Luo 2017;Payne 2014Payne , 2017.
In the later part of this article, we provide a comprehensive cross-linguistic survey of reduplicative processes based on earlier typological studies (Moravcsik 1978;Rubino 2005;Inkelas and Downing 2015a), with reduplication defined as an input-to-output function (McCarthy and Prince 1995). This survey is documented in a database we constructed, which we call The RedTyp database. It contains entries for 138 reduplicative processes from 91 languages and a 2-way D-FST for each entry. Aspects of this survey are presented in Sections 3-4, and discussed in detail in Section 6.
In Section 4, we compare 2-way D-FSTs to 1-way FSTs in terms of empirical coverage (Section 4.1), practical utility (Section 4.2), and linguistic motivation (Section 4.3). We argue that 2-way D-FSTs are linguistically motivated in that they capture the correspondence relations underlying the base and the reduplicant in a linguistically natural way. These correspondence relations are couched in terms of origin semantics (Bojańczyk 2014). We use origin semantics as a diagnostic for the strong generative capacity of reduplicative functions. (We do not claim that origin semantics matches linguistic intuitions exactly in every case, but rather that it approximately does so in many instructive cases.) The final contribution of this article is an attempt to classify reduplicative processes according to subclasses of 2-way D-FSTs in Section 6. The first result we already mentioned: the full typology of reduplicative processes can be modeled with deterministic 2-way D-FSTs. These subclasses are defined in terms of concatenations of subclasses of 1-way FSTs. Our next result is that approximately three-quarters of the typology is expressible with the concatenation of Output Strictly Local (OSL) functions (Chandlee et al. 2015). The remainder of the typology is expressible with the concatenation of sequential functions, with some arguably requiring sweeping transducers or unrestricted 2-way D-FSTs.
We review these contributions and conclude in Section 7.

BACKGROUND ON COMPUTATION OF REDUPLICATION
Within computational linguistics, reduplication has been a challenging process to model (Culy 1985;Sproat 1992;Roark and Sproat 2007;Hulden 2009a;Chandlee 2014Chandlee , 2017. Finite-state technology, as currently practiced, cannot adequately and elegantly describe many cases of productive reduplication, especially unbounded total reduplication. There are three kinds of issues: empirical coverage, practical utility, and matching the intensional description of reduplication. We discuss these challenges in Section 2.1. In response to these problems, some have proposed finite-state approximations for reduplication (Section 2.2) or developing more expressive systems just for total reduplication (Section 2.3). The latter approach however implies that total reduplication is ontologically different from partial reduplication, and thus should be computed differently. In Section 2.4, we discuss this implication and show that the evidence for it is inconclusive. We summarize in Section 2.5.

Why reduplication is challenging
Reduplication is challenging because segmental copying entails multiple crossing dependencies between the two copies. When the number of copied segments (and thus the number of crossing dependencies) is bound to some maximum number n, the outcome is partial reduplication. When there is no bound, the outcome is total reduplication. Partial reduplication can be modeled with 1-way FSTs (Roark and Sproat 2007;. However, as we explain in more detail in Section 4.3, these machines are understood as memorizing all finitely-many possible forms of the partial reduplicant. Consequently, the transducers suffer from an explosion of states and become unwieldy. For example, in a language with a medium-sized phonemic inventory of 22 consonants and 5 vowels, partial reduplication with a CVCV template would require at least 22 + 22 × 5 + 22 × 5 × 22 = 2552 states to memorize the first C (22 states), the first V (22 × 5 states), and the second C (22 × 5 × 22 states). 1-way FSTs likewise arguably do not match the intensional description of reduplication as a copying process because the FSTs simply memorize all possible reduplicants in the language (Roark and Sproat 2007, 54). This is discussed in detail in Section 4.3.
On the other hand, total reduplication cannot be modeled at all with 1-way FSTs (Culy 1985). This inability is due to the fact that the output language of total reduplication is not a regular language. Rather, the copying process of total reduplication can create output languages that are identical to the non-context-free L ww = {ww|w ∈ Σ * } . Thus the copying function w → ww (sometimes called the squaring function) is beyond the expressivity of 1-way FSTs. In fact, virtually all attested morphological processes can be described with 1-way finite-state acceptors and transducers, except for total reduplication (Langendoen 1981;Gazdar and Pullum 1985;Roark and Sproat 2007). In response to this problem, computational morphologists have often resorted to using either finite-state approximations (Section 2.2) or non-finite-state tools (Section 2.3).

2.2
Finite-state approximations The literature on finite-state morphology contains many finite-state approximations to reduplication (Walther 2000;Beesley and Karttunen 2003;Cohen-Sygal and Wintner 2006;Hulden and Bischoff 2009). Roark and Sproat (2007, 57) and Cohen-Sygal and Wintner (2006, 52) provide reviews. In general, finite-state approximations are designed to lessen the burden for the developer in designing reduplication rules. They introduce new operations or tools over 1-way FSTs but they do not increase their expressivity. In other words, they are designed to improve on practical utility but they don't improve on empirical coverage or intensional description.
Here we briefly review the two main sets of approaches with details following. One set of approaches checks for identity between the two copies (Cohen-Sygal and Wintner 2006;Hulden and Bischoff 2009). Another set of approaches essentially 'postpones' reduplication to a run-time task (Walther 2000;Karttunen 2000, 2003). Both try to reduce state complexity either by making a trade-off with time complexity, by implementing reduplication with a unique 1-way transducer for each morpheme in the finite lexicon, or both. which in principle applies to infinitely many words to a process which applies to only finitely many. Such approximations thus fall short of capturing how total reduplication is used as a productive process in natural language.
As for partial reduplication, all of the above four approaches have the same expressivity and are able to capture the linguistic generalization that partial reduplication is independent of string length. However, although they are designed to avoid state explosion by one means or another, they can still be said to memorize the partial reduplicant as opposed to copying it (see Section 4.3). In this way they do not intensionally capture the linguistic generalization of copying.

2.3
Extending formal power Because of the difficulty in modeling reduplication with finite-state machinery, various augmentations and expansions of context-free grammars have been proposed to handle L ww and reduplication. An early augmentation is Reduplication Context-Free Grammars (Manaster-Ramer 1986;Savitch 1989) designed to handle context-free languages and reduplication by using queues instead of stacks. A more recent augmentation is Multiple-Context Free Grammars (MCFGs) which can model L ww (Seki et al. 1991(Seki et al. , 1993. MCFGs have been used to model reduplication (Albro 2000(Albro , 2005. As an extension of MCFGs, Parallel MCFGs have been used to model reduplication and syntactic copying (Kobele 2006;Clark andYoshinaka 2012, 2014;Clark 2017). 5 Crysmann (2017) explores the use of HPSG to model total reduplication. These technologies have had considerably less attention within mainstream computational morphology than finite-state approximations. One shortcoming of these approaches is that they model formal languages, not transformations. They accept well-formed reduplicated words ww, but they do not generate a reduplicated word ww given some input w. Thus, they do not model the squaring function w → ww.
5 Kobele (2006) shows that syntactic copying can generate languages of the form a 2 n , i.e., exponential copying. This isn't attested in morphological copying. Note the string a 2 n is generated as the yield language of a tree transduction over a derivation tree.

Computational distinctions between total and partial reduplication
The previous sections showed that more expressive mechanisms are needed to model reduplication. Conceptually, the use of more powerful computational formalisms implies that reduplication is 'different' from the rest of morpho-phonology which can be modeled using 1-way FSTs (Roark and Sproat 2007, 60). This is especially the case for total reduplication which cannot be exactly modeled with 1-way FSTs, whereas partial reduplication can. This difference has caused debates over whether both types of reduplication should be computed with the same formalism or not. However, this debate is inconclusive.
On one hand, Chandlee (2017) suggests that the inadequacy of 1-way FSTs for total reduplication is evidence for total reduplication being ontologically different from partial reduplication. There is some empirical support for this argument. Prosodically, total reduplication resembles more 'syntactic' processes like compounding more often than partial reduplication (Downing 2006). The two copies in total reduplication can be stressed separately or have separate tonal contours (Downing 2003).
On the other hand, partial and total reduplication are closely related processes. Typologically, if a language has partial reduplication, then it almost always has total reduplication too (Rubino 2013). Diachronically, both types of reduplication are typically related to each other, but not always (Hurch and Mattes 2009). And in linguistic theory, both are modeled with the same tools (Steriade 1988;Raimy 2000;Inkelas and Zoll 2005;McCarthy et al. 2012).
Psycholinguistic work could shed more light on the issue of total reduplication vis a vis partial reduplication. Sadly, there is little to no work on the psycholinguistic processing of reduplication. To our knowledge, existing work focuses on partial reduplication, not total reduplication (Ohala et al. 1986;Waksler 1999).
Learnability is another factor which could tease apart these processes. It is an open question whether both partial and total reduplication can be learned in the same way with the same mechanism. In terms of stringsets, the formal language of totally reduplicated words ww can be learned with distributional methods for MCFGs (Clark and Yoshinaka 2012. There is also a substantial body of work in cognitive science and connectionism on how to learn reduplicated words (Marcus et al. 1999;Berent et al. 2014Berent et al. , 2016Berent et al. , 2017Andan et al. 2018;Alhama 2017;Alhama and Zuidema 2019). Here, the task is learning words which have repeated substrings (ABB or ABA) where A and B are syllables.
In contrast, there is little to no work on learning reduplication as a function (w → ww), whether in machine learning or grammatical inference. To our knowledge, the only algorithm designed specifically for learning reduplication is Nevins (2004) in the principlesand-parameters tradition. There is some recent work on using neural networks to learn copying (Gu et al. 2016;Prickett et al. 2018;Wilson 2019;Nelson et al. 2020). We speculate that one reason for the dearth of learning results is due to the challenges outlined above for finding natural computational models for reduplication.

Summary and consequences
All in all, current finite-state treatments of reduplication have issues regarding their empirical coverage (total reduplication's productivity), practical utility (state space explosion), and intensional descriptions (copying vs. remembering). The present study uses a computational formalism which does not suffer from these three problems: two-way finite-state transducers (2-way FSTs).  1959;. This ability makes them more expressive than 1-way FSTs (Savitch 1982;Engelfriet and Hoogeboom 2001). [ 188 ] It is useful to imagine a 2-way FST as a machine operating on an input tape and writing to an output tape. The symbols on the input tape are drawn from an alphabet Σ and the symbols written to the output tape are drawn from an alphabet Γ . For an input string w = σ 1 . . . σ n , the initial configuration is that the FST is in some internal state q 0 , its read head on σ 1 , and its write head at the beginning of an empty output tape. After the FST reads the symbol under the read head, three things occur: • The internal state of the FST may change.
• The FST writes some string, possibly empty, to the output tape.
• The read head moves in one of three ways: moves to the left (−1), moves to the right (+1), or stays (0).
This process repeats until the read head "falls off" one of the edges of the input tape. If for some input string w, the FST falls off the right edge of the input tape when the FST is in an accepting state after writing u on the output tape, we say the FST transduces, transforms, or maps, w to u. If for some input string w, the FST falls off the left edge, falls off the right edge while in a non-accepting state, or never falls off either edge, then the FST is undefined at w. The write head cannot move back along the output tape. It can only advance as strings are written. We formalize the definition and behavior of 2-way FSTs in Section 3.1. They are illustrated for reduplication in Section 3.2. We then describe their generative capacity and computational complexity (Section 3.3).

Preliminaries and formal definition
Given a finite alphabet Σ, the set of all possible strings of finite length built from Σ is Σ * . The empty string is represented by λ. The length of a string w is |w|, so |λ| = 0. For the given strings w 1 , w 2 , their concatenation is w 1 w 2 . Below is a formalization of deterministic 2-way FSTs based on Filiot and Reynier (2016) and Shallit (2008). We adopt the convention that inputs to a 2-way D-FST are flanked with the start (⋊) and end (⋉) boundaries. This larger alphabet is denoted by Σ ⋉ . [ 189 ] (2) Definition: A 2-way D-FST is a six-tuple (Q, Σ ⋉ , Γ , q 0 , F, δ) where: • Q is a finite set of states, A configuration of a 2-way D-FST T is an element of Σ * ⋉ QΣ * ⋉ × Γ * . The meaning of the configuration (wqx, u) is that the input to T is wx and the machine is currently in state q with the read head on the first symbol of x (or has fallen off the right edge of the input tape if x = λ) and that u is currently written on the output tape.
If the current configuration is (wqax, u) and δ(q, a) = (r, v, 0) then the next configuration is (wr ax, uv), in which case we write (wqax, u) → (wr a x, uv). If the current configuration is (wqa x, u) and δ(q, a) = (r, v, +1) then the next configuration is (war x, uv). In this case, we write (wqax, u) → (war x, uv). If the current configuration is (waqx, u) and δ(q, a) = (r, v, −1) then the next configuration is (wr ax, uv). We write (waqx, u) → (wr ax, uv). Observe that since δ is a function, there is at most one next configuration.
The transitive closure of → is denoted with → + . Thus, if c → + c then there exists a finite sequence of configurations c 1 , c 2 . . . c n with n > 1 such that c = c 1 → c 2 → . . . → c n = c .
Next we define the function f T that a 2-way D-FST T computes. For each string w ∈ Σ * , f T (w) = u ∈ Γ * provided there exists q f ∈ F such that (q 0 ⋊ w⋉, λ) → + (⋊w ⋉ q f , u). If f T (w) = u then u is unique because the sequence of configurations is determined deterministically.
If the configurations of a 2-way D-FST T halt the computation of T on some input w, then we say T is undefined on w. If the configuration is (qax, u) and δ(q, a) = (r, −1, v) then the derivation crashes and the transduction f T (ax) is undefined. Likewise, if the configuration is (wq, u) and q ∈ F then the transducer crashes and the transduction f T is undefined on input w. Another way that f T may be undefined for some input is if the input causes the transducer to go into an infinite [ 190 ] loop. 6 This occurs for input wx ∈ Σ * ⋉ whenever there exist q ∈ Q and u, v ∈ Γ * such that (q 0 wx, λ) → + (wqx, u) → + (wqx, uv).

Illustration of two-way transducers for reduplication
Having established what 2-way D-FSTs are, this section illustrates how they can be used to model reduplication. We provide two examples: total reduplication and partial initial-CVC reduplication. Both examples use deterministic 2-way FSTs.
Some useful terms are 'passes' and 'rewinds'. A pass (rewind) is when a 2-way D-FST moves left-to-right (right-to-left) from some position to another over the input.
Total reduplication is cross-linguistically the most common reduplicative process (Rubino 2005), and it is used in an estimated 85% of the world's languages (Rubino 2013). We illustrate it with data from Indonesian where total reduplication marks plurality (Cohn 1989). Figure 1 shows a 2-way D-FST that captures total reduplication. The boundary symbol ∼ is a symbol in the output alphabet Γ , and is not necessary. We include it only for illustration. The 2-way D-FST in Figure 1 operates as follows: 1. First pass: It reads the input tape from left to right and outputs the first copy. 2. Rewind: When it reaches the end boundary ⋉, it 'rewinds' or goes back to the start of the input tape by moving left until the start boundary ⋊ is reached. 3. Second pass: It reads the input tape once more from left to right and outputs the second copy. The transition arcs are interpreted as follows. The symbol Σ is a variable representation of any alphabet symbol except for {⋊, ⋉}. The arrow from q 1 to itself (Σ, Σ, +1) means this 2-way D-FST reads a symbol from Σ, writes that same symbol, and advances the read head one step to the right on the input tape. Table 1 shows an example derivation for buku → buku∼buku using the 2-way D-FST in Figure 1. The derivation shows the step-by-step configurations for the computation. The tuples in Table 1 consist of Outputting the first copy Going back to the start of the tape 7. ( ⋊bukq 2 u⋉, buku, q 1 Outputting the second copy 12. ( ⋊q 3 buku⋉, buku∼, q 2 [ 192 ] three parts. The first two represent the configuration and the third part shows the transition exercised to reach this configuration from the previous one. The underlined input symbol is what the FST will read next. In the first tuple, there is no transition used (N/A). Transitions in the other tuples are given in the form shown below.
input state input symbol:output string Partial reduplication processes are also very common. A common example is initial-CVC reduplication as in Agta (Moravcsik 1978, 311).
The 2-way D-FST in Figure 2 expresses partial initial-CVC reduplication. An example derivation of takki → tak∼takki using our 2-way D-FST is provided in Table 2. For illustrative purposes, we assume that the function is undefined for V-initial inputs.

Generative capacity and computational complexity
With respect to acceptors, 1-way and 2-way finite-state acceptors are equivalent in expressive power. Both define the regular languages Shallit 2008). However, with respect to transducers, 1-way FSTs are strictly less expressive than 2-way D-FSTs (Savitch 1982;Aho et al. 1969;Filiot and Reynier 2016). For a 1-way [ 193 ] Going back to the start of the tape 13. ( FST, both the input language and the output language must be regular languages. Therefore a 1-way FST cannot have its output language be the non-regular copy language L ww = {ww|w ∈ Σ * }. In contrast, the output language of a 2-way D-FST can be a non-regular language such as L ww . Figure 3 shows the hierarchy of FSTs, adapted from Filiot and Reynier (2016, p.8). Different FSTs have different generative capacity, based on whether the FST is deterministic (D-FST), non-deterministic (N-FST), 1-way, 2-way, and/or functional (f-FST). 1-way D-FST (=Sequential Functions) [ 194 ] 2-way D-FSTs are equivalent in expressivity to string transductions that are defined in Monadic Second Order logic (Engelfriet and Hoogeboom 2001) and to streaming string transducers (Alur 2010). 7 2-way D-FSTs are less powerful than Turing machines because they cannot move back and forth on the output tape. They are closed under composition (Chytil and Jákl 1977) and some important classes are closed under inverse (Courcelle and Engelfriet 2012, 526).
Because of the difference in expressivity between 1-way and 2-way D-FSTs, it makes sense to give different names to the classes of functions that they compute. We follow Filiot and Reynier (2016) who identify the class of functions describable with 1-way deterministic FSTs as 'sequential functions', with 1-way functional nondeterministic FSTs as 'rational functions', and with 2-way deterministic FSTs as 'regular functions'. The non-deterministic counterparts for 1-way and 2-way D-FSTs are respectively the 'rational relations' and 'regular relations'.
1-way D-FSTs run in time linear to the length of the input string. As for 2-way D-FSTs, one useful metric for measuring their complexity is in terms of the number of times the 2-way D-FST passes through the input (Baschenis et al. 2016). In the case of the reduplication examples in Section 3.2, the 2-way D-FSTs used only two passes through the input, one for each copy. Thus, the run time for those 2-way D-FSTs is at most 2n·m where n is the number of passes and m is the length of the input. Since n here is fixed at 2, the run time is still linear in the size of the input string. To our knowledge existing applications of regular functions have been efficient (Alur and Černý 2011;Alur et al. 2014).

CONTRASTING 2-WAY D-FSTS WITH 1-WAY FSTS
Having illustrated how 2-way D-FSTs can model reduplication, here we contrast 2-way FSTs with 1-way FSTs on three criteria: empirical coverage, practical utility, and intensional description.
7 A streaming-string transducer (SST) is a 1-way FST that uses finitely many registers of unbounded size. These registers allow the SST to keep track of previous information on the input tape, thus simulating 2-way D-FSTs.

Empirical coverage of the typology and productivity
In terms of empirical coverage, 2-way D-FSTs can effectively model virtually the entire typology of reduplication as described by Moravcsik (1978), Hurch (2005), Inkelas and Zoll (2005), Rubino (2005), and Samuels (2010). We review part of this typology in Section 6. This stands in stark contrast to 1-way FSTs discussed in Section 2. We say virtually because there are two cases in the literature which require further discussion. These are discussed in Section 6.6.2.

Practical utility and the RedTyp database
To showcase the empirical coverage of 2-way D-FSTs and their practical utility, we have constructed the RedTyp database (Dolatian and Heinz 2019a). 8 It contains entries for 138 reduplicative processes from 91 languages. These were gleaned from various surveys (Rubino 2005; Inkelas and Downing 2015a). 50 of these processes were from Moravcsik (1978), an early survey which is representative of the crosslinguistically most common reduplicative patterns. RedTyp contains 57 distinct 2-way D-FSTs that model the 138 processes. Each 2-way D-FST was designed manually, implemented in Python, and checked for correctness. On average, these 2-way D-FSTs had 8.8 states. This shows that 2-way D-FSTs are concise and convenient computational descriptions and models for reduplicative morphology. This is in contrast to 1-way FSTs which suffer from an explosion of states when modeling partial reduplication. 9 To our knowledge, the only other database on reduplication is the Graz Database on Reduplication (Hurch 2005 ff.). However, Red-Typ differs from the Graz Database because the latter does not include computational representations or implementations of its entries.
8 It can be found on the first author's GitHub page https://github.com/ jhdeov/RedTyp. 9 The largest 2-way D-FST in RedTyp is for verbal reduplication in Kinande (Downing 2000) with 29 states. This pattern depends on the size of the root and the number and type of suffixes and prefixes around it. In contrast, we estimate a deterministic 1-way D-FST would require over 1,000 states for this pattern of partial reduplication. [ 196 ] A comparison between the two databases is provided in Dolatian and Heinz (2019a).
RedTyp offers a useful corpus of reduplicative patterns for research. For example as described in Section 6, we have used this database to identify subclasses of 2-way D-FSTs for classifying the typology of reduplication. This corpus could be used to test for other universal computational properties of reduplication. Since it contains 2-way D-FSTs, it can also be used to generate reduplicated forms. Such data sets can be used to test morphological learning algorithms.
One shortcoming is that RedTyp under-represents cases of opacity in reduplication because our main source, Moravcsik (1978), did not list opaque cases. As discussed further in Sections 6.4.3-6.5, opacity can be said to occur when phonological processes exceptionally apply either across both copies or across neither copy because of a drive to maintain identity between the two copies (McCarthy and Prince 1995). Only 5% of RedTyp displays opacity. Furthermore, RedTyp focuses on morphological copying, not syntactic copying (cf. Kobele 2006).

Linguistic motivation with origin semantics
Importantly, using 2-way D-FSTs for reduplication is linguistically motivated and matches the intensional descriptions behind the linguistic generalizations on reduplication.
2-way D-FSTs do not approximate reduplication like 1-way FSTs do. 2-way D-FSTs do not copy by remembering strings of segments (see Section 2). Instead they actively and literally copy.
This contrast between copying and remembering can be formalized with the notion of the origin semantics of a transduction (Bojańczyk 2014). 10 Given a string-to-string function, the origin semantics of a function is the origin information of each symbol o n in the output string. This is the position i m of the read head on the input tape when the transducer had outputted o n . To illustrate, consider a partial string-to-string function f ab which maps ab to itself: Figure 4: Pair of 1-way FSTs for the function f ab and the origin information created by them for the mapping ab → ab As shown in the top row of Figure 4, this function can be modeled with at least two different 1-way FSTs which differ in when they output the output symbols a, b. In the bottom row of Figure 4, we visualize the origin information created by the two FSTs for the mapping (ab, ab) as graphs called origin graphs (Bojańczyk et al. 2017). The FSTs model the same function and are equivalent in their general semantics of what they output; however, they are not equivalent in their origin semantics because they use different origin information for their outputs.
This notion of origin semantics can be used to contrast how 1-way FSTs and 2-way FSTs model reduplication. Consider the toy example of initial-CV reduplication with a small alphabet Σ = {p,a,t}. This function can be modeled by either a 1-way or 2-way FST as in Figure 5. The two transducers in Figures 5 are equivalent in their general semantics because they can output the same string. For example, given the input pat, both FSTs will output pa∼pat. However, the two FSTs differ in their origin semantics for the mapping pat → pa∼pat. Setting aside boundary symbols ⋊, ⋉, ∼, the 1-way FST associates the second pa string of the output with the vowel a of the input as in the bottom middle column of Figure 5. This is because the second pa was outputted when the 1-way FST was reading the a in the input. In contrast, the 2-way FST associates each segment in the output with an identical segment in the input as in the bottom right column of Figure 5.
The origin information created by the 2-way FST matches theoretical treatments of how the reduplicant's segments are individually associated with identical segments in the input (Marantz 1982;Inke-[ 198 ] 1-way FST 2-way FST In contrast, the origin information created by the 1-way FST does not match linguistic intuitions of reduplication because non-identical segments are associated. This difference in the origin semantics of the 1-way FST and 2-way FST formalizes their behavior: the 1-way FST simply remembers what strings of segments to output twice (Roark and Sproat 2007, 54), while the 2-way FST actively copies.

LINGUISTIC MOTIVATIONS FOR SUBCLASSES OF TRANSDUCERS
Having shown the utility of 2-way D-FSTs for reduplication, the next two sections show that reduplication does not require the full power 11 In Base-Reduplicant correspondence theory or BRCT (McCarthy and Prince 1995), what matters for reduplication is not the relationship or correspondence between the input and output segments, but between the two copies in the output. Origin semantics might be able to formalize the intuition behind BRCT with finite-state technology, e.g. output symbols with the same origin are in correspondence. The only computational implementation of BRCT to our knowledge (Albro 2000(Albro , 2005 uses MCFGs to do so. Note however that the empirical validity of BRCT is questionable (Inkelas and Zoll 2005;McCarthy et al. 2012). [ 199 ] of 2-way D-FSTs but falls within certain subclasses. This means that reduplication has a demarcable generative capacity or complexity. In this section, we discuss the subclasses of 1-way FSTs that have been proposed to model segmental phonology (Section 5.1), specifically the Output-Strictly Local (OSL) functions and Sequential (Seq) functions. In Section 5.2, we discuss subclasses of 2-way FSTs and design new subclasses based on the concatenation of OSL and Seq functions. We explain the intuition behind using concatenation-based subclasses for reduplication (Section 5.3). The next Section 6 goes over the typology of reduplication and shows how it fits into these subclasses.

Computational typology of phonology and 1-way transducers
It is known that 1-way finite-state machines can model all attested phonological processes (Johnson 1972;Kaplan and Kay 1994;Mohri 1997). However, phonological processes do not require the full power of 1-way finite-state machines (Heinz 2007;Chandlee 2014  ). Some of these subclasses have been argued to characterize different types of phonological well-formedness conditions and transformations (Heinz 2018;. We give a brief and informal overview. A common intuition in linguistic theory is that phonological processes are local or subject to adjacency constraints (Odden 1994). For example, a common phonological process is post-nasal voicing (5a) whereby voiceless stops are voiced after nasals. This process is local in the sense that the trigger for voicing (the nasal) is within a finite bound from the target of voicing (the stop). The symbols N, T, D represent nasals, voiceless stops, and voiced stops. Another local process is nasal spread whereby a vowel becomes nasalized after a nasal or nasalized vowel (5b). Nasal spread is iterative in that when a nasal triggers nasalization on a subsequent vowel, the newly nasalized vowel can then nasalize its subsequent vowel (5b-iii). The symbols V,Ṽ represent vowels and nasalized vowels.
Both processes are intuitively local. This intuition corresponds to Strict Locality in formal language theory (McNaughton and Papert 1971;Vaysse 1986;Rogers and Pullum 2011;Chandlee 2014). Formal definitions can be found in Chandlee et al. ( , 2015. Informally, given an input string w, a function is Input-Strictly Local for a natural number k (k-ISL) if generating the output correspondent of some input symbol w i relies on information about the current input symbol w i and the k − 1 most recently seen input symbols. Post-nasal voicing is a 2-ISL function and it is computed by the 1-way FST in Figure 6. The symbol ? marks any other segment which isn't in an existing transition arc (Beesley and Karttunen 2003). The state labels are interpreted as keeping track of the last seen input symbol. The state labeled as N is where the post-nasal consonant is generated as voiced. The state label is interpreted as saying that a nasal was recently seen.
Output-Strictly Local functions for a number k (k-OSL) are analogously understood. A function is k-OSL if generating the output correspondent of w i relies on information about the current input symbol w i and the k − 1 most recently seen output symbols. An OSL function is L-OSL (R-OSL) if we read the input from the left (right), and write the output from the left (right). Nasal spread is a 2-L-OSL function and is computed by the 1-way FST in Figure 6. The state labels are interpreted as keeping track of the last recently generated output symbol. The state labeled as N,Ṽ is where a nasalized vowel is generated; the state label is interpreted as saying that the most recently outputted symbol was a nasal or nasalized vowel.  An example of an L-OSL function that will prove useful to model reduplication is truncation, such as nickname formation in English. This truncation process will output the first (C)VC of the input but delete everything after. 12 (6) English truncation English nickname formation is a 3-L-OSL function because it requires a window of size three in the output tape. The window keeps 12 We have simplified the analysis by not considering cases of complex onsets in the input, e.g. stivɪn → stiv ('Steven' → 'Steve'). [ 202 ] track of the last 2 symbols on the output tape and the current input symbol. The 3-OSL 1-way FST function in Figure 8 outputs up until the first VC of the input; it then stops outputting anything after that. 13 : OSL 1-way FST for English nickname formation A significant proportion of segmental phonology can be modeled with ISL and OSL functions (Chandlee 2014;. Long-distance processes in phonology are however neither ISL or nor OSL. For example, Kikongo nasal harmony (7) requires the higher subclass of Sequential functions (Gainor et al. 2012). In Kikongo, alveolar stops like d or l surface as n if a nasal precedes them anywhere in the input. There can be any number of vowels and consonants intervening between the triggering nasal and the target alveolar (7c). This long-distance information means that the 1-way FST must keep track of whether a nasal consonant was seen anywhere in the input stem before it will output the alveolar.

(7)
Kikongo nasal harmony The above pattern cannot be modeled by an ISL or OSL function but requires a Sequential 1-way FST as in Figure 9. A Seq 1-way FST is a deterministic 1-way FST that will read the input in only one direction (here left-to-right) and can use any information that it had found in the input string when processing the next input symbol.
To summarize, different types of phonological processes are computed by different subclasses of rational functions and with different subclasses of 1-way FSTs. The relatively low complexity of this subclasses has opened doors to understanding the cognitive limitations and learnability of phonological processes (Heinz 2018). In the next

Subclasses of 2-way finite-state transducers
Unlike for 1-way FSTs, there is much less work on subclasses for 2-way FSTs. Some intuitive subclasses have been proposed in the literature. The typology of reduplication inspired us to devise additional subclasses. All of these subclasses, shown in Figure 10, restrict: At the top of the hierarchy are 2-way D-FSTs which correspond to regular functions. In regards to the first restriction, a 2-way FST is a sweeping transducer if the read head can change direction only at the ends of the input (Baschenis et al. 2015(Baschenis et al. , 2016(Baschenis et al. , 2018. A sweeping transducer is a generalization of similarly defined sweeping automata (sweeping 2-way FSAs) (Sipser 1980). For example, the 2-way FST for total reduplication in Figure 1 is a sweeping transducer. The only time the FST moves right-to-left is going from the end boundary ⋉ to the start boundary ⋊. In contrast, the 2-way FST for initial-CVC partial reduplication in Figure 2 is not a sweeping transducer. It rewinds from the third input segment C to the beginning ⋊. However, the partial reduplication function computed by this 2-way FST can be computed by a sweeping transducer, which we show in the next section. 2-way D-FSTs are more expressive than deterministic sweeping 2-way D-FSTs. Consider the function u 1 #u 2 # . . . #u n → u n ...u 2 u 1 where the input is a sequence of strings u i separated by the special symbol #. The output is formed by reversing these strings and deleting the #'s. This function can be computed by a deterministic 2-way D-FST but not by a sweeping transducer. See Baschenis et al. (2016) for discussion.
In regards to the second restriction, a sweeping transducer is a rotating transducer if it does not output anything while it's moving right-to-left (Baschenis et al. 2017). The 2-way FST for total reduplication is a rotating transducer because it outputted nothing while moving right-to-left. Sweeping transducers are more expressive than rotating transducers. A sweeping transducer can compute the mirror function w → ww r , but a rotating transducer cannot.
As for the third restriction, we develop a set of concatenatedbased subclasses of functions.

(8)
Subclasses of Regular Functions a. C-Seq function: A Concatenated-Sequential function f is the concatenation of n Sequential functions s i , e.g. f (x) = if the component Seq functions read the input left-to-right (right-toleft). 14 14 In terms of function combinatorics for regular string transformations (Alur et al. 2014;Dave et al. 2018), the class of C-Seq functions involves the use of a 'sum combinator' ⊗ that concatenates the output of two or more Seq functions: where s i is a Seq function. This is similar to the use of product automata. See Alur et al. (2014) for details. [ 205 ] b. C-OSL function: A Concatenated-OSL function f is the concatenation of n Output-Strictly Local functions o i , e.g.
Rotating transducers are more expressive than C-Seq transducers, which are more expressive than C-OSL transducers. Examples witnessing these separations are drawn from the typology of reduplication in Section 6. C-Seq functions are more expressive than sequential functions (= 1-way D-FSTs) which are more expressive than OSL functions. A set of definitions is provided below for easier reference. We have found that virtually the entire typology of reduplication can be modeled with deterministic rotating 2-way FSTs. Further, the bulk of the typology can be modeled with C-OSL functions. A few minor cases require C-Seq functions; these mostly involve infixal or internal reduplication. A smaller set of cases require the full power of rotating transducers; though these cases are not clear-cut. Before going through the typology in detail in Section 6, we illustrate the insight behind C-OSL functions and how they compute reduplicative processes.

5.3
Illustrating C-OSL Intuitively, a C-OSL function is a function that takes as input the string x, gives x to n many separate 1-way FSTs which are OSL, and concatenates their output. To illustrate the insight behind C-OSL functions, [ 206 ] takki tak ∼ takki Tr(x) ID(x) Figure 11: Initial-CVC reduplication as a concatenation of functions consider initial-CVC partial reduplication from Agta again (Moravcsik 1978, 311) from (1a) repeated in (10a).
As an input-to-output function, reduplication may be viewed as submitting the same input to two separate functions in parallel and concatenating their output as in Figure 11. The first function, here labeled Tr(x), truncates the input to the first CVC while the second function, ID(x), is the identity function. The outputs of these two functions, tak and takki, are concatenated to form the reduplicated output: tak∼takki. In (10b), we explicitly show how initial-CVC reduplication can be seen as truncating the first copy: takki → takki∼takki where truncated material is shown in strikethrough.
The truncation function Tr(x) is a 3-L-OSL function because it outputs a truncation of the input to just the first CVC. This is similar to English nickname formation from Section 5.1. The identity function ID(x) is both 1-L-OSL and 1-R-OSL. Thus both Tr(x) and ID(x) are L-OSL and hence their concatenation is C-OSL. Figure 12 illustrates a 2-way D-FST for initial-CVC reduplication which is formulated as a concatenation of these two OSL functions. Contrast this model of initial-CVC reduplication (shown in Figure 12) with the nonrotating 2-way D-FST shown in Figure 2. (It is the the additional state CV 1 and its transition arcs in Figure 12 which make this D-FST rotating.) To summarize this section, understanding reduplicative processes as C-OSL and C-Seq functions is intuitive. This analysis echoes Steriade (1988)'s treatment of partial reduplication as total reduplication followed by truncation and Inkelas and Zoll (2005)'s treatment of total reduplication as morphological doubling.

COMPUTATIONAL TYPOLOGY OF REDUPLICATION
This section provides a detailed, comprehensive review of the RedTyp typology and classifies RedTyp's reduplicative processes according to the computational classification introduced in the last section. The main finding is that most processes are C-OSL (Section 6.2) and most of the ones that are not are C-Seq (Section 6.3). There are few (and questionable) cases where reduplication needs the full power of 2-way D-FSTs (Section 6.4). We give an overview in Section 6.5. Note that all partial reduplicative processes can be computed by 1-way FSTs. However, in order to get the linguistically-motivated origin semantics right (Section 4.3), we need the additional power of 2-way FSTs. Thus in this section, when we discuss how partial reduplicative cases fit into the subclasses of 2-way FSTs, we mean in terms of them generating the right origin semantics.

6.1
Preliminaries to the typology Although reduplication is cross-linguistically ubiquitous, there is a wide cross-linguistic variation in a) what substring or subsequence gets repeated, b) where the copied substring or subsequence is placed [ 208 ] in the output, and c) whether and how phonological processes interact with copying. This section provides a brief but representative typology of reduplication compiled from various surveys (Moravcsik 1978; Rubino 2005; Inkelas and Downing 2015a). We emphasize that our reported typology is descriptive and not theoretical. Various theoretical frameworks have been developed to account for the range of variation on reduplication (Marantz 1982;McCarthy and Prince 1995;Spaelti 1997 We define the following descriptive terms which will be useful in categorizing different reduplicative processes: (11) Terminology for categorizing the typology: • reduplicant: the substring in the output which was created via copying • base: the substring in the output which was not created via copying • target: the substring in the input which will be copied or duplicated • anchor point: the position in the input where the target starts or ends • source: the morphological or phonological constituent in the input which contains the target The output-based terms base and reduplicant are common in the literature on reduplication (McCarthy and Prince 1995) though their definition is problematic (Shaw 2005;Haugen 2009). Anchor points have been proposed for reduplication (Fitzpatrick 2006;Raimy 2009) and other non-concatenative processes (Yu 2007; Samuels 2010). We introduce the input-based terms source and target in order to better fully describe reduplication as an input-to-output function. This section goes through the typology of reduplication, organized in terms of how they vary in the source, target, and/or reduplicant. These variations align with what type of 2-way FST is needed to compute them. [ 209 ] 6.2 Most reduplication is C-OSL Most reduplicative processes are C-OSL. We go through common and some uncommon reduplicative processes and show they are C-OSL. For a function to be C-OSL, the two copies must be independent of each other, and the two passes over the input must likewise be independent of each other. Informally, some criteria for a C-OSL function are that each of the component functions: 1. reference only a finite and bounded number of the most recently generated output symbols, meaning that each of the functions, 2. do not depend on any long-distance information in the input, 3. do not use any finite lookahead or finite lookback on the input, 4. do not rely on deleted material, and 5. do not rely on any information from the other function.

Total and word-initial partial reduplication
Total reduplication and word-initial partial reduplication are C-L-OSL, which means they are the concatenation of two L-OSL functions. Consider total reduplication first.

Initial-CVC reduplication
Agta (Moravcsik 1978, 311) takki → tak∼takki 'leg' → 'legs' For total reduplication, the two OSL functions are identity ID(x). (Total reduplication is also C-R-OSL.) For partial reduplication, there is limited variety in the shape of the copied material, the reduplicant. Some languages have a partial reduplicative process that copies the first C or consonant of the word (13a), first CV or consonant-vowel sequence (CV) of the word (13b), first CVC sequence (13c), or first CV(C)CV sequence (13d). In general, the copied material has to fit into some template of a particular size. [ 210 ] (13) Common prefixal partial reduplicative patterns a.

Initial-C reduplication
Shilh ( As for the partial reduplication functions in (13), they are all C-L-OSL just like initial-CVC reduplication from Section 5.3. They involve the concatenation of a truncation Tr(x) and identity function ID(x). The truncation function varies in terms of how much word-initial material is faithfully outputted. Table 3 illustrates these examples where the truncated material is shown in strike-through. The outputs of the two component OSL function are separated by ∼ for illustration.

Variation in the number and placement of copies
The typology is larger than the above examples. Some languages create three copies of the input (triplication) instead of just two (14a). [ 211 ] Some reduplicative processes are suffixal; they specify that the location of the target be a word-final substring (14b) instead of wordinitial substring (13d). Some reduplicative process are wrong-sided by making the target and the reduplicant not adjacent in the output, i.e., copying the final CVC and placing it at the beginning of the output (14c vs. 13c). There are likewise cases where both the base and the reduplicant are shortened or truncated in the output, e.g., truncating both copies to CV (14d).

d. Abbreviated reduplication (Kager-Hamilton Problem)
Guarijio (Caballero 2006) 15 toni → to∼to 'to boil' → 'to start boiling' muhiba → mu∼mu 'to throw' → 'to start throwing' All these processes are still C-OSL, however. They differ in the number and order of concatenated functions, the direction in which the input is read, and whether all or none of the functions are identity. Their computation is visualized in Table 4. Triplication is C-L-OSL and C-R-OSL; it involves concatenating three identity functions. Suffixal reduplication like final-CVCV reduplication is C-R-OSL because 15 Such reduplication is often argued to be unattested and is called the Kager-Hamilton Problem (Idsardi and Raimy 2008). See Caballero (2006) for discussion on what prosodic and morphological factors condition this rare type of reduplication.
it is the concatenation of an identity function and an R-OSL truncation function. The truncation function reads the input right-to-left and deletes everything to the left of the final CVCV. Wrong-sided initial-CVC reduplication is C-L-OSL. It differs from initial-CVC reduplication by ordering identity before truncation. Abbreviated reduplication is C-L-OSL. Unlike initial-CV copying, it is composed of two L-OSL truncation functions instead of just one.

Copying a morphological subconstituent
In the above examples, the source was the entire input. But unlike concatenative morphology, reduplication is often sensitive to wordinternal morphological constituents, contra Bracket Erasure (Kiparsky 1982). In these cases, the semantic function of reduplication builds on the meaning of the entire input while the location of the reduplicant is word-internal (cf. Aronoff 1988). For example, some languages have reduplication target a morphological subconstituent within the input as the source, such as a root/stem (15a, 15b) or affix (15c), and whether for total reduplication (15a, 15c) or partial reduplication (15b). The source and reduplicant are usually adjacent; though there are some cases where the two copies are non-adjacent in the output, e.g., Madurese copies the root-final CVC and places it at the beginning of the output (15d).

Root-final CVC reduplication and word-initial placement
Madurese (Brown 2017, 964) pa-jalan-an → lan∼pa-jalan-an 'pedestrian' → 'pedestrians' More cases of reduplication targeting a morphological subconstituent are well-attested (Shaw 2005;Inkelas and Zoll 2005;Haugen 2009;Hyman 2009;Inkelas 2014). The above cases are C-OSL if the relevant morphological boundaries are present in the input. Their computation is visualized in Table 5. Each process uses two functions L(x),R(x) which generate the two copies, reference the morphological boundaries, and they crucially output these boundaries.
For total copying in KiHehe and Hungarian, the function is C-L-OSL and C-R-OSL. For total stem copying in KiHehe, the first function L(x) outputs everything up until the root right-boundary '} r '. The sec- [ 214 ] ond function R(x) outputs nothing until it sees the root left-boundary '{ r '; it outputs this and everything after it. Both functions are both L-OSL and R-OSL, thus KiHehe is C-L-OSL and C-R-OSL. Prefix copying in Hungarian is similarly defined but for the prefix boundaries '{ p ' and '} p '. Partial stem copying in Bikol is only C-L-OSL. The function L(x) outputs everything up until it outputs the string '{ r C V '; it deletes everything after that. The function R(x) outputs nothing up until it sees the root left-boundary '{ r '; it outputs this and everything after it. Non-local copying in Madurese is C-R-OSL. The function L(x) reads the input right-to-left; it outputs nothing until it sees the root rightboundary '} r '; it outputs this and the first CVC that it sees. After that, it deletes everything. The function R(x) is the identity function.
Even though some have argued against the use of morpheme boundaries in morpho-phonological representations (Anderson 1992;Stump 2001), morphological boundaries must be part of the input for a finite-state systems like ours (e.g. Karttunen 1983;Koskenniemi 1984;Roark and Sproat 2007). 16 Consider partial stem copying in Bikol: na{ r murak} r → na{ r mu{ r murak} r . Without the root boundaries, we could not distinguish the prefixed input na{ r murak} r from a hypothetical mono-morphemic input namurak. Without some way to encode the relevant morphological constituents in the input, we simply cannot define this reduplication function with any type of 1-way or 2-way FSTs. The use of such boundaries in finite-state morphology is standard practice.

Copying a prosodic subconstituent
Besides morphological subconstituents, the source can also be a metrical or prosodic subconstituent such as the stressed syllable (16a), the first syllable (16b), or the first foot (16c). The source can also 16 It should be noted though that HPSG-based approaches to computational morphology Crysmann 2013, 2016; do not need morpheme boundaries as symbols in their alphabet. One reason is because they can essentially directly capture hidden morphological structure or constituency. Another strategy is to temporally apply reduplication to the subconstituent and then later add the other affixes, e.g., haata → haata∼haata → ku-haata∼haata. This a common strategy in handling morphology-semantics bracketing paradoxes (cf. Stump 1995Stump , 2001).
[ 215 ] be a morphophonological constituent, e.g. a prosodic stem (16d). In Chumash, the prosodic stem (underlined) consists of all the segments in the morphological stem alongside any prefixal consonants that are syllabified with the morphological stem.
(16) Copying from a metrical or prosodic subconstituent a. CV-reduplication of the stressed syllable Chamorro ( If the relevant prosodic boundaries are in the input, the computation is C-OSL. The computation proceeds the same as for copying a morphological constituent. Table 6 shows this with syllable boundaries ( s ) s , foot boundaries ( f ) f , stressed syllable boundaries ( S ) S , and prosodic stem boundaries ( PS ) PS . 17 Given an unsyllabified input, these prosodic boundaries can be generated via a 1-way FST (Hulden 2006;Yu 2017) which can be ISL because it uses finite lookahead on the input (see also Strother-Garcia 2018, 2019.
However, if the input to reduplication lacks boundaries, then reduplication is C-Seq because we need finite lookahead to know if some consonant is part of the relevant prosodic constituent. Consider initial syllable copying in Hiaki vusa → vu∼vusa. In the first function L(x), the consonant s is not generated because it is part of the next syllable. We know because it precedes a vowel. In contrast for vamse → vam∼vamse, the consonant m is copied because it precedes a consonant. The use of such information from finite lookahead on the input cannot be computed by an OSL function. This section presented cases in RedTyp which are C-OSL. They comprise the bulk of reduplicative typology. Of the 138 reduplicative processes in RedTyp (Section 4.2), 121 (87%) were C-OSL.

Some reduplication is C-Seq
This section goes through some types of reduplication which are not C-OSL but are instead C-Seq. Informally, a reduplicative function is C-Seq if its component functions do not rely on any information from the other function or its output. A component function can use finite lookback, finite lookahead, or even long-distance information in the input.

Internal reduplication and gray areas between C-OSL or C-Seq
One problematic area for C-OSL are internal reduplication functions which seem infixal (Broselow and McCarthy 1983;Gafos 1998;Spaelti 1997). Some of these are C-OSL, some are not. These functions are C-OSL if the truncation functions can uniquely determine what segments to delete based on only what was outputted.
In the previous sections, the reduplication's target can be thought of as a contiguous substring that is determined by scanning either the left or right edge of the source. In those cases, the target was at the edge of the source and the reduplicant was placed at the left or right edge of the base. However, there are cases of internal or infixal reduplication where the target is a substring inside the source such that the substring is not strictly adjacent to the source's edges (17a, 17b) and the reduplicant is placed inside the base in the output (17c). In (17c), the word-initial C is copied and placed after the first vowel.

Initial-C reduplication and internal placement
Quileute (Broselow and McCarthy 1983, 44) t S iko → t S i∼tko 'he failed sp.' → 'he failed (freq.)' Table 7 visualizes these processes. A traditional analysis is that the reduplicant is infixal (Broselow and McCarthy 1983) where <> marks infixation, e.g., Mangarayi ɡabuji → ɡab<ab>buji. However, their treatment as C-OSL is somewhat counter-intuitive because a C-OSL function models these processes as concatenating two truncation functions: ɡabuji∼ɡabuji. The first function L(x) outputs the first C*VC* substring and deletes everything after that. The second function R(x) deletes all word-initial strings of consonants C*; once it sees a vowel V, it outputs it and everything after it.

6.3.2
Internal or non-contiguous reduplication which is C-Seq The main reason why Mangarayi and the other functions in Table 7 are C-OSL is because the target and deleted materials do not have the same shape. Knowing what to delete or generate doesn't need any finite lookahead or lookback over the input, just over the output. However, other cases of internal and non-contiguous reduplication do require such finite lookback/lookahead over the input. This makes them Table 7: Infixal vs. C-OSL treatment of internal reduplication C-Seq. In (18a), the penultimate syllable is reduplicated. In (18b), the word-initial CV is copied and placed before the final C. In most of these cases, the target is a contiguous substring in the input. In some cases, the target is not contiguous (18c). In (18c), the input's first CV and final C are copied and placed together at the beginning of the output. These C-Seq processes are visualized in Table 8. Consider penultimate syllable copying in Samoan with two truncation functions a.lo.fa → a.lo.fa∼a.lo.fa. If the input is read left-to-right, the first function must output everything up until the penultimate syllable: a.lo.fa. This is not OSL because knowledge about whether some syllable is penultimate or not requires finite lookahead on the input. If the input is instead read right-to-left, the first truncation function is still not OSL. The function would delete the last vowel and the last consonant; but once it sees the penultimate vowel, the function cannot Infixal treatment a.lo<lo>fa fayat<fa>k lúx w ∼lút'ux w C-Seq treatment a.lo.fa∼a.lo.fa fayatk∼fayatk lút'ux w ∼lút'ux w Subclass C-Seq C-Seq C-Seq determine if this vowel is penultimate or not based on only what it has outputted. The function would need lookback access to the input. In both left-to-right and right-to-left cases, the truncation functions are Seq. The other processes in Table 8 are not C-OSL for similar reasons.
Although penultimate syllable copying is not C-OSL, Samoan has penultimate stress (Zuraw et al. 2014). Stressed syllable copying is C-OSL. This is an argument for reanalyzing Samoan as instead copying the stressed syllable. This relates to Nelson's (2003, 117) hypothesis that any references to the penultimate position in reduplication must be prosodic. Note that for Creek and Nisgha, the component functions are Seq; however they do not generate the right origin semantics because of unbounded word-internal deletion. The first function for Nisgha deletes everything except for the first CV and last C lut'ux w . If read left-to-right, in order to generate the final C, we need to move to the next symbol and check if it is ⋉; thus the final C is generated as an output correspondent for the end-boundary ⋉. If read left-to-right, in order to generate the initial CV, we move on to the preceding symbol and check if it is ⋊; thus the first CV are generated as output correspondents to the start-boundary ⋊. This is because Seq functions are deterministic. In contrast, the right origin semantics would be generated if the component functions were non-deterministic or if the function was computed by a full 2-way FST. 19

Grey areas between C-Seq and rotating transducers
The above cases with infixation showed that capturing the right origin semantics might require classes which are more expressive than C-OSL and C-Seq. In this section, we go through more cases. Some are ambiguously C-Seq depending on the analysis; others must use rotating or even unrestricted 2-way D-FSTs in order to capture the right origin semantics.

Reduplication with syllable-count
Reduplication that is sensitive to syllables may involve iteration (19a) or minimality requirements on what is reduplicated (19b). Both examples are from Mandarin for different reduplicative processes. In (19a), reduplication is iterative because each syllable undergoes total reduplication: an input of the form A.B has A.A.B.B as the output. In (19b), a word undergoes total reduplication if it is monosyllabic, otherwise the morpheme meei is added.

b. Minimality in reduplication
Mandarin (Moravcsik 1978, 305-6). janɡ → janɡ∼janɡ 'sheet' → 'every sheet' jia.luen → meei-jia.luen 'gallon' → 'every gallon' Iterative copying (19a) is C-OSL if the number of iterations (=number of syllables) is bounded. The individual syllables must also be uniquely identifiable in the input. For Mandarin, the function is made up of four concatenated OSL truncation functions. The first two functions output everything up until the medial syllable boundary '.' while the latter two delete everything up until the '.' boundary.
(20) Mandaring iterative reduplication as C-OSL: We likewise have not seen cases of trisyllabic iterative copying in other languages. This is computationally significant. If Mandarin allowed iterative copying over trisyllabic words, then generating the right origin semantics would need as many passes over the input as there are syllables in the input. The function would either need the full power of a 2-way D-FST in order to generate the right origin semantics, otherwise we could use a 1-way FST that has the linguistically-unmotivated origin semantics.
As for minimality requirements (19b), this cannot be computed by a C-Seq transducer with the right origin semantics. In order to reduplicate a monosyllabic input: jang → jang∼jang, we use two concatenated identity functions. But to block reduplication in a bisyllabic input jia.luen → meei-jia.luen, we need to check that the input does not contain any medial syllable boundaries. The first function would need to use to finite lookahead before choosing to output the first segment j or the prefix meei. As with the infixation cases in Section 6.3.2, a C-Seq 2-way FST can do so but it then generates the wrong origin semantics because it associates the output segment j with the input syllable boundary '.'. Generating the right origin semantics needs a rotating 2-way D-FST that involves three passes. The first pass reads the input and checks if it is monosyllabic or not. If yes, the second and third passes apply the identity function: janɡ∼janɡ. If no, the second pass outputs the prefix and the base meei-jia.luen; there is no third pass.

6.4.2
Phonological changes to the reduplicant The previous section illustrated how C-Seq 2-way FSTs are distinct from rotating 2-way FSTs. In the latter, a pass can transfer information (e.g., is the input monosyllabic) to a later pass. Similar information transfer is required in certain cases where phonological processes interact with reduplication. We first go over cases where we arguably do not need such information transfer. Reduplicative patterns do not only involve copying. In addition to copying segments, a reduplicative process may involve a host of other [ 222 ] phonological transformations (Steriade 1988;Raimy 2011). When reduplication interacts with phonological transformations, the complexity may change. Some of these phonological changes affect only the reduplicant (21), including prosodic modifications to the reduplicant (21a), simplifications of the reduplicant (21b), or creating nonidentity across the two copies (21c). 20 In (21a), the initial-CV is copied; the reduplicant's vowel is lengthened. In (21b), the stem's initial-CV is copied. If the stem starts with a complex onset, then the complex onset is reduced to CV. In (21c), the input undergoes total copying; the second copy starts with /m-/ which replaces any word-initial onset.
These phonological modifications can be understood in terms of function composition as a formal analog to phonological rule ordering (Steriade 1988). This is shown in Table 9. Consider Papago lengthening. This is computed by a C-OSL function which is the concatenation of modified truncation function M(Tr(x)) and identity ID(x). The function M(Tr(x)) is the composition of a truncation function Tr(x) that deletes the string bana to ba inside a modification function M(x) that lengthens word-initial ba to baa. Both truncation and modification are 20 These simplifications are often called TETU (or the emergence of the unmarked) effects Prince 1994, 1995). Cases of echo-reduplication like (21c) are highly common and found even in Indo-European languages such as English book-schmook (Nevins and Vaux 2003). It is often sensitive to phrasal or syntactic factors (Fitzpatrick-Cole 1994;Lidz 2001).
[ 223 ] L-OSL, their composition is L-OSL, and the concatenation with ID(x) is C-L-OSL. Complex onset reduction in Tagalog and echo reduplication in Turkish are likewise C-L-OSL and consist of the concatenation of a composed L-OSL function with some other L-OSL function.
However, this does not mean that all hypothetical cases of reduplicant modifications are C-OSL. Such processes can be C-Seq or higher if the composition of a truncation or identity function with the modification function is Seq or higher. For example, if complex onset reduction in the reduplicant deleted the first consonant: mag-trabaho → mag-ra∼trabaha, this process would be C-Seq and not C-OSL. In the first copy, the truncation function would generate maɡ{ r trabaho, while the modification function would generate mag{ r tra. Deleting only the root-initial consonant t if it precedes a consonant is not OSL because we need finite lookahead on the input. Interestingly, this type of cluster reduction is argued to be unattested in reduplication (Zukoff 2017, 25). This may either be an accidental gap or evidence that reduplication modification must be C-OSL. To our knowledge, there is no typological survey of attested reduplicant modifications to settle this. 6.4.3 Phonological changes to or across both copies Phonological changes may likewise affect both copies or apply across the boundary between the copies (22). Some involve a phonological process which is productive in the language (22a), others involve a phonological process which is not found anywhere else in the language outside of reduplication (22b). The former set of cases are often called In (22a), the prefix maN-can trigger reduplication of the root/stem. Nasal substitution combines the prefix's nasal with an adjacent voiceless consonant into a single nasal that has the place of articulation of the consonant. Nasal substitution applies only to the segment next to the prefix, regardless of whether that consonant is part of the reduplicant or not. In (22b), the final syllable of the root is copied and placed at the left edge of the input. If there are two coronals across the reduplicative boundary (b), then the first coronal becomes dorsal. The final /a/ is epenthesized.
We likewise find phonological processes or rules interacting differently in the context of reduplication. For example in Madurese, there is a phonological process of nasal spread in which nasality is spread from nasals onto sequences of glides and vowels (23a). Reduplication copies the final CVC and places it at the beginning of the output (23b). If a vowel in the base is nasalized by a nasal, its nasality will transfer to the reduplicant as well. Because the reduplicant does not contain any nasals to trigger nasal spread, nasal spread in the reduplicant is treated as an over-application of the phonological process of nasal spread.
[ỹãt∼nẽỹãt] 'intentions' [ 225 ] Traditionally, these cases can be thought as a composition of a morphological rule of reduplication (C-OSL) and a phonological rule (that is independently ISL, OSL, or Sequential) (Raimy 2000;Inkelas and Zoll 2005). If the morphological rule precedes the phonological rule, then we have normal application. If the morphological rule outputs reduplicant boundaries and precedes the phonological rule, then we have juncture effects. And, if the phonological rule precedes the morphological rule then we have over-application. Table 10 visualizes these three types of interactions as rule or function composition.
Innermost functions maN{ r taɡtaɡ} r ∼ maŋ { r taɡtaɡ} r žat ∼ žata nẽỹãt Outer function maN{ r ŋaɡtaɡ} r ∼ { r taɡtaɡ} r žaɡ ∼ žata nẽỹãt∼nẽỹãt Computationally, we can treat all these cases as composition of a C-OSL/C-Seq function for reduplication with an OSL/Seq function for phonology in either order. We conjecture C-OSL/C-Seq functions are not closed under composition, but we do not prove it. This means that composition may create a rotating 2-way FST.
Whether a case of normal application, juncture effect, or overapplication is C-OSL, C-Seq, or higher depends on the complexity of the individual functions. In fact, the above three examples can be done with a C-Seq transducer. To illustrate, consider over-application in Madurese. Nasal spread is an L-OSL function M(x). Reduplication is the concatenation of an R-OSL truncation function L(x) and an L/R-OSL identity function R(x). To generate overapplication, reduplication is instead the concatenation of two modified functions L(M(x)) · R(M(x)). The first function is the composition of truncation over nasal spread. The composition of these two OSL rules of different directions is L-Seq because nasalization relies on deleted information [ 226 ] from the input. 21 The second function is the composition of identity over nasal spread; this is L-OSL. Together, Madurese overapplication is C-L-Seq.
It is an open question if there are cases of normal application, juncture effects, and over-application which cannot be treated with a C-Seq formalization but require an unrestricted rotating 2-way FST. Solving this requires an in-depth knowledge of both the morphology and phonology of any such example (Inkelas and Zoll 2005). Under-application and Back-copying In contrast to the over-application of phonological processes in reduplication, we likewise find cases of under-application. For example in Akan, velar consonants become palatalized before nonlow front vowels: /k,ɡ/ → [tɕ, dʝ]/ __ /i,e/ as in (24a). Akan likewise has a process of initial-CV reduplication where the reduplicant V is a pre-specified non-low front vowel /ɪ/ (24b). 22 However if the reduplicant C is a velar, it will not be palatalized before the reduplicant's non-low front vowel /ɪ/ (24c). Thus the rule under-applies. The velar will only palatalize if both copies of the velar in the reduplicant and base are preceded by a non-low front vowel (24d).

(24) Under-application of palatalization in reduplication
Akan ( 'receive' Cases of apparent under-application or over-application in reduplication are termed opacity effects (cf. the transparency of normal application (22a)). They are often understood as being caused by a need to maintain identity between the two copies that reduplication cre-ated (Wilbur 1973;McCarthy and Prince 1995). A more drastic version of identity is back-copying whereby the reduplicant undergoes some phonological rule, and then the effects of this rule are transferred onto the base. It is reported that in Malay, nasality spreads from a nasal consonant onto a sequence of vowels. Nasality can spread over glides and /h/. Plurality is marked by total reduplication. If nasal spread applies across the two copies, nasality will transfer onto both copies. Because under-application and back-copying have weak empirical backing, there is a limited attested typology of these processes. It is thus unclear whether we can make any computational generalizations about them. But putting aside these empirical problems, Akan under-application can be modeled with a C-Seq function which uses finite lookahead on the input. It is the concatenation of a modified truncation function and a modified identity function. The first function truncates the input C 1 V 2 Σ * to C 1 i and applies palatalization if V 2 is /i,e/. The second function applies palatalization to the input.
Malay back-copying is not C-Seq. This is because nasalization requires unbounded lookahead on the input. The function requires an unrestricted rotating transducer with three passes over the input. 24 In the first pass, we output nothing but we check if the input ends in a N(V+G)* sequence where G stands for glides and /h/: hamə. If yes, the second pass applies nasal spread starting from the first segment: hamə∼hãmə. The third pass does the same: hamə∼hãmə∼hãmə.

Overview of the typology summary
To summarize, we cataloged a wide variety of attested reduplicative patterns. All of it can be computed with deterministic 2-way FSTs. Most common and uncommon types of reduplication can be computed with the subclass of C-OSL functions, including total reduplication (12a), common partial reduplication patterns (13), triplication (14a), suffixal reduplication (14b), non-local reduplication (14c), and abbreviated reduplication (14d). Subconstituent reduplication is likewise C-OSL if the relevant morphological (15) or prosodic boundaries (16) are present in the input. In fact, of the 138 reduplicative processes in RedTyp ( §5.2), 121 (87%) are C-OSL. 25 We analyzed the typology in terms of generating the right origin semantics. To do so, some less common types of reduplication are C-Seq or higher. This is largely because of the need for finite lookahead on the input. Some but not all types of infixal or non-contiguous reduplication are C-OSL (Section 6.3.1) and some are C-Seq (Section 6.3.2). In the latter case, generating the right origin semantics can require full 2-way FSTs because of the need for finite lookahead. Some cases like iterative reduplication (19a) are C-OSL if the input is at most bisyllabic; otherwise generating the right origin semantics needs an unrestricted 2-way D-FST. Minimality requirements (19b) likewise require 24 Malay back-copying can likewise be treated as the composition of a C-OSL function for triplication hamə∼hamə∼hamə, followed by an OSL function for nasal spread hamə∼hãmə∼hãmə, followed by an OSL function that deletes everything before the first ∼ boundary hãmə∼hãmə. This analysis is inspired by Reiss and Simpson (2009). 25 Although the cross-linguistic typology on reduplication is overwhelmingly C-OSL, our numbers from RedTyp do not mean that we estimate that 13% of the cross-linguistic typology of reduplicative processes is not C-OSL. RedTyp likely under-represents cases of opacity. Such cases can be non-C-OSL. full 2-way D-FSTs. When reduplication interacts with phonological processes, the computation can range anywhere from C-OSL to full 2-way D-FSTs depending on the individual phonological process and the order of function composition. We suspect the finite lookahead in these cases may be resolved with more sophisticated representations and logical transductions (Dolatian 2020).
This concludes the section on how various subclasses of 2-way D-FSTs map to certain divisions in the reduplicative typology. The above cases are representative of common and uncommon reduplicative processes. There are other subtle variations for reduplication in natural language, such as cases of allomorphy (Spaelti 1997), or multiple reduplicants (Urbanczyk 1999(Urbanczyk , 2001Fitzpatrick and Nevins 2004;Fitzpatrick 2006), among others. We will not discuss these cases because a full typology is beyond the scope of this paper. However, virtually all attested reduplicative processes can be modeled with 2-way FSTs. Fitting the entire attested typology into the right subclasses is a fruitful research direction. The next section looks at cases where 2-way D-FSTs arguably over-generate or under-generate the typology, even with these well-defined subclasses.

Issues in over-and under-generation
Here, we address the questions whether and how 2-way D-FSTs underand over-generate reduplicative processes.
6.6.1 Over-generation with 2-way D-FSTs One way to interpret the contribution we have made is that we are advocating the following hypothesis: (26) 2-way Hypothesis: Reduplication is anything that can be computed with 2-way D-FSTs. This is not, in fact, a position we advocate. We think this hypothesis is false because it overgenerates in ways we consider linguistically bizarre. For example, 2-way D-FSTs can map words to their reverse (w → w r ) and to a copy of itself and its mirror image (w → ww r ). None [ 230 ] of these transformations are attested morphologically. Some overgeneration can be avoided by hypothesizing stronger computational properties; that is, focusing on subclasses of 2-way D-FSTs which cannot generate the above unattested patterns.
This leads to another hypothesis.
The C-OSL hypothesis is well supported because it covers the bulk of reduplicative typology as shown in Section 6. Rarer reduplicative patterns require more powerful subclasses of 2-way D-FSTs. Even this hypothesis can be said to suffer from overgeneration. For example, while this excludes the reversal and mirror image processes above, it permits total reduplication of a word up to some large natural number n (w → w n ), or partial reduplication up to some natural number n of segments.
Nonetheless, not all issues in overgeneration can be reduced to computation or computability. Some are certainly due to external factors. 26 To illustrate, total reduplication in most spoken languages creates at most two copies. The creation of three copies (= triplication) is relatively rare in spoken languages, e.g. Thao (Blust 2001). In sign languages, we find the reverse situation: creating two copies is rare but triplication is common, e.g. ASL (Wilbur 2005). The difference between sign and spoken reduplication is more likely due to modality and not to the computation. 27 6.6.2 Under-generation with 2-way D-FSTs Non-computational factors can also help us understand apparent cases of under-generation. There are two cases we discuss here: abstract morphemic copying and reduplication with haplology. Both of these 26 Like Potts and Pullum (2002, 375), "we are extremely sceptical of the idea that formalisms exist that correspond exactly to what linguists wish to say." 27 A similar point can be made for the role of pivot or anchor points in reduplication. Cross-linguistically, most reduplicative processes target specific positions in the word which are perceptually or psycho-linguistically more salient (Samuels 2010; Raimy 2009; Idsardi and Raimy 2008), e.g. the first syllable and not the third syllable. The choice of these pivots is likely functional, not computational. [ 231 ] can be explained as involving interactions between reduplication and other linguistic modules (the lexicon) or processes (filters).

Undergeneration of abstract morphemic copying
Abstract morphemic copying is when the input to the copying mechanism is not a string of phonological segments but a more abstract morphological entity, i.e. a morpheme or morpho-syntactic feature bundle (Inkelas and Zoll 2005). This is in contrast to examples reviewed earlier, where the source of reduplication was a string of segments which may contain morpheme boundaries. Such a case occurs in Sye in Table 11.
In Sye, a stem may have multiple suppletive allomorphs used in different morphological contexts. For example, the abstract morpheme FALL in Table 11a has two allomorphs amol and omol, such that amol is used after future morpheme and certain other tense morphemes while omol is used elsewhere. As for reduplication, total reduplication is used to mark intensification (Table 11b). When total reduplication applies in a context that requires using one of the allomorphs, we have an allomorph mismatch between the two copies (Table 11c).  Inkelas and Zoll (2005) analyze Sye as involving morphological copying. The copies are not in phonological correspondence because they are different allomorphs of the same morpheme. What was copied was an abstract morpheme FALL. Its two copies were later spelledout as two different allomorphs. Inkelas and Zoll's (2005) analysis for Sye is controversial (Frampton 2009); but there are a few other languages which show that the reduplicant is copying an abstract morphological entity (Inkelas and Downing 2015a,b;).
Cases of morphological copying for suppletive roots can be modeled with a 2-way D-FST that copies an abstract pre-spelled-out morphological entity, e.g. a root morpheme FALL or a root index (Harley 2014) which can be represented as a finite string of symbols. This is followed by a 1-way FST that models spell-out such that it is equipped [ 232 ] with knowledge over what all the finite pairs of morphemes and their suppletive allomorphs are. We make the safe assumption that the number of morphemes in a language that show suppletion is finite. 28

Undergeneration of reduplication with haplology
Another case of potential under-generation is when reduplication is affected by antihomophony constraints or haplology, i.e. when reduplication is blocked because it would create a sequence of identical syllables or feet that is dis-preferred by speakers (Yip 1995;Nevins 2012).
(28) Reduplication and haplology in Kanuri a. kanəmbu 'Kanembu tribe' kanəmbu∼kanəmbu 'language of the Kanembu tribe' b. karekare 'Karekare tribe' *karekare∼karekare 'language of the Karekare tribe' A 2-way D-FST can encode this requirement that the input must not itself be a sequence of identical syllables or feet. However that would require the 2-way D-FST to know what all the finitely possible sequences of syllables and feet are in the language.
Two alternatives to this solution are possible. One is using a copyand-filter mechanism (Golston 1995). The 2-way D-FST would handle the copying. The output of the copying process would be fed to a phonological system which would filter out any homophonous sequences of syllables or feet. The other alternative is to argue that the Kanuri input stems which contain a repeated sequence of symbols /karekare/ are underlyingly already reduplicated via lexical reduplication /kare+RED/. Such arguments have been brought up for superficially similar haplology effects in Manam (Buckley 1997). From this approach, there is then no haplology problem for 2-way D-FSTs.
In sum, although virtually the entire typology of reduplication can be modeled with 2-way D-FSTs, there are complications if one wishes to model the full interface of reduplicative morphology with other systems. However, as a reviewer point outs, it may not be desirable, from a linguistic perspective at least, to model the interfaces in this way. It is disputable whether complications occurring at the interface of morphology with syntax or phonology should be addressed within an FST that is intended to account for the computational complexity of the morphology itself. On the other side of the coin, some conceptual problems arise with over-generation of 2-way D-FSTs because of the power that they require to handle copying in the first place.

CONCLUSION
The present study has taken a step in formalizing the wide typology of reduplicative processes in formal-language theoretic terms. We showed that 2-way D-FSTs, which are are an understudied type of finite-state transducer, can easily model reduplication because they can reread their input multiple times in multiple directions. Computationally, this means that recognizing whether strings belong to the copy language {ww | w ∈ Σ * } (so for any w ∈ Σ * determining whether there is a v ∈ Σ * such that w = vv) is a harder problem than the one that takes any w ∈ Σ * as input and returns ww as output (copying). Reduplication studied as recognition is computationally more complex than reduplication studied as copying.
In addition to modeling reduplicative morphology as copying, 2way D-FSTs do not suffer from state explosion nor do they assume finite bounds on the input, unlike 1-way FSTs. In terms of strong generative capacity, 2-way FSTs actively copy segments instead of memorizing segments. A diagnostic for copying vs. remembering is the origin semantics of the function. This article also presented the RedTyp database, which provides concrete examples of 2-way DFSTs modeling a range of cross-linguistic reduplicative morphemes.
Furthermore, we showed that the typology of reduplication can be modeled with subclasses of 2-way FSTs that are essentially defined as concatenations of simple subclasses of 1-way FSTs. Thus, our work showed the role of computational subclasses in carving out the generative capacity of morphological processes, whether reduplicative or not. To give more context, most morphological processes can be computed by 1-way finite state automata and transducers (Koskenniemi 1983;Beesley and Karttunen 2003). In fact, substantially less expressive subregular classes are capable of computing most of these morphological processes (Aksënova et al. 2016;Chandlee 2017). So far, these subclasses have been identified based on considerations of locality (ISL, OSL) and determinism (Seq, sequentiality). At first, reduplication looks like an outlier in that it requires the more expressive generative capacity of 2-way transducers. However, even within this larger class of 2-way FSTs, we argued that reduplication only needs certain subclasses which are also based on the same considerations of locality (C-OSL) and sequentiality (C-Seq). These subclasses reinforce the role of locality and determinism as general constraints in linguistic processes (cf. Heinz 2018).
Having showcased the utility of 2-way D-FSTs for modeling reduplication, we conclude with three avenues of future research.
First, we have approached reduplication from the perspective of morphological generation. Given an input buku, a 2-way D-FST can generate the output buku∼buku easily. On the other hand, it is an open question as to how to do morphological analysis with 2-way FSTs to get the inverse relation of buku∼buku → buku. As a class, deterministic 2-way FSTs are not invertible. We are currently developing algorithms for inverting the subclasses (C-OSL, C-Seq) that we have set up.
A second area of research is the integration of 2-way FSTs into natural language processing. This obviously has many aspects. A first step may be the integration of 2-way FSTs into existing platforms such as xfst (Beesley and Karttunen 2003), open-fst (Allauzen et al. 2007), foma (Hulden 2009b), and pynini (Gorman 2016). 29 A third promising area of research is developing learning models based on the computational models that we proposed here. One approach builds on Chandlee et al.'s 2015 learning results of OSL func-tions (Dolatian and Heinz 2018a). Another approach probes the learnability of reduplicative patterns with neural networks (Nelson et al. 2020).