Scott 2021: Two Types of Resumptive Pronouns in Swahili

[Sco21]

Two Types of Resumptive Pronouns in Swahili. Linguistic Inquiry 52(4): 812–833.

Core Claims

Swahili distinguishes two types of resumptive pronouns:

1. Movement copies (personless: -ye, -o): lower copies of Ā-movement chains, reduced by chain reduction at PF. Diagnosed by parasitic gap constructions — the "true gap" position must license movement, and the "parasitic gap" position shows personless resumptives.

2. Base-generated bound pronouns (person-matching: -mi, -we, -si, -nyi): not copies — syntactically bound by the head of the RC. Diagnosed by adjunct islands — movement is blocked, so only binding is available, and bound resumptives obligatorily match person.

Analysis: Chain Reduction + MaxElide

Following [Lan06] and [VU18]:

• Movement leaves full copies of the pronoun (including PersP)
• Chain reduction at PF deletes copies except the highest
• Where a phonological requirement (bimoraic Minimality on monosyllabic prepositions) prevents full deletion, MaxElide deletes the largest deletable constituent — PersP
• After PersP deletion, the remaining features [GEN: ANIM, NUM: SG/PL] trigger insertion of the less specific (personless) VI -ye or -o

DP Structure (Tree-Based)

Pronouns: [DP D [NumP Num [nP n_anim [PersP Pers:x]]]] Lexical DPs: [DP D [NumP Num [nP n/n_anim [√P √]]]]

Modeled using Syntax DPCat String with Minimalism-grounded categories (D, Num, n, Pers).

Vocabulary Insertion (FeatureBundle-Based)

Uses Minimalist.FeatureBundle and Morphology.DM.VI.vocabularyInsertSimple from the DM theory module. The Elsewhere Condition is structural: person- specified rules (specificity 3) beat personless defaults (specificity 2). Chain reduction removes person features from the bundle, so only the default matches.

inductive Scott2021.DPCat : Type

Categories for DP-internal structure. Grounded in Minimalism categories but restricted to the four projections relevant to Bantu pronoun structure ([Sco21]).

• D : DPCat
• Num : DPCat
• n : DPCat
• Pers : DPCat

@[implicit_reducible]

instance Scott2021.instDecidableEqDPCat : DecidableEq DPCat

Equations

• Scott2021.instDecidableEqDPCat x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

@[implicit_reducible]

instance Scott2021.instReprDPCat : Repr DPCat

Equations

• Scott2021.instReprDPCat = { reprPrec := Scott2021.instReprDPCat.repr }

def Scott2021.instReprDPCat.repr : DPCat → ℕ → Std.Format

Equations

• Scott2021.instReprDPCat.repr Scott2021.DPCat.D prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Scott2021.DPCat.D")).group prec✝
• Scott2021.instReprDPCat.repr Scott2021.DPCat.Num prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Scott2021.DPCat.Num")).group prec✝
• Scott2021.instReprDPCat.repr Scott2021.DPCat.n prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Scott2021.DPCat.n")).group prec✝
• Scott2021.instReprDPCat.repr Scott2021.DPCat.Pers prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Scott2021.DPCat.Pers")).group prec✝

@[implicit_reducible]

instance Scott2021.instInhabitedDPCat : Inhabited DPCat

Equations

• Scott2021.instInhabitedDPCat = { default := Scott2021.DPCat.D }

def Scott2021.pronTree1sg : Syntax.Tree DPCat String

1SG pronoun mi: [DP D [NumP Num:sg [nP n_anim [PersP 1]]]] [Sco21].

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.pronTree2sg : Syntax.Tree DPCat String

2SG pronoun we: [DP D [NumP Num:sg [nP n_anim [PersP 2]]]]

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.pronTreeCl1 : Syntax.Tree DPCat String

Noun class 1 pronoun ye (no person): [DP D [NumP Num:sg [nP n_anim]]] [Sco21]. This is also the structure AFTER chain reduction deletes PersP from a 1SG/2SG pronoun.

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.pronTree1pl : Syntax.Tree DPCat String

Plural counterparts.

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.pronTreeCl2 : Syntax.Tree DPCat String

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.deletePersP : Syntax.Tree DPCat String → Syntax.Tree DPCat String

Delete the PersP subtree from a pronoun tree. This is what MaxElide does to movement copies: it removes the biggest deletable constituent, which is PersP (nP cannot be deleted because Num and n form a portmanteau — no VI exists for Num alone).

Uses mutual recursion with list helpers so that tree operations reduce definitionally on concrete trees.

Equations

• Scott2021.deletePersP (Syntax.Tree.node Scott2021.DPCat.n children) = Syntax.Tree.node Scott2021.DPCat.n (Scott2021.filterPers✝ children)
• Scott2021.deletePersP (Syntax.Tree.node c children) = Syntax.Tree.node c (Scott2021.mapDeletePersP✝ children)
• Scott2021.deletePersP x✝ = x✝

theorem Scott2021.delete_persP_1sg : deletePersP pronTree1sg = pronTreeCl1

Deleting PersP from a 1SG pronoun yields a class 1 pronoun.

theorem Scott2021.delete_persP_2sg : deletePersP pronTree2sg = pronTreeCl1

Deleting PersP from a 2SG pronoun yields the same class 1 pronoun.

theorem Scott2021.delete_persP_1pl : deletePersP pronTree1pl = pronTreeCl2

Deleting PersP from a 1PL pronoun yields a class 2 pronoun.

theorem Scott2021.delete_persP_idempotent : deletePersP pronTreeCl1 = pronTreeCl1

Class 1 pronoun has no PersP — deletion is idempotent.

def Scott2021.terminalToFeature : DPCat → String → Option Minimalist.FeatureVal

Extract the feature bundle from a pronoun tree's terminals. Each terminal maps to a FeatureVal:

• Pers "1" → phi (person .first)
• Pers "2" → phi (person .second)
• Num "sg" → phi (number .Sing)
• Num "pl" → phi (number .Plur)
• n "anim" → phi (gender 1) (encoding animacy as gender 1)

Equations

• Scott2021.terminalToFeature Scott2021.DPCat.Pers "1" = some (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.person Person.first))
• Scott2021.terminalToFeature Scott2021.DPCat.Pers "2" = some (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.person Person.second))
• Scott2021.terminalToFeature Scott2021.DPCat.Num "sg" = some (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.number Number.singular))
• Scott2021.terminalToFeature Scott2021.DPCat.Num "pl" = some (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.number Number.plural))
• Scott2021.terminalToFeature Scott2021.DPCat.n "anim" = some (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.gender 1))
• Scott2021.terminalToFeature x✝¹ x✝ = none

def Scott2021.extractFeatureList : Syntax.Tree DPCat String → List Minimalist.GramFeature

Collect all features from a tree's terminals as a list of GramFeatures, in depth-first traversal order. The list traversal is the natural shape; extractFeatures wraps it into a FeatureBundle assignment. Uses mutual recursion for definitional reduction.

Equations

• Scott2021.extractFeatureList (Syntax.Tree.terminal c w) = match Scott2021.terminalToFeature c w with | some fv => [Minimalist.GramFeature.valued fv] | none => []
• Scott2021.extractFeatureList (Syntax.Tree.node a children) = Scott2021.extractFeatureListAux✝ children
• Scott2021.extractFeatureList (Syntax.Tree.trace a a_1) = []
• Scott2021.extractFeatureList (Syntax.Tree.bind a a_1 body) = Scott2021.extractFeatureList body

def Scott2021.extractFeatures (t : Syntax.Tree DPCat String) : Minimalist.FeatureBundle

The feature bundle of a pronoun tree: fold its terminal features into the total assignment. Each pronoun structure has at most one feature per dimension, so no information is lost in the fold.

Equations

• Scott2021.extractFeatures t = Minimalist.FeatureBundle.ofGramFeatures (Scott2021.extractFeatureList t)

theorem Scott2021.features_1sg : extractFeatureList pronTree1sg = [Minimalist.GramFeature.valued (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.number Number.singular)), Minimalist.GramFeature.valued (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.gender 1)), Minimalist.GramFeature.valued (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.person Person.first))]

1SG pronoun has features: [number:sg, gender:anim, person:1]. (Order follows depth-first tree traversal.)

theorem Scott2021.features_after_deletion : extractFeatureList (deletePersP pronTree1sg) = [Minimalist.GramFeature.valued (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.number Number.singular)), Minimalist.GramFeature.valued (Minimalist.FeatureVal.phi (Minimalist.PhiFeature.gender 1))]

After PersP deletion, features are: [number:sg, gender:anim] — no person.

def Scott2021.hasPerson (fb : Minimalist.FeatureBundle) : Bool

Helper: does a feature bundle contain a person feature?

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.getPerson (fb : Minimalist.FeatureBundle) : Option Person

Helper: extract the person level if present.

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.isSg (fb : Minimalist.FeatureBundle) : Bool

Helper: is the number singular?

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.isAnim (fb : Minimalist.FeatureBundle) : Bool

Helper: does the bundle contain animacy?

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.resumptiveVIRules : List (Morphology.DM.VI.VocabItem Minimalist.FeatureBundle Unit)

Swahili resumptive VI rules using the DM VocabItem type. [Sco21]. Person-specified rules have specificity 3 (checking 3 features); personless defaults have specificity 2. The Elsewhere Condition in vocabularyInsertSimple picks the most specific matching rule.

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.insertResumptive (fb : Minimalist.FeatureBundle) : String

Insert the correct resumptive exponent for a feature bundle using the DM Elsewhere Condition.

Equations

• Scott2021.insertResumptive fb = (Morphology.DM.VI.vocabularyInsertSimple Scott2021.resumptiveVIRules fb).getD "-ye"

inductive Scott2021.PronOrigin : Type

Whether a pronoun occurrence is a movement copy (part of an Ā-movement chain). Only copies undergo chain reduction.

• bound : PronOrigin
• movementCopy : PronOrigin

@[implicit_reducible]

instance Scott2021.instDecidableEqPronOrigin : DecidableEq PronOrigin

Equations

• Scott2021.instDecidableEqPronOrigin x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

@[implicit_reducible]

instance Scott2021.instReprPronOrigin : Repr PronOrigin

Equations

• Scott2021.instReprPronOrigin = { reprPrec := Scott2021.instReprPronOrigin.repr }

def Scott2021.instReprPronOrigin.repr : PronOrigin → ℕ → Std.Format

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.realize (tree : Syntax.Tree DPCat String) (origin : PronOrigin) : String

Full pipeline: tree → (optional) MaxElide → feature extraction → VI.

• Bound pronouns: tree is unchanged → full features → person-matching VI
• Movement copies: MaxElide deletes PersP → reduced features → personless VI

Equations

• Scott2021.realize tree Scott2021.PronOrigin.bound = Scott2021.insertResumptive (Scott2021.extractFeatures tree)
• Scott2021.realize tree Scott2021.PronOrigin.movementCopy = Scott2021.insertResumptive (Scott2021.extractFeatures (Scott2021.deletePersP tree))

theorem Scott2021.island_bound_1sg : realize pronTree1sg PronOrigin.bound = "-mi"

Bound 1SG in adjunct island → person-matching -mi.

theorem Scott2021.island_bound_2sg : realize pronTree2sg PronOrigin.bound = "-we"

Bound 2SG in adjunct island → person-matching -we.

theorem Scott2021.island_bound_1pl : realize pronTree1pl PronOrigin.bound = "-si"

Bound 1PL in adjunct island → person-matching -si.

theorem Scott2021.parasitic_movement_1sg : realize pronTree1sg PronOrigin.movementCopy = "-ye"

Movement copy 1SG in parasitic gap → personless -ye.

theorem Scott2021.parasitic_movement_2sg : realize pronTree2sg PronOrigin.movementCopy = "-ye"

Movement copy 2SG in parasitic gap → also -ye. Person is irrelevant because chain reduction deletes PersP regardless.

theorem Scott2021.parasitic_movement_1pl : realize pronTree1pl PronOrigin.movementCopy = "-o"

Movement copy 1PL in parasitic gap → personless -o.

theorem Scott2021.movement_erases_person_distinction : realize pronTree1sg PronOrigin.movementCopy = realize pronTree2sg PronOrigin.movementCopy

Both 1SG and 2SG movement copies produce the same form — chain reduction erases the person distinction.

theorem Scott2021.end_to_end : deletePersP pronTree1sg = pronTreeCl1 ∧ hasPerson (extractFeatures (deletePersP pronTree1sg)) = false ∧ realize pronTree1sg PronOrigin.movementCopy = "-ye" ∧ realize pronTree1sg PronOrigin.bound = "-mi"

The complete derivation in one theorem:

1. Start with 1SG pronoun tree (with PersP:1)
2. MaxElide deletes PersP → tree matches class 1 structure
3. Feature extraction yields [number:sg, gender:anim] — no person
4. VI inserts -ye (specificity 2 default beats nothing more specific)
5. The same tree, unreduced (bound), yields -mi (specificity 3 wins)

structure Scott2021.ParasiticGapJudgments : Type

Parasitic gap judgments per speaker. Each field encodes whether the combination (true-gap-form ... parasitic-gap-form) is accepted. [Sco21] Table 4.

• moveMove : Bool
• pronounMove : Bool
• pronounPronoun : Bool
• movePronoun : Bool

def Scott2021.instDecidableEqParasiticGapJudgments.decEq (x✝ x✝¹ : ParasiticGapJudgments) : Decidable (x✝ = x✝¹)

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance Scott2021.instDecidableEqParasiticGapJudgments : DecidableEq ParasiticGapJudgments

Equations

• Scott2021.instDecidableEqParasiticGapJudgments = Scott2021.instDecidableEqParasiticGapJudgments.decEq

@[implicit_reducible]

instance Scott2021.instReprParasiticGapJudgments : Repr ParasiticGapJudgments

Equations

• Scott2021.instReprParasiticGapJudgments = { reprPrec := Scott2021.instReprParasiticGapJudgments.repr }

def Scott2021.instReprParasiticGapJudgments.repr : ParasiticGapJudgments → ℕ → Std.Format

Equations

• One or more equations did not get rendered due to their size.

def Scott2021.speaker1 : ParasiticGapJudgments

Equations

• Scott2021.speaker1 = { moveMove := true, pronounMove := false, pronounPronoun := false, movePronoun := false }

def Scott2021.speaker2 : ParasiticGapJudgments

Equations

• Scott2021.speaker2 = { moveMove := true, pronounMove := false, pronounPronoun := true, movePronoun := false }

def Scott2021.speaker3 : ParasiticGapJudgments

Equations

• Scott2021.speaker3 = { moveMove := true, pronounMove := false, pronounPronoun := true, movePronoun := false }

theorem Scott2021.parasitic_gap_generalization : (speaker1.moveMove && speaker2.moveMove && speaker3.moveMove) = true ∧ (speaker1.pronounMove || speaker2.pronounMove || speaker3.pronounMove) = false ∧ (speaker1.movePronoun || speaker2.movePronoun || speaker3.movePronoun) = false

All speakers accept ye...ye (Row 1); no speaker accepts mi...ye (Row 2) or ye...mi (Row 4). The parasitic gap requires the true gap to also be movement, and a movement true gap cannot license a bound parasitic pronoun.

theorem Scott2021.islands_are_syntactic : realize pronTree1sg PronOrigin.bound = "-mi" ∧ realize pronTree1sg PronOrigin.movementCopy = "-ye" ∧ realize pronTree1sg PronOrigin.bound ≠ realize pronTree1sg PronOrigin.movementCopy

Both island constructions have overt resumptive pronouns — the difference is syntactic (movement vs. binding), not phonological (overt vs. gap). If islands were phonological, both -mi and -ye should be equally acceptable inside islands.

def Scott2021.DPCat.isDeletable : DPCat → Bool

Whether a DP layer can be deleted by MaxElide. Deletable iff the remaining material can be spelled out (a VI exists for the residue).

• PersP: deletable (VI [sg + n_anim] ↔ -ye exists)
• nP: NOT deletable (Num and n portmanteau; no VI for Num alone)
• NumP/DP: never deleted (highest copy is pronounced)

Equations

• Scott2021.DPCat.Pers.isDeletable = true
• Scott2021.DPCat.n.isDeletable = false
• Scott2021.DPCat.Num.isDeletable = false
• Scott2021.DPCat.D.isDeletable = false

def Scott2021.maxElideTarget : Option DPCat

MaxElide: "Elide the biggest deletable constituent." Trying from biggest (D) to smallest (Pers), PersP is the only deletable layer.

Equations

• Scott2021.maxElideTarget = List.find? Scott2021.DPCat.isDeletable [Scott2021.DPCat.D, Scott2021.DPCat.Num, Scott2021.DPCat.n, Scott2021.DPCat.Pers]

theorem Scott2021.maxElide_targets_persP : maxElideTarget = some DPCat.Pers

theorem Scott2021.reduction_preserves_number : isSg (extractFeatures (deletePersP pronTree1sg)) = isSg (extractFeatures pronTree1sg)

Chain reduction (PersP deletion) preserves number features.

theorem Scott2021.reduction_preserves_animacy : isAnim (extractFeatures (deletePersP pronTree1sg)) = isAnim (extractFeatures pronTree1sg)

Chain reduction preserves animacy features.

theorem Scott2021.reduction_removes_person : hasPerson (extractFeatures pronTree1sg) = true ∧ hasPerson (extractFeatures (deletePersP pronTree1sg)) = false

Chain reduction removes person features.

theorem Scott2021.bound_retains_person : hasPerson (extractFeatures pronTree1sg) = true

Bound pronouns retain person features (no PersP deletion).

theorem Scott2021.movement_is_subset : have fullFeats := extractFeatureList pronTree1sg; have reducedFeats := extractFeatureList (deletePersP pronTree1sg); reducedFeats.length < fullFeats.length ∧ (reducedFeats.all fun (x : Minimalist.GramFeature) => decide (x ∈ fullFeats)) = true

If a language has both types with morphological distinction, the movement resumptive is featurally a proper subset of the bound resumptive (chain reduction only deletes).

def Scott2021.canAlternateWithFull (origin : PronOrigin) : Bool

Full pronoun alternation: bound -mi can alternate with full mimi, but movement -ye cannot alternate with yeye. Movement copies exist only to satisfy bimoraic minimality.

Equations

• Scott2021.canAlternateWithFull Scott2021.PronOrigin.bound = true
• Scott2021.canAlternateWithFull Scott2021.PronOrigin.movementCopy = false

theorem Scott2021.bound_alternates : canAlternateWithFull PronOrigin.bound = true

theorem Scott2021.movement_no_alternate : canAlternateWithFull PronOrigin.movementCopy = false

theorem Scott2021.fragment_consistency_1sg : Swahili.resumptivePronounIsPersonMatching Swahili.RelPerson.first Swahili.RelGramNum.sg = true ∧ realize pronTree1sg PronOrigin.bound = Swahili.resumptivePronoun Swahili.RelPerson.first Swahili.RelGramNum.sg ∧ realize pronTree1sg PronOrigin.movementCopy = Swahili.resumptivePronoun Swahili.RelPerson.third Swahili.RelGramNum.sg

The theory-neutral observation in the Fragment (resumptivePronounIsPersonMatching) is consistent with the theoretical pipeline in this study (realize). Person-matching (bound) ↔ Fragment says true; personless (movement) ↔ false.

theorem Scott2021.marker_classification : Swahili.ambaMovement.npRel.resumptiveKind = some RelativeClause.ResumptiveKind.movementCopy ∧ Swahili.ambaBound.npRel.resumptiveKind = some RelativeClause.ResumptiveKind.bound ∧ Swahili.ambaGap.npRel.resumptiveKind = none

The movement marker in the Fragment is correctly classified.

theorem Scott2021.person_entails_number : hasPerson (extractFeatures pronTree1sg) = true → isSg (extractFeatures pronTree1sg) = true

"If the copied pronouns match in person, they also match in number" ([Sco21] §6). This follows from the DP structure: Num dominates PersP, so deleting PersP cannot affect Num. Conversely, if person survives (not deleted), then Num — being structurally higher — necessarily also survived.

theorem Scott2021.number_without_person : isSg (extractFeatures pronTreeCl1) = true ∧ hasPerson (extractFeatures pronTreeCl1) = false

The converse does NOT hold: number can be present without person (as in noun class pronouns / movement copies).