This article considers chain effects in Kurpian. It is observed that initial i triggers j-Insertion. The inserted [j] induces a lowering process, whereby /i/ changes into [e] or [ə], depending on the context. This change destroys the original trigger of j-Insertion, making the process opaque, as in jënteres ‘interest’ that exhibits the following chain: i → ji → jə . The chain shows that j-Insertion is not apparent from the surface form because //i//, the trigger, has been changed to schwa, which cannot induce j-Insertion. I argue that chain effects cannot be modeled in Standard Optimality Theory (OT, hereafter) and that they constitute evidence for derivational levels envisaged by Derivational Optimality Theory. In particular, insertion must take place before /i/ is turned into [e] or [ə] because j-Insertion cannot apply before mid vowels.
Section 1 lays out the necessary background facts. Section 2 inspects the data and offers descriptive generalizations. Section 3 provides a formal analysis of these generalizations. Section 4 considers non-derivational alternatives: Max Feature theory, Sympathy theory and Candidate Chains theory. Section 5 concludes with a summary of the results.
1 Background
Kurpian is a dialect of Polish spoken in the northern part of the Mazovia province, about 120 kilometers north of Warsaw. The Kurpian community numbers some 70,000 people. Only the oldest generation (70 years old and older) speaks the dialect natively. The younger generations are making an effort to preserve and revitalize their language. The endeavor has much success, of which the most noteworthy is the introduction of Kurpian courses in some schools of the region.
The literature on Kurpian is minimal. It is limited to brief mentions in books on Polish dialectology, such as Zduńska (Reference Zduńska1965) and Dejna (Reference Dejna1973). A more extensive study of Kurpian, that of Friedrich (Reference Friedrich1955), is written in the traditional methodology of the 1930s, which is when the research was conducted. Friedrich perished in the Second World War and the book was published posthumously in 1955. The recent work on Kurpian is that of Rubach (Reference Rubach2009, Reference Rubach2011a, Reference Rubach2014a, Reference Rubachb). While Rubach’s papers discuss various aspects of Kurpian phonology, they do not even mention the phonological processes presented in this article. The data reported here all come from my fieldwork conducted in the villages of central KurpiaFootnote [2] over the period of the past ten years.
Rubach (Reference Rubach2011a) has shown that Kurpian has a system of vowels richer than does Standard Polish.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU1.png?pub-status=live)
In terms of distinctive features, Kurpian vowels can be characterized as in (2).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU2.png?pub-status=live)
The feature [±tense] is used here in the way defined by Wood (Reference Wood1975), who relates this feature to a degree of constriction in the regions of hard palate, soft palate, pharynx and lower pharynx. This means that upper high, upper mid and back retracted low vowels are [+tense]. Thus, the difference between Standard Polish [i ɨ] and Kurpian is characterized as an opposition between tense and lax high vowels.
Kurpian orthography, the system proposed by Rubach (Reference Rubach2009), is closely phonetic. It has a few letters that are either unknown in Standard Polish or represent sounds that do not occur in Standard Polish. Here are the main features and examples of Kurpian orthography:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU4.png?pub-status=live)
Let us add that prepalatals [ɕ ʑ tɕ dʑ ɲ] are always written with an accent in Kurpian, so śïwy ‘gray’, śano [ɕanɔ] ‘hay’, źïma [ʑɪma] ‘winter’, źarno [ʑarnɔ] ‘seed’, ćïchy
‘silent’, ćotka [tɕɔtka] ‘aunt’, dźådek [dʑɑdɛk] ‘grandpa’, dźïwny [dʑɪvnɨ] ‘strange’, and ńïska [ɲɪska] ‘bowl’, ńebo [ɲɛbɔ] ‘sky’.Footnote [5]
2 Generalizations
In Kurpian no word may begin with ï [ɪ]. The phonotactic generalization is that we find jï- where we would expect ï. We know that this ï comes from i historically. Also, we see it in Standard Polish, which is the main source language for borrowings into Kurpian.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU7.png?pub-status=live)
The generalization that ï is preceded by j word-initially, illustrated in (4a), is entirely exceptionless and extends to borrowings, as seen in (4b). Since the occurrence of [j] is predictable from the presence of ï [ɪ], the [j] is derived by rule rather than present in the underlying representation. Schematically, the rule is presented in (5).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU8.png?pub-status=live)
The motivation for j-Insertion is particularly clear in Optimality Theory: Onset, a constraint militating against onsetless syllables, drives j-Insertion forcing [ɪ] to spawn [j], so that the initial syllable has an onset.Footnote [6]
Let us consider [ɪ] as the trigger of j-Insertion. The situation is untypical because normally it is tense [i] rather than lax [ɪ] that triggers j-Insertion (see Rubach (Reference Rubach2000a)). Evidence from both alternations and the adaptation pattern for borrowings shows that the ï which triggers j-Insertion, seen in (6a–b), subsequently lowers to tense [e], illustrated in (6b).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU9.png?pub-status=live)
The details of the lowering process, in particular, the context in which it occurs, are complex, so they will be discussed later. For the moment, let us assume that there is a dissimilation constraint that prohibits [j] followed by a high front vowel and [r], schematically *jir/jɪr. Ranked above Ident[+high], *jir/jɪr enforces the change from a high vowel to a mid vowel. Let us see how this enforcement works in OT. The following constraints play a role in the lowering process:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU10.png?pub-status=live)
In (8) below I look at a formal evaluation of Jérka ‘Irene (dimin)’. I ignore the problem of where [j] comes from and focus on the vowel. The alternating vowels are lax ï [ɪ] in Jïrëna ‘Irene’ and tense é [e] in Jérka. Since we know that [e] is the product of Post-glide Dissimilation, it is [ɪ], not [e], that must be the underlying vowel. Assuming for the sake of argument that //j//Footnote [8] is present in the underlying representation, the input to the evaluation is //jɪrk+a//.Footnote [9] The undesired winner is indicated by the left-pointing hand ☜. The icon ☹ marks the desired winner that has lost in the evaluation.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU11.png?pub-status=live)
The result is incorrect as [jɛrka] with lax [ɛ] rather than [jerka] with tense [e] wins in the evaluation. Notice that there is no way of repairing the evaluation by manipulating the ranking of the constraints because [jerka], the desired winner, has a superset of the violations of [jɛrka], the wrong winner. At this point one could wonder if an additional constraint could help. This additional constraint would need to ban candidate (8d), hence the configuration [jɛr]. The problem is that the option of postulating *jɛr as a new constraint is not available in Kurpian because [jɛr] is a perfectly well-formed concatenation, as shown by ńïźïjersky ‘engineer (Adj)’, fryzjersky
‘courier (Adj)’. If postulating *jɛr is not an option, the wrong winner in (8d) is a problem.
The architecture of OT is based on the assumption that the winner is the candidate that satisfies the markedness constraints by minimally violating the faithfulness constraints. That is, the winner must execute the least costly repair. Given the input //jɪr// and the prohibition on *jir/jɪr, the least costly repair is to change //ɪ// to [ɛ] because the input //ɪ// and the output [ɛ] are both lax vowels. The change //jɪr// → [jer], in addition to lowering the vowel (//jɪr// → [jɛr]) makes another alteration: a lax vowel is transformed into a tense vowel, //ɪ// → [e]. This additional alteration is unwarranted from the point of view of satisfying *jir/jɪr, so candidate (8e), [jerka], loses to candidate (8d), [jɛrka] – the wrong result.
The solution to the problem lies not in the constraint system but with the underlying representation. If we assume that the input vowel is tense, that is //i// rather than //ɪ//, then, by the logic outlined above, the optimal output must also be tense, so [e] rather than [ɛ], because i → e, but not i → ɛ, obeys Ident[+tense] (the value [+tense] of the input //i// is preserved in the output [e]). Tableau (8) is now replaced with tableau (9). The right-pointing hand denotes the correct winner.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU15.png?pub-status=live)
The result is correct. I conclude that the input vowel must be tense //i// and not lax //ɪ//. This brings up a general question of whether Kurpian should admit in its inventory of underlying vowels both //i// and //ɪ//. The postulation of //i// entails the postulation of Laxing i → ɪ because, for example, Jïrëna ‘Irene’ now derives from //irɛn+a//Footnote [11] with //i//, so i → ɪ is necessary in order to reflect the correct surface representation. Laxing i → ɪ can be generalized to non-round high vowels, yielding the following rule:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU16.png?pub-status=live)
This generalization produces an inventory that is not only plausible and typical but also natural because now Kurpian has the system in (11a) rather than the implausible system in (11b)
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU17.png?pub-status=live)
In this analysis, the laxness of Kurpian high vowels is a phonetic detail. From the phonological point of view, specifically, from the point of view of interaction of phonological generalizations, Kurpian has tense //i ɨ//. The surface lax are derived by the Laxing rule in (10).Footnote [12]
The analysis just suggested cannot be conducted in the framework of Standard Optimality Theory that is founded on the principle of strict parallelism prohibiting any form of derivation (McCarthy & Prince Reference McCarthy, Prince, Beckman, Dickey and Urbanczyk1995, Prince & Smolensky Reference Prince and Paul2004). Essential for the analysis is the distinction of derivational levels: at an early level the vowels are tense, so the optimal outputs have /i ɨ/; Laxing sets in at a later level. This mode of phonological processing is exactly what Derivational Optimality Theory predicts. I return to the details of the analysis in Section 3 below.
If the high vowels are tense, the operation of j-Insertion has /i/, not /ɪ/, as its context, so the statement in (6) is now replaced by the statement in (12).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU19.png?pub-status=live)
Postg-lide Dissimilation stated provisionally in (7a) requires more work. The objective is to determine the context in which dissimilation, i → e, takes place. We know from the data in (4) that [ji-]Footnote [13] is the attested output in many Kurpian words, so the i → e process cannot be context-free.
A comparison of the examples in (4) and (6) leads to the following observation: underlying //i// survives in the surface representation before an obstruent, as in jïzba ‘room’ (see the examples in (4) above). If the following segment is r, as in (6), underlying //i// surfaces sometimes as [i] (or rather [ɪ], an effect of Laxing) and sometimes as [e] as in Jïrena ‘Irene’ versus Jérka (dimin) and jércha ‘deerskin’. This pattern is strengthened by the following examples:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU20.png?pub-status=live)
While all the examples in (13) contain a liquid after //i//, only the //i// in (13b) surfaces as [e]. A comparison of (13a) and (13b) shows that i → e occurs if the liquid is followed by a consonant. This observation can be refined to say that i → e occurs in closed syllables because Kurpian syllabification follows the expected pattern of respecting sonority relations among neighboring segments.Footnote [14] The data in (14) below show intermediate forms (hence slashes rather than square brackets): after syllabification but before j-Insertion and the lowering /i/ → [e]. Dots mark syllable boundaries.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU21.png?pub-status=live)
To conclude this part of the discussion, Post-glide Dissimilation, i → e, takes place in closed syllables.
A pattern very much like that in (13) is found with //i// that is followed by a nasal.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU22.png?pub-status=live)
While all the examples exhibit j-Insertion, those in (15b) show a further change: //i// → [ə], which occurs before a nasal consonant. The nasal consonant is in the coda, so the syllable is closed.Footnote [15]
The patterns in (15) and (14) above are strikingly similar: in both cases we have high vowel inputs that are lowered to mid vowels and the lowering occurs in a closed syllable. The question is why the product of lowering in (15) is ë [ə] rather than é [e], as in (14). The answer to this query is found in Rubach (Reference Rubach2011a), who postulates the rule of Nasal Backing.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU23.png?pub-status=live)
Nasal Backing is an exceptionless rule that is supported by both phonotactics and alternations. The phonotactic generalization is that neither [ɛ] nor [e] can ever be found before a nasal, as exemplified in (17a). Direct evidence for Nasal Backing comes from alternations such as those in (17b).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU24.png?pub-status=live)
The scenario for the data in (15) is now clear: Post-glide Dissimilation familiar from the data in (13) changes //i// to /e/ in closed syllables: /jintɛrɛs/ → /jentɛrɛs/ ‘interest’. The occurrence of e before a nasal triggers Nasal Backing, which takes /e/ to [ə]: /jentɛrɛs/ → [jəntɛrɛs].
Now let us return to the statement of Post-glide Dissimilation. It has been shown thus far that the process works in closed syllables, so in jércha ‘deerskin’ and jënteres ‘interest’ but not in jïrys ‘iris’ and jïńë ‘name’. This statement is sharpened by the inspection of jïść [jɪɕtɕ] ‘go’, whose syllable begins with [j], as in jércha ‘deerskin’ and jënteres ‘interest’, and yet the dissimilation changing //i// to a mid vowel does not occur. The relevant difference between jércha ‘deerskin’ and jënteres ‘interest’, on the one hand, and jïść [jɪɕtɕ] ‘go’, on the other, is the type of consonant that constitutes the coda: a sonorant versus an obstruent. Dissimilation occurs if the syllable is closed by a sonorant:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU25.png?pub-status=live)
We have assumed without argument that the lowering of //i// to a mid vowel occurs after /j/, but is this assumption necessary? The answer is affirmative because there is no lowering in words such as those in (19).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU26.png?pub-status=live)
These words have syllables closed by a sonorant. What they do not have is /j/ before the vowel and there is no lowering. I conclude that the presence of /j/ is a necessary condition for lowering. The generalization that I call Post-glide Dissimilation can be stated informally as follows:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU27.png?pub-status=live)
That is, //i// is lowered to tense /e/ after /j/ in a syllable closed by a sonorant.
It should be noted that the process is entirely productive. We see it massively at work with borrowings from Standard Polish into Kurpian. The pattern of adaptation is regular and follows from Post-glide Dissimilation. For example, the newly borrowed noun internet ‘internet’ is consistently rendered as [jəntɛrnɛt], so it should be written jënternet.
The final descriptive issue to address is the provenance of j in the data, which was informally expressed in (12) as j-Insertion. The important point is that [j] is derived by rule rather than present in the underlying representation. The rule is entirely exceptionless and productive. It is so pervasive that it sometimes causes interference when Kurpians speak Standard Polish, so [jidʑɛ] ‘he goes’ instead of the Standard Polish [idʑɛ]. If j is not present in the underlying representation, then an informal derivation of jércha ‘deerskin’ and jënteres ‘interest’ is as follows:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU28.png?pub-status=live)
Even though the particular steps in the derivation make sense, the procedure as a whole is perplexing. The reason is that the trigger of j-Insertion, the tense vowel /i/, is not present in the surface representation, so we witness opacity.
The question is whether this opacity could be eliminated by making j-Insertion sensitive not to /i/ but to mid vowels. The answer is negative, as the following data show.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU29.png?pub-status=live)
These data document that front mid vowels do not trigger j-Insertion, which means that the process is limited to the context of i, a highly natural limitation. The scenario in (21) is therefore correct: /j/ must be inserted prior to changing //i// into a mid vowel. However, from a general perspective, the scenario in (21) is perplexing since we witness a chain of destructive events: //i// spawns /j/ and then /j/ destroys its benefactor because /i/ is eliminated by Post-glide Dissimilation, whose crucial context is the occurrence of /j/. In the case of a following nasal, the destruction is deepened by one further step: /e/ is turned into [ə]. The question is how these chain effects can be modeled in OT. Answering this question is the goal of the following section.
3 Formal analysis
In preparation for a formal OT analysis, let us introduce the constraints that can potentially play a role in the evaluation of the data discussed in the preceding section. From an OT perspective, the insertion of [j] in words beginning with //i// is driven by Onset.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU30.png?pub-status=live)
Insertion in word-initial position violates Align-L in addition to violating the general anti-insertion constraint Dep-Seg.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU31.png?pub-status=live)
Dep-Seg is straightforward because it prohibits insertion anywhere in the string. In contrast, Align-L is violated only by stem-initial insertion. This is so because insertion of a segment at the beginning of the stem, as in //izba// → [jizba] ‘room’, causes misalignment of the syllable and the stem: the initial syllable begins with [j] while the grammatical stem begins with [i], not with [j]. The reason is that //i// is the initial segment in the underlying representation, so we have misalignment and Align-L is violated.
Insertion inside words violates Dep-Seg, but not Align-L. Word-internal insertion of [j] in Kurpian works the same way as in Standard Polish (see Rubach Reference Rubach2007).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU32.png?pub-status=live)
Since we witness j-Insertion, the ranking of the constraints must be Onset >>Dep-Seg in both Standard Polish and Kurpian. The treatment of initial syllables is different because Kurpian permits j-Insertion while Standard Polish does not: [jizba] versus [izba] ‘room’. This difference is derived from a different ranking of the constraints, as the following tableaux show.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU33.png?pub-status=live)
The quality of /i/ in (26) is adjusted by Laxing, i → ɪ, at a later level of evaluation (see below).
The system of the constraints discussed thus far does not account for the fact that it is [j] rather than some other segment, for example, [t] that is inserted. Consequently, the candidate [tizba], not included in (26i), would be evaluated as just as good as the actually attested [jizba]. Intuitively, however, the insertion of [j] looks better than the insertion of [t]. The reason is that the phonetic content of [j], but not of [t], can be harvested from /i/. In fact, [j] is a copy of [i], the difference being that it occurs in the onset rather than in the nucleus. We can thus say that [j] is spawned by [i].
The implementation of spawning is based on the requirement that all features of the glide come from the vowel by spreading. It is the spreading imperative that distinguishes between [ji] and [ti]. The point is that the features of [t] cannot be spread from [i] because [i] does not have any of the features of [t], so there is nothing to spread. This is schematically represented in (27).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU34.png?pub-status=live)
Spreading is enforced by feature count (the fewer features the better) since the occurrence of a feature violates feature markedness constraints, such as *[$-$back] (don’t be [
$-$back]). The features that come from spreading are for ‘free’ because they already exist in the vowel, so no new occurrences of features are added. This is shown for the feature [+high] that is penalized by constraint (28). For example, in [ji], the configuration in (27i) and in candidate (29i-b), [+high] comes from the source vowel [i]. This is not true for [je] or [ja] because [e] and [a] do not contain the feature [+high], so there is nothing to spread. In (29i) below, I look at //i// → [ji] and in (29ii) at //e// → [je]. The addition of [+high] in (29ii-b) violates the feature markedness constraint against [+high].
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU35.png?pub-status=live)
Here and below I ignore Align-L and Dep-Seg, whose function was illustrated in (26).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU36.png?pub-status=live)
The feature [+high] in (29i-b) is shared with [i], so there is only one violation of *[+high], as in (29i-a).
Recall from (22) that Kurpian does not permit j-Insertion before e, so elekstryk ‘electrician’ is [ɛlɛkstrɨk] and not *[jɛlɛkstrɨk]. To achieve this result, we need to reverse the ranking in (29ii), so that a violation of *[+high] is evaluated as more serious than a violation of Onset. This ranking has no adverse effects on //i// → [ji], as in jizba ‘room’ in (30ii). In (30i), I look at the fragment //ɛlɛ// of //ɛlɛkstrɨk//.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU37.png?pub-status=live)
In (30ii), //izba// → [jizba], the candidates tie on *[+high], since they both contain [i], which is [+high]. Candidate (30ii-a), [izba], additionally violates Onset and hence loses. Finally, the question is whether the system of the constraints developed thus far would not have adverse effects on je concatenations that come from the underlying representation, such as in jeść ‘eat’. The answer appears to be that it would have an adverse effect on jeść and the like since the ranking *[+high] >> Onset would favor the candidate eść over the faithful jeść. However, there is no danger that the undesired candidate eść could win. The reason is that eść has deleted the input segment j. Deletion is penalized by Max-Seg so if Max-Seg is ranked sufficiently high, the candidate eść is doomed and will never win – the correct result.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU38.png?pub-status=live)
Further, the features of //j// in jeść should not be altered, for example, /j/ should not become a mid [$-$high] glide in order to satisfy *[+high]. Such unwanted changes are thwarted by Ident constraints that mandate the preservation of the input features in the output candidates, here Ident[+high]. The ranking Ident[+high] >>*[+high] ensures that the [+high] feature that comes from the underlying representation is faithfully preserved in the optimal candidate. In sum, the ranking of the constraints is Ident[+high] >>*[+high] >>Onset.
Returning to Post-glide Dissimilation. Its statement as a constraint mirrors the schematic statement as a rule in (20).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU39.png?pub-status=live)
Kurpian satisfies *jiSon) $_{\unicode[STIX]{x1D70E}}$ by lowering the vowel, //i// → /e/, as in jércha ‘deerskin’, //irxa// → /jirxa/ → [jerxa]. There are, however, other imaginable strategies to comply with *jiSon)
$_{\unicode[STIX]{x1D70E}}$. For example, //i// could be changed to [u], so /irxa// → /jirxa/ → [jurxa]. This candidate will not win if Ident[
$-$round] stated in (7c) is ranked sufficiently high. Similar other candidates are excluded by other Ident constraints, so there is no need to illustrate these options here.
Post-glide Dissimilation as a constraint is not as odd as it might appear to be at first glance. Kawasaki (Reference Kawasaki1982) observes that many languages avoid [ji] syllables since they are hard from the point of view of perception. Rubach (Reference Rubach1998) translates this observation into OT by postulating Distinct Glide as a constraint. It prohibits not only [ji] but also [wu], requiring that the glide cannot be a copy of the vowel. Post-glide Dissimilation *jiSon) $_{\unicode[STIX]{x1D70E}}$ is an instantiation of Distinct Glide. What it prohibits is not just any occurrence of [ji] but the occurrence of [ji] in a certain context. The context is that of a syllable closed by a sonorant. Thus, *jiSon)
$_{\unicode[STIX]{x1D70E}}$ can be regarded as an expansion of the generic *ji constraint. The generic *ji plays no role in Kurpian, which means that it is bottom-ranked. In contrast, *jiSon)
$_{\unicode[STIX]{x1D70E}}$ is ranked high (see below) as it drives lowering, //i// → [e]. The relation between *ji and *jiSon)
$_{\unicode[STIX]{x1D70E}}$ is typical for a family of constraints: the specific constraint is predictably ranked higher than the generic constraint.
Kurpian chain effects cannot be modeled in Standard OT, as the following reasoning explains. The founding principle of Standard OT is strict parallelism, which prohibits postulating derivational levels. This principle is a problem, as the evaluation of jënteres ‘interest’ documents.Footnote [16]
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU40.png?pub-status=live)
Onset must outrank Dep-Seg-Seg, so that j-Insertion can have an effect. We know from the discussion of jeść ‘eat’ and the evaluation of elekstryk ‘electrician’ in (30) that the ranking is Ident[+high] >>*[+high] >>Onset. We also know that the desired response to *jiSon) $_{\unicode[STIX]{x1D70E}}$ is lowering, so *jiSon)
$_{\unicode[STIX]{x1D70E}}$ must outrank Ident[+high]. This ranking eliminates candidate (33c), [jin.tɛ.rɛs]. Ident[+high] excludes also candidate (33b), [ən.tɛ.rɛs], and candidate (33d), [jən.tɛ.rɛs]: these candidates have lowered //i// to [ə], so the [+high] feature of the input //i// has not been preserved. The remaining candidate, (33a), [in.tɛ.rɛs], wins in the evaluation – the wrong result. I conclude that Standard OT fails because it cannot generate the attested surface form.
The solution to the conundrum is readily available in Derivational Optimality Theory. This theory, proposed by Kiparsky (Reference Kiparsky1997), Rubach (Reference Rubach and Roca1997),Footnote [17] and Bermúdez-Otero (Reference Bermúdez-Otero1999), rejects the principle of strict parallelism and assumes that the phonological component of the grammar contains derivational levels. Kiparsky (Reference Kiparsky2000) proposes three such levels: the stem level, the word level and the post-lexical level (sentence level). Rubach (Reference Rubach2011b) extends this model by adding the clitic level placed between the word level and the post-lexical level, so altogether there are four levels in Derivational OT. Levels constitute miniphonologies: the constraints are the same at all levels, but their ranking may be different because ranking is specific to a level.
For the analysis at hand, a Derivational OT scenario can be constructed as follows. At Level 1, the grammar generates the glide /j/. Importantly, underlying //i// surfaces in the optimal candidate at this level, so that spawning executed by Ident[+high] >>*[+high] is an available mechanism: //irxa// → /jirxa/
‘deerskin’ and //intɛrɛs// → /jintɛrɛs/
‘interest’. For underlying //i// to be present in the optimal output at Level 1, *jiSon) $_{\unicode[STIX]{x1D70E}}$ must be ranked below Ident[+high]. This ranking is reversed at Level 2, so lowering, i → e, is the preferred option. We see [e] in the final output of ircha ‘deerskin’: /jirxa/ → [jerxa]. In the case of jënteres ‘interest’, the optimal candidate must additionally undergo Nasal Backing formulated as a rule in (16), as [ə] and not [e] is the attested surface vowel: /jintɛrɛs/ → /jentɛrɛs/ → [jəntɛrɛs], where both changes are effected at the same level.
Expressed in terms of OT, Nasal Backing in (16) is the following constraint:
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU41.png?pub-status=live)
The implementation of NB violates Ident[$-$back].
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU42.png?pub-status=live)
For NB to have an effect, the ranking must be NB >>Ident[$-$back].
We are now ready to look at a complete analysis of representative examples that document two different responses to *jiSon) $_{\unicode[STIX]{x1D70E}}$: lowering to [e], ircha //irx+a// → [jerxa] ‘deerskin’, and lowering cum backing to schwa, jënteres //intɛrɛs// → [jəntɛrɛs] ‘interest’.
To save space, the tableaux in (36) show only these constraints that are relevant for the analysis. To keep the tableaux within manageable bounds, I omit the candidate that turns //i// into [u], that is, [urxa]. This candidate has no chance of winning because Ident[$-$round] is a surface-true and hence undominated constraint in Kurpian.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU43.png?pub-status=live)
The lowering to [ɛ], [ə] or [e] in candidates (36i-c, d) and (36ii-b, d, e) fatally offends Ident[+high]. The ranking Onset >>*jiSon) $_{\unicode[STIX]{x1D70E}}$ makes clear that [jir.xa] (36i-c) and [jin.tɛ.rɛs] (36ii-d) win over [ir.xa] (36i-a) and [in.tɛ.rɛs] (36ii-a), respectively.
For lack of space, the evaluation in (36ii) does not mention Nasal Backing and Ident[$-$back] because these constraints have no chance to play a role. For example, candidate (36ii-e), /jen.tɛ.rɛs/, violates NB but this candidate loses, regardless of how it fares on NB because it offends Ident[+high]. NB and Ident[
$-$back] are important at Level 2, as the analysis below shows.
The winners from Level 1, /jir.xa/ and /jin.tɛ.rɛs/, are now inputs to Level 2. Importantly, /j/ is present in the input, so candidates such as [ir.xa] and [in.tɛ.rɛs] that have deleted the input /j/ violate Max-Seg. At Level 2 Post-glide Dissimilation *jiSon) $_{\unicode[STIX]{x1D70E}}$ and Ident[+high] switch places, so dissimilation (lowering) is no more important than being faithful to
Ident[+high].
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU44.png?pub-status=live)
The evaluations now continue at Level 2. To keep the tableaux within manageable bounds, I omit constraints that are not relevant at Level 2, such as Dep-Seg.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU45.png?pub-status=live)
At Level 2 the input contains /j/, so the absence of /j/ in candidate (38c) is treated as deletion, a violation of Max-Seg. Ident[$-$round] eliminates [jur.xa] (38b) and [wir.xa] (38d) because the former has changed the input /i/ and /j/, which are [
$-$round], to [u] and [w], respectively, which are [+round]. *jiSon)
$_{\unicode[STIX]{x1D70E}}$ outlaws the faithful candidate [jir.xa] (38a), which has [ji] in a syllable closed by a sonorant. Of the two remaining candidates, [jɛr.xa] (38e) and [jer.xa] (38f), the latter preserves [+tense] from the input /i/ and hence wins, which is correct as [jer.xa] is the attested surface form.
Finally, we look at the evaluation of jënteres ‘interest’ at Level 2. The input is the winner from Level 1 /jin.tɛ.rɛs/.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU46.png?pub-status=live)
Candidate (39a), [jin.tɛ.rɛs], contains [ji] in a syllable closed by a sonorant (here by n), so it fails on Post-glide Dissimilation *jiSon) $_{\unicode[STIX]{x1D70E}}$. Candidate (39b) has deleted the glide and hence fails on Max-Seg, in addition to failing on Onset (not shown here). Candidates (39c), [jen.tɛ.rɛs], and (39d), [jɛn.tɛ.rɛs], have lowered /i/ to [e] and [ɛ], respectively, and thus avoid violating *jiSon)
$_{\unicode[STIX]{x1D70E}}$, but mid front vowels cannot appear before a nasal because they fatally violate Nasal Backing (NB). This is not true in candidate (39e), [jun.tɛ.rɛs], but this candidate has circumvented violating *jiSon)
$_{\unicode[STIX]{x1D70E}}$ by changing /i/ into [u], which is prohibited by Ident[
$-$round]. Candidate (39f), [jən.tɛ.rɛs], has changed /i/ to [ə], which violates Ident[
$-$back] and Ident[+tense] (schwa is a lax vowel) in addition to violating Ident[+high], but these constraints are low-ranked, so [jən.tɛ.rɛs] wins in the evaluation. This is correct because [jən.tɛ.rɛs] is the attested surface form.
4 Non-derivational alternatives
The JL referees for this paper ask that I show how the Kurpian data can be analyzed by invoking OT auxiliary theories that have been created with a view to account for opacity: Max Feature theory, Sympathy theory and OT Candidate Chains theory (OT-CC). The questions are intriguing because if these theories can produce a successful analysis, the Kurpian argument for Derivational OT falls. I begin with Max Feature theory. I repeat tableau (33), which has shown why Standard OT fails.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU47.png?pub-status=live)
Max Feature theory (Lombardi Reference Lombardi1998) accounts for opacity by mandating that a given feature of the input must be represented in the output. Max[F] is different from Ident[F], because, unlike Ident[F], it does not specify on which segment in the output the feature [F] must surface. To see the point, compare the statement of Ident[+high] and Max[+high] in (41).
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU48.png?pub-status=live)
As already noted, Max[+high] is satisfied by the occurrence of [+high] anywhere in the output. This is exactly what we need to enforce the occurrence of [j] in //intɛrɛs// → [jəntɛrɛs] in (40). As tableau (40) shows, Ident[+high] is violated by the mapping //i// → [ə]. The fact that [+high] occurs on [j] does not help because [ə], not [j], is the correspondent of //i//. Max[+high] produces the correct result: the candidate [jəntɛrɛs] wins over [əntɛrɛs] because the former, but not the latter, contains the feature [+high] in the output. I assume, arbitrarily, that Max[+high] is an undominated constraint. The ranking of the other constraints was motivated in Section 3 above, where I showed that mid vowels do not trigger j-Insertion, so elekstryk ‘electrician’, not *jelekstryk, is the attested surface form. To facilitate the evaluation of correspondence, the segments of the first syllable have been equipped with integers. Tableau (42) shows that Max[+high] can successfully enforce the occurrence of [j] before the mid vowel in (42c). This success is short-lived, however.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU49.png?pub-status=live)
Upon further scrutiny of the Kurpian data, it turns out that Max[+high] fails in a spectacular way. First, it cannot deliver the correct result for the data that contain an independent [+high] vowel. Second, it is unable to eliminate the undesired faithful candidate in (40a).
The words in (43) are examples of a typical pattern in Kurpian.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU50.png?pub-status=live)
The gen.sg forms as well as the diminutive forms satisfy Max[+high] in the wrong way: the [u] is [+high] and the [ɪ] is [+high, $-$back]. Max[+high] can no longer enforce the occurrence of [j] in the initial syllable, as shown by the evaluation of the diminutive form //intɛrɛs+ik// → [jəntɛrɛɕɪk].
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU51.png?pub-status=live)
Max[+high] is satisfied by the [ɪ] of the suffix [ɪk] and, consequently, [jə$_{1}$n
$_{2}$.tɛ.rɛɕɪk] (44c) that has two instances of [+high], on the [j] and on the [ɪ], loses to [ə
$_{1}$n
$_{2}$.tɛ.rɛɕɪk] (44a) – the wrong result.
The failure of Max[+high] is actually more fundamental than shown in (44). The theory cannot exclude the undesired faithful candidate (not shown in 44), so an evaluation employing Max[+high] is incorrect in the same way as the evaluation in (33) that did not appeal to any opacity theory.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU52.png?pub-status=live)
The result is incorrect. I conclude that Max[+high] or, more generally, Max[F] theory, is unable to account for Kurpian chain effects.
The hope for a solution to the conundrum now lies with Sympathy theory (McCarthy Reference McCarthy1999, Reference McCarthy, Féry and van de Vijer2002) and OT-CC (McCarthy Reference McCarthy2007). These theories take inspiration from derivation, even though they are, technically, non-derivational. Sympathy de facto recreates a derivational stage via a surrogate that is called a sympathetic base. OT-CC recreates rule ordering via a surrogate that is a class of Precedence (Prec) constraints. Prec constraints stipulate the order of violations in chains of output forms.
The idea of Sympathy theory is to give a privileged status to one of the candidates that thus becomes a sympathetic base. The privilege is that all other candidates compete on how similar they are to the sympathetic base. The winner is the candidate that best resembles the sympathetic base. Technically, the similarity is measured by the constraints called Cum (cumulativity) and Diff (differences). Cum requires that the candidate accumulate all the sympathetic base’s faithfulness violations. Once Cum has been satisfied, Diff records the number of additional faithfulness violations that a given candidate has beyond those that are shared with the sympathetic base. I will not go into the details of how Cum and Diff work because Sympathy theory fails even before we are in a position to look at the operation of Cum and Diff.
Cum and Diff set in at the point when the grammar has appointed one of the candidates as the sympathetic base. The appointment is made by a selector constraint. McCarthy (Reference McCarthy1999, Reference McCarthy, Féry and van de Vijer2002) assumes that the selector must be chosen from among faithfulness constraints. An associated assumption is that the sympathetic base cannot violate the selector.
Below I repeat the failed evaluation in (40) and treat it as a worksheet. The goal is to discover which faithfulness constraint would be the best to serve as the selector. In order to have a complete pool of constraints as candidates for the selector, I adduce all faithfulness constraints that interact in the evaluation,Footnote [20] even if they play no decisive role.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU53.png?pub-status=live)
The ranking Onset >>Dep-Seg ensures that the desired winner, [jən.tɛ.rɛs], inserts a [j], as required by the attested surface form. Let us now search for the selector.
Suppose we appoint Ident[+high] as the selector. Candidate (45b), [ən.tɛ.rɛs], and (45d), [jən.tɛ.rɛs] violate Ident[+high], so they cannot be considered in the race for the status of the sympathetic base.Footnote [21] Of the remaining candidates, [jin.tɛ.rɛs] (45c) loses to [in.tɛ.rɛs] (45a) because it fares worse on constraint violation. Consequently, [in.tɛ.rɛs] becomes the sympathetic base. This result is unacceptable because it forfeits the purpose: the whole point of appealing to various opacity theories of Standard OT is to find a way to eliminate [in.tɛ.rɛs] as the winner. Appointing [in.tɛ.rɛs] as the sympathetic base makes things worse because the sympathetic base by definition passes on the Sympathy theory’s constraints Cum and Diff, so the analysis would strengthen [in.tɛ.rɛs] rather than eliminate it from the race. I conclude that Ident[+high] cannot be the selector. Ident[$-$back] and Ident[+tense] are violated by exactly the same candidates as Ident[+high], so they repeat the bad result delivered by Ident[+high]. The only remaining faithfulness constraint to consider for the function of the selector is Dep-Seg. Candidates (45c) and (45d), [jin.tɛ.rɛs] and [jən.tɛ.rɛs], respectively, are automatically excluded from consideration because they violate Dep-Seg. Of the remaining candidates (45b) and (45a), [in.tɛ.rɛs] fares better on constraint violation and, consequently, becomes the sympathetic base – the wrong result. I conclude that bringing Sympathy theory into the analysis of //intɛrɛs// → [jən.tɛ.rɛs] makes things worse rather than better because the undesired winner [in.tɛ.rɛs] is strengthened rather than eliminated.Footnote [22]
OT-CC (OT Candidate Chains, McCarthy Reference McCarthy2007) purports to account for opacity by introducing a new class of constraints called Prec (Precedence) constraints. They require a certain order in which faithfulness violations are incurred. The order of changes is best reflected in a derivation, but derivations are forbidden in Standard OT. The surrogate is to assume that candidates are not single output forms but chains of output forms. Chains are subject to three conditions: initial form, gradualness and harmonic improvement (local optimality). The initial form condition mandates that the first form in a chain must be a fully faithful parse of the input, which means in practice that it is the underlying representation with added syllable structure. Gradualness ensures that successive forms in a chain differ by no more than one violation of a faithfulness constraint. The condition of harmonic improvement mandates that forms satisfy some markedness constraint of the hierarchy of ranked constraints in a given language. To be valid, a chain must obey these three conditions. For example, the chain < in.tɛ.rɛs, jən.tɛ.rɛs >is invalid because it runs afoul of gradualness. This is so because [in.tɛ.rɛs] →[jən.tɛ.rɛs] has made more than one change in one step: [j] has been inserted and [i] has been changed to [ə]. The correct chain is < in.tɛ.rɛs, jin.tɛ.rɛs, jen.tɛ.rɛs, jɛn.tɛ.rɛs, jən.tɛ.rɛs >, where successive forms in the chain differ by exactly one violation of faithfulness.
Much like Feature [F] theory, OT-CC can do a good job on distinguishing the undesired candidate [ən.tɛ.rɛs] from the desired winner [jən.tɛ.rɛs]. Recall that the issue is how to enforce the occurrence of [j] before schwa. This is a problem because mid vowels do not trigger j-Insertion, so we have [ɛ] rather than [jɛ] in elekstryk ‘electrician’ (see (22) in Section 3). The descriptive generalization is that j-Insertion applies before i, which means that we need to appeal to the derivational step at which underlying //i// is still /i/, that is: //in.tɛ.rɛs// →
/jin.tɛ.rɛs/ → [jən.tɛ.rɛs]. The problem is that derivational steps are not permitted in Standard OT. OT-CC’s idea is to get the benefit of a derivational step from the order in which the changes need to take place. Specifically for the case at hand, OT-CC requires that the insertion process, Ø →j / — i, precede the vowel lowering process, i → ə
/ j — Son) $_{\unicode[STIX]{x1D70E}}$. Translated into the tools of OT, insertion falls within the jurisdiction of Dep-Seg while lowering is controlled by Ident[+high]. Since we do not have derivation to check the order in which the changes are implemented, we need to have candidate chains where successive forms emulate derivational steps. The order can now be enforced by Precedence, specifically, Prec(Dep-Seg, Ident[+high]), which says that a violation of Ident[+high] must be preceded (and cannot be followed) by a violation of Dep-Seg. We need a chain of forms to check if Prec is satisfied. In (46) I assume, arbitrarily, that Prec(Dep-Seg, Ident[+high]) is undominated.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU54.png?pub-status=live)
It should be clarified that chains are used only to check if Prec is violated. The other constraints look exclusively at the final form in the chain. Candidate (46a) has an Ident[+high] on the initial vowel but no violation of Dep-Seg in the preceding forms in the chain, so Prec(Dep-Seg, Ident[+high]) is violated. Candidate (46b) is mute on Prec(Dep-Seg, Ident[+high]) because it does not violate Ident[+high], so the precedence relation cannot be established. Candidate (46c) has done exactly what Prec(Dep-Seg, Ident[+high]) asks for: the violation of Ident[+high] in the final form [jən.tɛ.rɛs] is preceded by a violation of Dep-Seg in the preceding form [jɛn.tɛ.rɛs]. The result is correct since [jɛn.tɛ.rɛs] is the attested surface form. However, the success of OT-CC is apparent. The theory fails when we include the fully faithful candidate in the candidate pool, as (47) documents.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU55.png?pub-status=live)
Candidate (47a), [in.tɛ.rɛs], satisfies Prec(Dep-Seg, Ident[+high]) in a trivial way. This candidate is the initial form, so by definition there are no preceding forms in the chain. Consequently, Prec cannot be checked and is vacuously satisfied. Also, Ident[+high] is not violated. The winner is [in.tɛ.rɛs], the wrong candidate.Footnote [23] OT-CC fails.
More generally, the conclusion is that none of the three auxiliary theories of Standard OT, Max Feature, Sympathy and OT-CC, is able to account for the facts of Kurpian. Consequently, there is no non-derivational alternative to the analysis in terms of Derivational OT in Section 3.
The failure of Max[F], Sympathy and OT-CC with the Kurpian data is deepened by ‘cyclicity effects’.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU56.png?pub-status=live)
The insertion of [j] in the prepositional phrases is spurious and complicates matters in two ways. Onset would be perfectly satisfied by the preposition z ‘from’ or w ‘in’, as z jënternetu ‘from the internet’: //z intɛrnɛt+u// → [zintɛrnɛtu]. Second, the insertion of [j] makes syllable structure worse rather than better because it creates a complex onset: [zjən.tɛr.nɛ.tu]. Max[F], Sympathy and OT-CC are completely unable to deal with these data, so Standard OT must turn to yet another auxiliary theory: Output–Output faithfulness (Benua Reference Benua1997).Footnote [24]
The difficulties just described do not arise in Derivational OT. In fact, the outputs in (48) are exactly what Derivational OT predicts. As shown in Section 3, the evaluation at Level 1 takes //intɛrnɛt+u// to /jin.tɛr.nɛ.tu/. The evaluation continues at Level 2: /jin.tɛr.nɛ.tu/ → /jən.tɛr.nɛt.u/. The prepositions z ‘from’ and w ‘in’, like all prepositions, are proclitics, so they become first available at Level 3, the clitic level. In accordance with the architecture of Derivational OT, the input to Level 3 is the winning output from Level 2, now expanded by the clitic: /z jən.tɛr.nɛ.tu/ → [zjən.tɛr.nɛ.tu]. The only operation at Level 3 is the integration of [z] into the onset, an operation that is mandated by Parse-Seg.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU57.png?pub-status=live)
Faithfulness constraints, such as Max-Seg (31), ensure that the segmental composition of the input sails safely through Level 3.
![](https://static.cambridge.org/binary/version/id/urn:cambridge.org:id:binary:20200723073254866-0591:S002222671900015X:S002222671900015X_eqnU58.png?pub-status=live)
The argument for Derivational OT is the cyclic effect: we need to evaluate words before we evaluate clitic phrases.
5 Conclusion
Kurpian exhibits chain effects which are a response to two constraints: Onset and *ji. Onset induces j-Insertion in all words that begin with //i//, hence, in surface terms, no word in Kurpian may begin with i. Even though i → ji satisfies Onset, it produces a non-optimal concatenation of [j] and [i], violating DistinctGlide (*ji). Kurpian tolerates the non-optimal ji in open syllables or in syllables ending in an obstruent. However, ji is not tolerated if the syllable is closed by a sonorant: *jiSon) $_{\unicode[STIX]{x1D70E}}$. To eliminate this configuration, Kurpian performs two types of repair: first, lowering //i// → [e], as in jércha //irxa// → [jerxa] ‘deerskin’, and, second, lowering cum backing //i// → [ə] before a nasal, as in jënteres //intɛrɛs// → [jəntɛrɛs] ‘interest’.
The changes i → ji → je and i → ji → jə yield self-destructive chains because //i//, the trigger of j-Insertion, is eliminated precisely because it has induced j-Insertion (i → e and i → jə apply after j). Such chains are opaque and cannot be analyzed in Standard OT, even when it is expanded by postulating the auxiliary theories of Max Feature, Sympathy and OT-CC. The self-destructive chains of Kurpian require the postulation of derivational levels, a requirement that is easily accommodated by Derivational Optimality Theory.