4.1. UnificationTOP

The critical idea we need, presented in Bale et al. (2014), is that feature-filling is the result of unification, which is a partial operation. This idea is probably best explained by contrasting unification with set union. Set union is not partial: for any two sets, A and B, the union of the two, A ⋓ B, is always defined (as the set that includes all the elements of A and all the elements of B, but no other elements). Unification, in contrast, is defined only when its output is consistent. For phonological purposes, we define consistency as follows:

When Consistency is met, the output of set unification is identical to the output of set union:

When A⊔B is not defined, we will say that unification fails.

To understand how unification can be used in phonological rules, let’s reconsider the Turkish data discussed above, involving two fully specified coronal stops (/t/ and /d/) as well as a coronal stop underspecified for voicing (/D/). In Inkelas’ analysis, /D/ is voiced to [d] in onsets, but both /t/ and /d/ surface unchanged. As discussed above, there is no way of targeting just /D/ using the rule notation discussed above (any natural class containing /D/ will also contain /t/ and /d/), however there is a way to make a rule that appears to target just /D/ using unification:

This rule will have the following interpretation:

The rule targets the natural class that contains the three segments /t, D, d/. Let’s see how the rule applies in various cases, assuming monosyllabic forms:

In (20a), unification fails, because /t/ is –VOICE, so the union of /t/ with {+VOICE} is not consistent. Therefore, the output string is the same as the input string, [tab]. In (20b), unification adds the valued feature {+VOICE} to /D/, yielding an output string [dab]. In (20c), unification does not fail, but it is vacuous, since /d/⋓{+VOICE} is just [d]. The output string is identical to the input string, namely [dab]. In (20d), /D/ is not in a syllable onset, so the output string is identical to the input string, namely [baD]. The phonological rule targets all three segments in the natural class, but has a non-vacuous effect only on the underspecified segment, and only when that segment occurs in an onset.

4.2. Feature filling rules and the empty segment

The preceding example made use of /D/, a segment unspecified for the single feature, VOICE, and a rule that added a value for this feature to segments lacking one. This logic can be extended to segments lacking values for any number of features, even to the empty segment. To illustrate how we can extensionally target the empty segment without doing so intensionally, let’s construct a simple example of a phonological process in a language defined within a grammar with a very limited inventory of features. Consider a system with just two binary features ±F, ±G. If we do not stipulate that segments be complete, that is, if we allow underspecification, these features can be combined into nine different segments (feature sets):

Now consider a language L₁ that has only five of these segments, the fully specified ones, {+F, +G}, {+F, −G}, {−F, +G}, {−F, −G} and the empty segment {}. Suppose that L₂ has a process that assimilates the empty segment to the preceding segment if that segment is{+F, +G}, so that we observe the following input-to-output mapping:

(22)	Input-to-output mapping in L1:
	{+F, +G}{ } {+F, +G}{+F, +G}

This process can be informally characterized as stating that the empty segment becomes {+F, +G} when it occurs after{+F, +G}:

However, the informal process in (23) intensionally targets the empty segment, which, as we discussed in section 2, cannot constitute a natural class. Yet, if we use set-unification as the primary operator, we can write a rule that targets a natural class and yet achieves an almost identical input-to-output mapping as the one expressed by the informal process in (23). Consider the rule in (24).

This rule will have the following interpretation:

The rule in (24), as it is interpreted in (25), is a function from strings to strings that targets every segment that appears to the right of {+F, +G} (since the natural class defined by [] contains all possible segments and the natural class defined by [+F, +G] contains only the segment{+F, +G}). The rule attempts to unify these targets with {+F, +G}.

However, the effect of this unification on the target is sometimes vacuous (and the rule application is vacuous), when the target segment in an input string is the segment {+F, +G} itself. The rule application is also vacuous when the unification is undefined because the union of a target segment and {+F, +G} is inconsistent: unification fails and thus the segment remains unaffected by the rule. The only noticeable (non-vacuous) application of the rule will occur when the target is the empty segment. The relevant possible mappings are presented in (26), where we consider minimal two-segment sequences as inputs to the rule.

(26)	Three scenarios for a two-segment sequence of the form {+F, +G}X
	• Where X is {}: {+F, +G}{ } {+F, +G}{+F, +G} (unification applies and fills in values of input{})
	• Where X is{+F, +G}: {+F, +G}{+F, +G} {+F, +G}{+F, +G} (unification applies vacuously, {+F, +G}⊔{+F, +G}={+F, +G})
	• Where X is {+F, –G}, {–F, +G} or {–F, –G} Unification failure---X remains unchanged because set union yields an inconsistent set (see (25) condition 2 above, and the rule semantics in Bale and Reiss, 2018).
	1. {+F, +G}{+F, –G} {+F, +G}{+F, –G}, since {+F, +G}⊔{+F, –G} is undefined.
	2. {+F, +G}{–F, +G} {+F, +G}{–F, +G}, since {+F, +G}⊔{–F, +G} is undefined.
	3. {+F, +G}{–F, –G} {+F, +G}{–F, –G}, since {+F, +G}⊔{–F, –G} is undefined.

Hence, although the rule intensionally targets all segments to the immediate right of {+F, +G}, the only time the output is different from the input is when the segment to the right of {+F, +G} is the empty set.

This example differs from the Turkish illustration with /t, D, d/ in two ways. First, there are two features involved in the rule, not just one, and second, the second argument of the unification operation happens to be identical to the segment defining the rule environment, in contrast to the condition in Turkish that +VOICE is supplied in Onsets. Despite these differences, the logic of the two examples is identical with respect to the mechanics of unification.

4.3. Do we really want to unify segments with non-singleton sets?

In section 4.2 we unified segments with a set containing two valued features. We assumed that the toy language in question L₂ had only five segments, four that are fully specified and one that is completely unspecified. Let’s consider a language that contains all nine of the definable segments given the features F and G. We’ll assume that this L₂ has the same rule as L₁, repeated in (27):

Here are some cases that arise when the rule applies to strings containing some of the nine definable segments preceded by{+F, +G}:

(28)	Some applications
	a. {+F, +G}{ } {+F, +G}{+F, +G} Both valued features are filled in.
	b. {+F, +G}{+F, +G} {+F, +G}{+F, +G} Unification is vacuous.
	c. {+F, +G}{–F, –G} {+F, +G}{–F, –G} Unification fails so target is unchanged.
	d. {+F, +G}{+G} {+F, +G}{+F, +G} Unification fills in+F, but is vacuous for +G
	e. {+F, +G}{–G} {+F, +G}{–G}Unification fails so target is unchanged

The logic for all five cases should be clear, but pay particular attention to (e). Since the union {–G}⋓{+F, +G} = {+F, +G, –G}, which is inconsistent, it follows that the unification {–G}⊔{+F, +G} is undefined. Therefore, the output string must be the same as the input string, namely{+F, +G}{–G}.

We propose that this might be the wrong result for modelling human phonology. We suspect that a formal system that would yield {+F, +G}{+F, –G} in such a case is correct. In other words, the conflict with respect to the feature G should not prevent the addition of the valued feature +F via unification. A simple way to achieve this is to suppose that the second argument in a phonological unification must be a singleton set, and thus rule (27) needs to be reformulated in terms of a sequence of two rules, each containing unification with a singleton set. In the remainder of this section we sketch out such a system and show how it achieves the effect we are claiming better reflects the human language faculty. In section 5 we work with data sets and toy languages based on Turkish vowel harmony phenomena to illustrate the kinds of languages we specifically want to rule out. We cannot prove the non-existence of such languages, but if no examples are attested, our explicit proposal might explain why.

To give a flavour of the kind of system we intend to develop, let’s take a closer look at case (e) in (28) above. As it is, the output of the unification process is the same as the input. However, if we divide the unification process into two rules, one that first attempts to unify the target with {+F} and then another that then attempts to unify the target with {+G}, the output for case (e) would be different even though the output for all the other cases would be the same. For example, if we first unify {–G} with {+F} we get {+F, –G} as an output. Then, if we try to unify this output with {+G}, the unification will fail. As a result, the final output would be {+F, –G} rather than just {–G}. Note that we get the same result if we change the order of the two unification processes. If we first try to unify {–G} with{+G}, the result is undefined, so we get the output {–G}. If we then unify this output with {+F}, the result is{+F, –G}.

We have not proved that this is the correct result, but rather illustrated a distinction that leads to different outputs. However, we will make a strong empirical claim and propose the following as a property of phonological rules:

In other words, unification must proceed in a derivation one feature at a time. If the SSR is valid then we need to reformulate the processes expressed in (28a-e). First let’s decompose rule (27) to conform to the SSR in (29). We will arbitrarily order unification with +F before unification with+G.

Each rule is a function from strings to strings, so we can compose the rules in normal fashion. For example, we can apply R₁ to a string abcd and then apply R₂ to the output: R₂ ° R₁ (abcd). Let’s redo the derivations in (28) using the two rules of (30) instead of the one in (27), which we now propose is not a licit human phonological rule at all:

(31)	Some applications
	a. R2°R1 ({+F, +G}{ }) {+F, +G}{+F, +G}
	Both valued features are filled in: +F is filled in on the righthand segment by R1 and +G is filled in on the righthand segment by R2.
	b. R2°R1({+F, +G}{+F, +G}) {+F, +G}{+F, +G}
	Each rule yields a vacuous unification.
	c. R2°R1({+F, +G}{–F, –G}) {+F, +G}{–F, –G}
	Each unification fails so target is unchanged.
	d. R2°R1 ({+F, +G}{+G}) {+F, +G}{+F, +G}
	Unification fills in +F, but is vacuous for +G
	e. R2°R1 ({+F, +G}{–G}) {+F, +G}{+F, –G}
	Unification is vacuous for +F (by R1) and unification fails for G, so –G on the target remains.

The mappings in (31) are identical to those in (28) aside from case (e).

It is crucial to note that the SSR applies only to structural changes in unification rules. The rules above in (30) have two valued features specified in the environment segment, and thus are different from the following rules which each have a single feature specified in the environment segment:

The reader can confirm that R₁ in (30) applied to the string {+F, −G}{ } yields the identical string{+F, −G}{ }, whereas R_A in (32) applied to the same input yields {+F, −G}{+F}. This is because R_A does not require that the preceding segment be +G, but R₁ does. Think of R₁ as a rule that spreads +VOICE from segments that are +CONTINUANT, whereas R_A is like a rule that spreads +VOICE regardless of other feature values.

4.4. Unification and the SSR with α-notation

We now demonstrate how the system we propose interacts with α-notation. The SSR allows for the single member of the set denoting the structural change to be a feature with a Greek letter variable as its value. This variable denotes identity with other tokens of the same variable elsewhere in the rule:

This rule says to unify each coronal stop with the set containing the voicing value of the following segment. We have to consider six cases, namely strings in which each segment /t, D, d/ occurs before a voiced segment, and strings in which each occurs before a voiceless segment. Let’s first consider what happens when each coronal stop occurs before a voiced segment:

In (34a), unification fails, because /t/ is – VOICE, so the union of /t/ with {+VOICE} is not consistent. Therefore, the output string has [t]. In (34b), unification adds the valued feature {+VOICE} to /D/, yielding [d] in the output string. In (34c), unification does not fail, but it is vacuous, since /d/ ⋓{+VOICE} is just [d].

Now let’s see what happens before a voiceless segment:

In (35a), unification is vacuous since /t/ is already −VOICE, so the output is [t]. In (35b) unification adds the feature −VOICE to /D/, yielding [t]. In (35c) unification fails, because /d/ is−VOICE, so the union of /d/ with {−VOICE} is not consistent. Therefore, the output string has [d].

5.1. Turkish vowel harmony

Let’s consider a limited dataset illustrating Turkish vowel harmony, one that only contains monosyllabic roots and words with a single suffix. For example, notice the vowel alternations in (36).

(36) Less specific environment specifications:

The vowel in the plural suffix always surfaces as –HIGH and –R OUND, but it agrees with the value for BACK on the preceding vowel. One way to represent the underlying phonological form of this suffix is to posit a vowel /A/ which is underspecified for BACK. We might imagine that the value for this feature could be filled in by a unification rule that targets /A/, something like this:

However, we now know that any rule that targets /A/ must target the natural class that includes /e/ and /a/ as well, (since /A/⊆/e/ and/A/⊆/a/) so the correct formulation is more like this:

The effect of the rule on suffixes with fully specified underlying vowels will be vacuous.

It turns out that alternating suffixes with +HIGH vowels also assimilate with respect to BACK on a preceding vowel:

The high suffix vowel in these genitive forms also assimilates to the value of BACK on the preceding vowel, just like the non–nigh vowel in the plural. Rule (38) can be revised to apply to this vowel as well, by removing the specification that the target vowel must be +HIGH and –R OUND:

We can thus treat BACK harmony in high and non−high vowels as a single process.

The non-high vowel of the plural suffix is always, −ROUND, but the high vowel of the genitive suffix also alternates with respect to the feature ROUND. Let’s assume that underlyingly this high vowel is /I/, specified as +HIGH, but unspecified for both ROUND and BACK. We need another rule to fill in values for ROUND:

Rounding harmony does not affect the vowel of the plural suffix, but we don’t need to specify that the targets of the rounding rule are+HIGH, since unification of sets containing conflicting values of ROUND will fail. So, application of a rule based on unification of any value for ROUND with the −ROUND of /A/ will be vacuous (either because /A/ is vacuously unified with{−ROUND}, or because unification of /A/ with {+ROUND} fails due to inconsistency). Note that the two rules in (39) and (40) happen to obey the SSR.

Unconstrained by the SSR, we could posit an alternative to the two rules (39) and (40). We could propose to use (38) to fill in BACK on /A/ and then use a single rule to fill in both underspecified features on an alternating high vowel suffix /I/, something like (41):[16]

However, this would treat the BACK assimilation as being due to two separate rules, a result that we think misses a critical generalization.

In contrast, by insisting that rules are formulated in accordance with the singleton set restriction, BACK assimilation would be due to a single process. To see how, let’s go through a derivation. Consider again the rules in (39, 40), repeated in (42):

The rules can apply in either order, but we illustrate with BACK assimilation applied first. The formula in (43) shows the composition of the two rules applied to the input /ip-lAr/. This composed function has the effect of first ‘attempting’ to add a value for BACK to each target segment, and then attempting to add a value for ROUND, with one application of unification for each feature.

In the derivations below, the abbreviation ‘v.u.’ refers to ‘vacuous unification’, for example, when a –ROUND vowel unifies with {−ROUND}. The abbreviation ‘u.f.’ refers to ‘unification failure’, another kind of vacuous application which occurs, for example, when a –ROUND vowel unifies with{+ROUND}. The tables show only the features that get added to the suffix vowels by each rule.

So, in the course of the derivation, the vowel of /ip-lAr/ starts out as{−HIGH, −ROUND}, then receives {−BACK} via rule R_a, and is unaffected by rule R_b. It surfaces as [e]. Let’s see what happens with the suffix containing /I/:

In the course of the derivation, the suffix vowel of /ip-In/ starts out as {−HIGH}, then receives –BACK via rule R_a, and -ROUND via rule R_b. It surfaces as [i].

5.2. Hypothetical languages: Purkish and Surkish

We have just shown that we can derive the surface forms of Turkish using one rule per harmonizing feature. In other words, the SSR is not too weak to model Turkish. Since the SSR restricts set of possible grammars (i.e., any grammar that obeys the SSR is also a grammar in a phonological system that does not enforce the SSR), we will adopt the SSR as a guiding principle unless the phonological data can be better explained by adopting more complex rules. In this section, we discuss some of the differences between a phonological theory that is constrained by the SSR and one that is not. We begin by first presenting a possible variation of Turkish, which we call Purkish. Purkish is identical to Turkish except that it has a third underlying underspecified vowel, namely /U/={+HIGH, +ROUND}. Critically /U/ has no specification for BACK. We hypothesize that this vowel also undergoes assimilation with respect to the previous vowel (i.e., it surfaces as having the same BACK specification as the previous vowel). As we discuss below, not only do rules that obey the SSR provide a better account of Purkish, but the analysis reveals the limits of the SSR.

Let’s consider some details of Purkish. By hypothesis, this hypothetical language has the same eight surface vowels as Turkish, as well as the underlyingly partially specified /A/ and /I/. Also by hypothesis, Purkish /A/ and /I/ show the same exact alternations as their Turkish counterparts in the same environments. It is thus possible to posit the same rules for the two languages in order to account for this alternation. However, as mentioned above, Purkish also has another partially specified vowel /U/, let’s say realized on a comitative suffix /-Uk/. Critically, /U/ is more specified than /I/. Note that there is no way to target, in a rule, the vowel /I/ without also targeting the more specified vowel /U/, because any natural class that contains /I/, also contains /U/.

Now, if /U/ assimilates with respect to the BACK specification of the previous vowel (as mentioned above), it is relevant to note that only one of the rule systems hypothesized in the previous section will be able to account for the input to output mapping. For example, consider a derivation with the two rules that obey the SSR in the derivation table in (46).

The vowel in the suffix /-Uk/ always surfaces with the feature +ROUND, since that is the underlying value, unlike the underlying /I/ which is unspecified for ROUND. As a result, the rule that ‘attempts’ to unify /U/ with the ROUND specification of the previous vowel will always have no effect, either due to unification failure or due to vacuous unification. In contrast, /U/ will be affected by the rule that ‘attempts’ to unify it with the BACK specification of the previous vowel, since /U/ is underspecified for this feature. The end result is a system that maps /U/ to [Ü] or [u].

Let’s reconsider the same underlying forms with respect to the rules in the previous section that violated the SSR. The effect of these rules is quite different, as outlined in (41).

(47)	No Singleton Set Restriction
Purkish comitative derivations: /U/ is {+HIGH, +ROUND }
UR	ip-Uk	ek-Uk	gül-Uk	öç-Uk	kıl-Uk	sap-Uk	pul-Uk	son-Uk
	u.f.	u.f.	−BK +RD	−BK +RD	u.f.	u.f.	+BK +RD	+BK +RD
SR	ipUk	ekUk	gülük	öçük	kılUk	sapUk	puluk	sonuk

The SRs in (47) have three different mappings of underlying /U/—it maps /U/ to [Ü], [u], and [U]. If Purkish does indeed have the surface forms represented in (46), then the rule in (47) is unable to derived the right result. To get the right result and maintain the rule that violates the SSR, one would need to posit a further rule to provide a BACK value on the suffix of roots that are –ROUND. This seems like an unnecessary complication to our grammar.

However, not only is the added complexity a problem, the mappings in (47) also demonstrate a key limitation of a grammar that obeys the SSR. Following our natural class logic, it is impossible to fill in values of BACK on the less-specified /I/ but not do so on the more specified /U/. In other words, a system with the input-output mappings of (47), call it Surkish, is not a possible human language if we assume the SSR.[17] Thus, to argue against the SSR, one would have to demonstrate that input to output mappings like in (47) provide a better analysis of some attested language. We do not know of any examples of such languages, and hence we propose adopting the SSR as a working hypothesis for a restricted model of phonological UG.