Abstract
Phonological generalizations are finite-state. While Optimality Theory is a popular framework for modeling phonology, it is known to generate non-finite-state mappings and languages. This paper demonstrates that Optimality Theory is capable of generating non-context-free languages, contributing to the characterization of its generative capacity. This is achieved with minimal modification to the theory as it is standardly employed.
1 Introduction
Phonological generalizations are finite-state (Johnson, 1972; Kaplan and Kay, 1994; see Heinz, 2018, for a recent overview); that is, input-output mappings can be modeled using finite-state transducers and phonotactic well-formedness can be modeled using finite-state acceptors.
Optimality Theory (OT; Prince and Smolensky, 1993/2004) is a framework that is commonly used to model phonology. While some restricted variants of OT are finite-state (Frank and Satta, 1998; Eisner, 2000, 2002; Riggle, 2004; see Hulden, 2017, for a recent overview), standard OT, as it is employed by practicing phonologists, is known to generate non-finite-state mappings and languages (Eisner, 1997; Frank and Satta, 1998).
OT is a special instance of Harmonic Grammar (Legendre et al., 1990), which can model arbitrary computations (Smolensky, 1992). While the exact generative capacity of OT has not yet been characterized, it has recently been shown to produce non-context-free mappings (Lamont, 2019a, b). This paper contributes to the literature on OT by demonstrating its capacity to generate non-context-free languages using constraints defined over subsequences. Subsequences are finite literals composed of ordered symbols that are not necessarily adjacent.1 They contrast with substrings, whose constituent elements are contiguous. Figure 1 illustrates the subsequences of length 2 in the string example. Of these twenty-one subsequences, six are also substrings of length 2: e… x, x… a, a… m, m… p, p… l, l… e.
In the literature on phonotactics as formal languages, subsequences have been used to model non-local phenomena (Heinz, 2007, 2010, 2014; Rogers et al., 2010; Graf, 2017). For example, if a language disallows words from surfacing with more than one lateral consonant, it can be modeled as banning the subsequence l…l. Languages defined by banning a finite set of subsequences belong to the Strictly Piecewise languages, which are properly contained within the class of regular languages.
Strictly Piecewise languages impose inviolable constraints on subsequences: A string belongs to a language if and only if it does not contain any banned subsequences. In OT, all constraints are violable, and violations are minimized whenever possible. Consequently, in addition to modeling non-local restrictions, constraints on subsequences are often used to minimize the distance between two objects (McCarthy and Prince, 1993; Hyde, 2012, 2016). For example, Figure 2 illustrates a string of syllables, represented as σ, that belong to a prosodic word, whose edges are marked with square brackets. Two syllables are parsed into a foot, indicated by parentheses. The number of )…σ… ] subsequences indicates how far the foot is from the right edge of the prosodic word, calculated over intervening syllables.
When only one foot is parsed, aligning it to the right edge of the prosodic word eliminates )…σ… ] subsequences: [σσσσσ(σσ)]. However, they are unavoidable when multiple feet are parsed. In these cases, the pressure to minimize )…σ… ] subsequences determines the prosodification. For example, Table 1 illustrates four parses of a seven syllable string that contain three disyllabic feet and one monosyllabic foot. The position of the monosyllabic foot affects the total number of )…σ… ] subsequences.
Parse . | Total . |
---|---|
[(σ)(σσ)(σσ)(σσ)] | 12 |
[(σσ)(σ)(σσ)(σσ)] | 11 |
[(σσ)(σσ)(σ)(σσ)] | 10 |
[(σσ)(σσ)(σσ)(σ)] | 9 |
Parse . | Total . |
---|---|
[(σ)(σσ)(σσ)(σσ)] | 12 |
[(σσ)(σ)(σσ)(σσ)] | 11 |
[(σσ)(σσ)(σ)(σσ)] | 10 |
[(σσ)(σσ)(σσ)(σ)] | 9 |
It is not possible to replicate these effects with inviolable constraints on subsequences. Formally, this is because some strings that are not in the language are themselves subsequences of strings that are in the language. For example, to ban the string *[(σ)(σσ)], one must ban one of its subsequences. However, because *[(σ)(σσ)] is itself a subsequence of [(σσ)(σσ)], the latter contains every subsequence of the former, and *[(σ)(σσ)] cannot be banned without incorrectly banning [(σσ)(σσ)]. This example illustrates that violable constraints on subsequences in OT generate languages more expressive than Strictly Piecewise languages. Along similar lines, Koser and Jardine (2020) demonstrate that violable constraints on substrings in OT are more expressive than inviolable constraints.
Optimization and violability contribute much more expressivity than these results suggest. Eisner (1997, 2000) demonstrated that OT can generate context-free languages with subsequence constraints, and this paper pushes his result into non-context-free languages. The main result of this paper has wide-reaching consequences for phonologists, as many standard constraint families are defined over subsequences. Examples include alignment constraints (McCarthy and Prince, 1993; Hyde, 2012, 2016), conjoined constraints (Smolensky, 1993, 2006; Alderete, 1997), co-occurrence constraints (Suzuki, 1998; Pulleyblank, 2002), Share constraints (McCarthy, 2010; Mullin, 2011), and the family of surface correspondence constraints (Walker, 2000; Hansson, 2001, 2010; Rose and Walker, 2004; Bennett, 2013, 2015).
Eisner’s result, that OT with subsequence constraints generates context-free languages, is presented in section 2. It further argues that restricting the set of subsequence constraints available to OT does not limit its generative capacity. This paper’s contribution, that OT generates context-sensitive languages with constraints on subsequences, is presented in section 3. The result is illustrated with case studies on prosodic parsing and non-local dissimilation, and a proof of the general case is provided.
2 Violable Subsequence Constraints Can Divide Strings into Halves
Eisner (1997, 2000) demonstrated that with violable constraints on subsequences, mappings in Optimality Theory can target the centers of strings. In his example, the Midpoint Pathology, a feature in the input shifts so as to surface in the center of the output. Taking stress as that feature, the Midpoint Pathology is defined in (1) as an input-output mapping, where σ represents a syllable, and represents a stressed syllable. The output language is homomorphic to the archetypal non-finite-state language anbn, with the allowance of an additional a or b.
- (1)
where i + j = k + l and |k − l|≤ 1
In OT, a set of candidates is generated from an input string, and evaluated by a ranked set of constraints. Constraints are functions that map candidates onto a number of violation marks, assigning as many violations as there are specific structures in the candidate or specific changes made to the input to generate the candidate. The candidate that is lexicographically minimal in its concatenated violations is returned as output. In the Midpoint Pathology, stress shifts to minimize the violations of the alignment constraint (McCarthy and Prince, 1993; McCarthy, 2003) defined in (2), which assigns a candidate as many violations as and subsequences it contains.
- (2)
Align(σ, , σ): For every syllable σ, if there is a stressed syllable , assign one violation mark for every syllable that intervenes between σ and .
The tableau in Table 2 illustrates stress shifting onto the middle syllable of a seven syllable string. The candidate set contains the input string // (2a) and the six candidates derived from it by shifting the stress to another syllable (2b–g). The middle column shows the number of violations Align(σ, , σ) assigns each candidate; for clarity, the violations incurred by each syllable are shown separately. Violations of Align(σ, , σ) decrease as stress approaches the center syllable. For completeness, the rightmost column shows the number of violations assigned by the constraint Ident(stress), which penalizes syllables whose stress value in the input was changed. The ordering between constraints indicates that Align(σ, , σ) is ranked above Ident(stress). The candidate with medial stress (2d) is returned as output because its violation vector (6,2) is lexicographically minimal. If Ident(stress) were ranked above Align(σ, , σ), candidate (2a) would be returned as output.
// . | Align(σ, , σ) . | Ident(stress) . |
---|---|---|
a. | 0 + 0 + 1 + 2 + 3 + 4 + 5 = 15 | |
b. | 0 + 0 + 0 + 1 + 2 + 3 + 4 = 10 | 2 |
c. | 1 + 0 + 0 + 0 + 1 + 2 + 3 = 7 | 2 |
→ d. | 2 + 1 + 0 + 0 + 0 + 1 + 2 = 6 | 2 |
e. | 3 + 2 + 1 + 0 + 0 + 0 + 1 = 7 | 2 |
f. | 4 + 3 + 2 + 1 + 0 + 0 + 0 = 10 | 2 |
g. | 5 + 4 + 3 + 2 + 1 + 0 + 0 = 15 | 2 |
// . | Align(σ, , σ) . | Ident(stress) . |
---|---|---|
a. | 0 + 0 + 1 + 2 + 3 + 4 + 5 = 15 | |
b. | 0 + 0 + 0 + 1 + 2 + 3 + 4 = 10 | 2 |
c. | 1 + 0 + 0 + 0 + 1 + 2 + 3 = 7 | 2 |
→ d. | 2 + 1 + 0 + 0 + 0 + 1 + 2 = 6 | 2 |
e. | 3 + 2 + 1 + 0 + 0 + 0 + 1 = 7 | 2 |
f. | 4 + 3 + 2 + 1 + 0 + 0 + 0 = 10 | 2 |
g. | 5 + 4 + 3 + 2 + 1 + 0 + 0 = 15 | 2 |
As this example demonstrates, shifting stress onto the medial syllable minimizes the violations of Align(σ, , σ); see section 3 for a proof that this holds for any length input. Hyde (3; 2008; 2012; 2016) argues that the Midpoint Pathology is an artifact of the symmetrical nature of Align(σ, , σ). In particular, if the constraint penalized only or subsequences and not both, then stress would be drawn to one edge rather than the center. The tableau in Table 3 illustrates this. Here, only subsequences are penalized, and stress is drawn to the right edge, surfacing on either of the last two syllables (3f–g).
// . | * . | Id(stress) . |
---|---|---|
a. | 15 | |
b. | 10 | 2 |
c. | 6 | 2 |
d. | 3 | 2 |
e. | 1 | 2 |
→ f. | 0 | 2 |
→ g. | 0 | 2 |
// . | * . | Id(stress) . |
---|---|---|
a. | 15 | |
b. | 10 | 2 |
c. | 6 | 2 |
d. | 3 | 2 |
e. | 1 | 2 |
→ f. | 0 | 2 |
→ g. | 0 | 2 |
While asymmetrical constraints avoid the Midpoint Pathology specifically, they motivate other mappings that target the centers of strings. For example, the constraint AllFeet-Right (Hyde, 2008, 2012, 2016) penalizes )…σ subsequences that occur within a prosodic word. By restricting its application to a given prosodic word, AllFeet-Right is similar to but distinct from penalizing )…σ… ] subsequences. As discussed in section 1, this constraint pulls monosyllabic feet to the right edge of prosodic words, and as the tableau in Table 4 illustrates, it also balances the size of multiple prosodic words. All the candidates in this tableau are parsed into two prosodic words and are exhaustively footed. To save space, constraints that enforce these conditions are omitted. The violations of AllFeet-Right decrease as the difference in size between the two prosodic words decreases, and candidate (4l) is returned as output. In practice, prosodic words typically reflect morphosyntactic structure. However, because the constraints that enforce such correspondences are violable (such as the family of Match constraints; Selkirk, 2011), mappings like those illustrated in Table 4 are predicted to be possible.
/σσσσσσσσ/ . | AllFt-R . |
---|---|
a. [(σ)][(σ)(σσ)(σσ)(σσ)] | 0 + 12 = 12 |
b. [(σ)][(σσ)(σ)(σσ)(σσ)] | 0 + 11 = 11 |
c. [(σ)][(σσ)(σσ)(σ)(σσ)] | 0 + 10 = 10 |
d. [(σ)][(σσ)(σσ)(σσ)(σ)] | 0 + 9 = 9 |
e. [(σσ)][(σσ)(σσ)(σσ)] | 0 + 6 = 6 |
f. [(σ)(σσ)][(σ)(σσ)(σσ)] | 2 + 6 = 8 |
g. [(σ)(σσ)][(σσ)(σ)(σσ)] | 2 + 5 = 7 |
h. [(σ)(σσ)][(σσ)(σσ)(σ)] | 2 + 4 = 6 |
i. [(σσ)(σ)][(σ)(σσ)(σσ)] | 1 + 6 = 7 |
j. [(σσ)(σ)][(σσ)(σ)(σσ)] | 1 + 5 = 6 |
k. [(σσ)(σ)][(σσ)(σσ)(σ)] | 1 + 4 = 5 |
→ l. [(σσ)(σσ)][(σσ)(σσ)] | 2 + 2 = 4 |
/σσσσσσσσ/ . | AllFt-R . |
---|---|
a. [(σ)][(σ)(σσ)(σσ)(σσ)] | 0 + 12 = 12 |
b. [(σ)][(σσ)(σ)(σσ)(σσ)] | 0 + 11 = 11 |
c. [(σ)][(σσ)(σσ)(σ)(σσ)] | 0 + 10 = 10 |
d. [(σ)][(σσ)(σσ)(σσ)(σ)] | 0 + 9 = 9 |
e. [(σσ)][(σσ)(σσ)(σσ)] | 0 + 6 = 6 |
f. [(σ)(σσ)][(σ)(σσ)(σσ)] | 2 + 6 = 8 |
g. [(σ)(σσ)][(σσ)(σ)(σσ)] | 2 + 5 = 7 |
h. [(σ)(σσ)][(σσ)(σσ)(σ)] | 2 + 4 = 6 |
i. [(σσ)(σ)][(σ)(σσ)(σσ)] | 1 + 6 = 7 |
j. [(σσ)(σ)][(σσ)(σ)(σσ)] | 1 + 5 = 6 |
k. [(σσ)(σ)][(σσ)(σσ)(σ)] | 1 + 4 = 5 |
→ l. [(σσ)(σσ)][(σσ)(σσ)] | 2 + 2 = 4 |
- (3)
AllFeet-Right: For every foot in a prosodic word, assign one violation for every syllable it precedes within the same prosodic word.
The balanced prosodic word mapping is defined in (4). Like the Midpoint Pathology, its application depends on identifying the center syllable, and its output language is homomorphic to anbn with an extra a or b. Thus, even though asymmetric alignment cannot target the center of a prosodic word, it can target the center of a string parsed into two prosodic words.
- (4)
Fbalanced : σi↦[(σσ)j(σ)k][(σσ)l(σ)m] where i = j + k + l + m, k ≤ 1, m ≤ 1, and j = l
The mappings in this section depend on the same underlying mechanism: divide a string of syllables into two parts, and minimize the subsequences of at least length 2 that occupy each part. This reduces the difference in size between the two parts to at most one syllable. With the Midpoint Pathology, the two parts are defined by syllables that precede the stressed syllable and syllables that follow the stressed syllable. With balanced prosodic words, the two prosodic words define the parts. This mechanism is independent of the subsequences themselves, provided that they are at least of length 2. Thus, restricting which subsequences a constraint can penalize can only block specific mappings. No restrictions on the set of subsequences prevents them from dividing strings in half. This is proved formally at the end of section 3. The mappings in this section only divided strings into two equal parts, generating context-free languages. The next section presents mappings that divide strings into three or more equal parts, generating non-context-free languages.
3 Violable Subsequence Constraints Can Divide Strings into Arbitrarily Many Equally Sized Parts
As the previous section demonstrated, subsequence constraints can be used to divide strings into two equal parts, generating context-free languages. Parsing strings into more than two equal parts generates non-context-free languages. With balanced prosodic words, this follows from parsing a string of syllables into more than two prosodic words. This can be motivated by hierarchical prosodic structure (Nespor and Vogel, 1986; Selkirk, 1984), rather than stipulated arbitrarily. Figure 3 illustrates a standard five-level prosodic hierarchy, where prosodic words are dominated by phonological phrases, which are dominated by an intonational phrase. By requiring these top two levels to dominate exactly two daughter nodes, the string of syllables is parsed into four prosodic words. Note that because this hierarchy is finite, it can be represented by a finite-state grammar (Yu, 2019).
As expected, AllFeet-Right has two effects on strings parsed into four prosodic words. First, in odd-parity prosodic words, the monosyllabic foot appears at the right edge. Second, no two prosodic words differ in size by more than one syllable. The tableau in Table 5 illustrates these effects with a fourteen syllable string. A large number of candidates are omitted to reduce the size of this tableau. These include candidates with more or fewer than four prosodic words, and candidates where monosyllabic feet do not surface at the right edge of their prosodic word. It can be verified that those candidates incur more violations of AllFeet-Right, as in Tables 1 and 4. The other omitted candidates are identical to the presented candidates, except with their prosodic words in another order. For example, the candidate chosen as output (5v) represents a set containing six possible parses, which incur the same number of violations of AllFeet-Right.
/σσσσσσσσσσσσσσ/ . | AllFeet-Right . |
---|---|
a. [(σ)][(σ)] [(σ)] [(σσ)(σσ)(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 0 + 25 = 25 |
b. [(σ)][(σ)] [(σσ)] [(σσ)(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 0 + 20 = 20 |
c. [(σ)][(σ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 1 + 16 = 17 |
d. [(σ)][(σ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 2 + 12 = 14 |
e. [(σ)][(σ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 4 + 9 = 13 |
f. [(σ)][(σ)] [(σσ)(σσ)(σσ)] [(σσ)(σσ)(σσ)] | 0 + 0 + 6 + 6 = 12 |
g. [(σ)][(σσ)] [(σσ)] [(σσ)(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 0 + 16 = 16 |
h. [(σ)][(σσ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 1 + 12 = 13 |
i. [(σ)][(σσ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 2 + 9 = 11 |
j. [(σ)][(σσ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σσ)] | 0 + 0 + 4 + 6 = 10 |
k. [(σ)][(σσ)(σ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 1 + 1 + 9 = 11 |
l. [(σ)][(σσ)(σ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)] | 0 + 1 + 2 + 6 = 9 |
m. [(σ)][(σσ)(σ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σ)] | 0 + 1 + 4 + 4 = 9 |
n. [(σ)][(σσ)(σσ)] [(σσ)(σσ)] [(σσ)(σσ)(σ)] | 0 + 2 + 2 + 4 = 8 |
o. [(σσ)][(σσ)] [(σσ)] [(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 0 + 12 = 12 |
p. [(σσ)][(σσ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 1 + 9 = 10 |
q. [(σσ)][(σσ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)] | 0 + 0 + 2 + 6 = 8 |
r. [(σσ)][(σσ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σ)] | 0 + 0 + 4 + 4 = 8 |
s. [(σσ)][(σσ)(σ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)] | 0 + 1 + 1 + 6 = 8 |
t. [(σσ)][(σσ)(σ)] [(σσ)(σσ)] [(σσ)(σσ)(σ)] | 0 + 1 + 2 + 4 = 7 |
u. [(σσ)(σ)][(σσ)(σ)] [(σσ)(σ)] [(σσ)(σσ)(σ)] | 1 + 1 + 1 + 4 = 7 |
→ v. [(σσ)(σ)][(σσ)(σ)] [(σσ)(σσ)] [(σσ)(σσ)] | 1 + 1 + 2 + 2 = 6 |
/σσσσσσσσσσσσσσ/ . | AllFeet-Right . |
---|---|
a. [(σ)][(σ)] [(σ)] [(σσ)(σσ)(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 0 + 25 = 25 |
b. [(σ)][(σ)] [(σσ)] [(σσ)(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 0 + 20 = 20 |
c. [(σ)][(σ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 1 + 16 = 17 |
d. [(σ)][(σ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 2 + 12 = 14 |
e. [(σ)][(σ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 4 + 9 = 13 |
f. [(σ)][(σ)] [(σσ)(σσ)(σσ)] [(σσ)(σσ)(σσ)] | 0 + 0 + 6 + 6 = 12 |
g. [(σ)][(σσ)] [(σσ)] [(σσ)(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 0 + 16 = 16 |
h. [(σ)][(σσ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 1 + 12 = 13 |
i. [(σ)][(σσ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 2 + 9 = 11 |
j. [(σ)][(σσ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σσ)] | 0 + 0 + 4 + 6 = 10 |
k. [(σ)][(σσ)(σ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 1 + 1 + 9 = 11 |
l. [(σ)][(σσ)(σ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)] | 0 + 1 + 2 + 6 = 9 |
m. [(σ)][(σσ)(σ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σ)] | 0 + 1 + 4 + 4 = 9 |
n. [(σ)][(σσ)(σσ)] [(σσ)(σσ)] [(σσ)(σσ)(σ)] | 0 + 2 + 2 + 4 = 8 |
o. [(σσ)][(σσ)] [(σσ)] [(σσ)(σσ)(σσ)(σσ)] | 0 + 0 + 0 + 12 = 12 |
p. [(σσ)][(σσ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)(σ)] | 0 + 0 + 1 + 9 = 10 |
q. [(σσ)][(σσ)] [(σσ)(σσ)] [(σσ)(σσ)(σσ)] | 0 + 0 + 2 + 6 = 8 |
r. [(σσ)][(σσ)] [(σσ)(σσ)(σ)] [(σσ)(σσ)(σ)] | 0 + 0 + 4 + 4 = 8 |
s. [(σσ)][(σσ)(σ)] [(σσ)(σ)] [(σσ)(σσ)(σσ)] | 0 + 1 + 1 + 6 = 8 |
t. [(σσ)][(σσ)(σ)] [(σσ)(σσ)] [(σσ)(σσ)(σ)] | 0 + 1 + 2 + 4 = 7 |
u. [(σσ)(σ)][(σσ)(σ)] [(σσ)(σ)] [(σσ)(σσ)(σ)] | 1 + 1 + 1 + 4 = 7 |
→ v. [(σσ)(σ)][(σσ)(σ)] [(σσ)(σσ)] [(σσ)(σσ)] | 1 + 1 + 2 + 2 = 6 |
This quartering mapping is defined in (5). The language it generates is homomorphic to the context-sensitive stringset anbncndn with allowances for an extra a, b, c, or d.
- (5)
Fquarter : σi↦[(σσ)j(σ)k][(σσ)l(σ)m][(σσ)n(σ)o][(σσ)p(σ)q] where i = j + k + l + m + n + o + p + q, k ≤ 1, m ≤ 1, o ≤ 1, q ≤ 1, and j = l = n = p
As noted in the previous section, AllFeet-Right is distinct from a constraint that penalizes )…σ subsequences. In particular, because it is restricted to subsequences within prosodic words, it undercounts when multiple prosodic words are parsed, as Figure 4 illustrates. The next case study demonstrates that this property is irrelevant to the generative capacity of OT with subsequence constraints.
To that end, consider the constraint *X…X defined in (6). *X…X is a non-local variant of *Geminate that penalizes subsequences of length 2 whose constituent segments are identical. It has not been proposed as a serious phonological constraint, but rather as supporting evidence for this paper’s result. Unlike AllFeet-Right, there are no restrictions on which subsequences it evaluates.
- (6)
*X…X: Assign one violation for every subsequence α…β where α = β.
The tableau in Table 6 illustrates the effect of this constraint on non-local liquid dissimilation. In this example, the class of liquid consonants comprises only alveolar laterals and rhotics, and the constraint Ident(lateral) penalizes changing one into the other. The input contains eight laterals (6a). The candidates shown are derived by changing underlying laterals into rhotics (6b–e). As in Table 5, permutations of these strings incur equal numbers of violations. This tableau demonstrates that as the difference in the number of laterals and rhotics decreases, so does the number of violations of *X…X. Any string with four laterals and four rhotics is returned as output (6e).
/llllllll/ . | *X…X . | Ident(lateral) . |
---|---|---|
a. llllllll | 28 + 0 = 28 | |
b. lllllllr | 21 + 0 = 21 | 1 |
c. llllllrr | 15 + 1 = 16 | 2 |
d. lllllrrr | 10 + 3 = 13 | 3 |
→ e. llllrrrr | 6 + 6 = 12 | 4 |
/llllllll/ . | *X…X . | Ident(lateral) . |
---|---|---|
a. llllllll | 28 + 0 = 28 | |
b. lllllllr | 21 + 0 = 21 | 1 |
c. llllllrr | 15 + 1 = 16 | 2 |
d. lllllrrr | 10 + 3 = 13 | 3 |
→ e. llllrrrr | 6 + 6 = 12 | 4 |
This mapping is defined in (7). Its output language is context-free, and homomorphic to permutations of anbn with the usual allowance of an additional a or b.
- (7)
Fliquid : {l,r}i↦{l,r}i where the difference between the number of laterals and rhotics is not greater than 1.
To generate a context-sensitive stringset with this constraint, one just has to consider a third segment type. The tableau in Table 7 on the next page illustrates this case with dissimilation targeting major place. Here, the segment inventory comprises voiceless stops specified as labial, coronal, or dorsal. The input is a string of nine labial stops (7a), and candidates derived from it by changing the place features are shown (7b–l). The constraint Ident(place) penalizes changes made to major place features. Unsurprisingly, as the differences between the numbers of each stop decrease, so do the violations of *X…X. The output is any string with three labial stops, three coronal stops, and three dorsal stops (7l).
/ppppppppp/ . | *X…X . | Ident(place) . |
---|---|---|
a. ppppppppp | 36 + 0 + 0 = 36 | |
b. ppppppppt | 28 + 0 + 0 = 28 | 1 |
c. ppppppptt | 21 + 1 + 0 = 22 | 2 |
d. ppppppttt | 15 + 3 + 0 = 18 | 3 |
e. ppppptttt | 10 + 6 + 0 = 16 | 4 |
f. ppppppptk | 21 + 0 + 0 = 21 | 2 |
g. pppppptkk | 15 + 0 + 1 = 16 | 3 |
h. ppppptkkk | 10 + 0 + 3 = 13 | 4 |
i. pppptkkkk | 6 + 0 + 6 = 12 | 5 |
j. pppppttkk | 10 + 1 + 1 = 12 | 4 |
k. ppppttkkk | 6 + 1 + 3 = 10 | 5 |
→ l. ppptttkkk | 3 + 3 + 3 = 9 | 6 |
/ppppppppp/ . | *X…X . | Ident(place) . |
---|---|---|
a. ppppppppp | 36 + 0 + 0 = 36 | |
b. ppppppppt | 28 + 0 + 0 = 28 | 1 |
c. ppppppptt | 21 + 1 + 0 = 22 | 2 |
d. ppppppttt | 15 + 3 + 0 = 18 | 3 |
e. ppppptttt | 10 + 6 + 0 = 16 | 4 |
f. ppppppptk | 21 + 0 + 0 = 21 | 2 |
g. pppppptkk | 15 + 0 + 1 = 16 | 3 |
h. ppppptkkk | 10 + 0 + 3 = 13 | 4 |
i. pppptkkkk | 6 + 0 + 6 = 12 | 5 |
j. pppppttkk | 10 + 1 + 1 = 12 | 4 |
k. ppppttkkk | 6 + 1 + 3 = 10 | 5 |
→ l. ppptttkkk | 3 + 3 + 3 = 9 | 6 |
The mapping is defined in (8); it generates a language homomorphic to permutations of anbncn, with one additional a, b, or c.
- (8)
Fplace : {p,t,k}i↦{p,t,k}i where the difference between any two sets of stops defined by place is not greater than 1.
*X…X has the same effect as constraints like AllFeet-Right: it divides the string into a fixed number of parts, and requires those parts be as similar to each other in size as possible by penalizing their subsequences. *X…X differs only in that it does not require that the subparts form contiguous substrings.
The mappings in this section demonstrated constraints over subsequences dividing strings into a fixed number of groups of equal size. In all cases, if the groups were not exactly equal, they could differ by at most one element. This generalizes to strings of all lengths and all numbers of groups: minimizing the difference between group sizes minimizes the number of violating subsequences. Before presenting a proof of this result, it is necessary to establish that subsequences of length 2 grow quadratically in a string’s length, in particular, a string of length n has subsequences of length 2. As a base case, a string of length 2 has 1 such subsequence: . Inductively, assume that a string of length n has subsequences of length 2. Adding one segment adds n subsequences of length 2, and it can be verified that . The proof of the main result of this paper follows.
This proves that violable constraints in Optimality Theory that penalize subsequences of length 2 can divide any length input into a fixed number of equally sized parts, generating context-sensitive stringsets.
4 Conclusion
Optimality Theory is known to generate non-finite state mappings and languages (Eisner, 1997; Frank and Satta, 1998), even with constraints defined over strings (Riggle, 2004; Gerdemann and Hulden, 2012; Heinz and Lai, 2013; Hao, 2019; Lamont, 2019a, b). This paper contributes to this literature by demonstrating that constraints over subsequences generate context-sensitive languages under optimization. This result has wide-ranging impacts for the field of phonology, as a number of commonly employed constraint types are defined over subsequences.
Acknowledgments
This paper has been greatly improved by three anonymous reviewers for TACL and through conversations with Jeffrey Heinz, Brett Hyde, Neil Immerman, and Brandon Prickett. I am especially grateful to Chris Coscia for his guidance on mathematical notation and structuring the proof. All remaining errors are of course my own.
Notes
Trivially, all strings of length 1 are subsequences. In this paper, subsequences refer to subsequences of length ≥ 2.