Multidominance

@cite{citko-2014}

Multiply dominated structures: syntactic objects shared between two or more dominating nodes. A node is multiply dominated when it has more than one mother — it is built once but structurally accessible from multiple positions.

Two PF Reduction Mechanisms

Natural languages have two independent ways to arrive at PF-reduced representations (material interpreted but not pronounced):

• Ellipsis: material is built in full, then deleted at PF by an E-feature on a functional head (e.g., C^E deletes its TP complement).
• Multidominance (MD): material is built only once and shared between two structural positions; pronounced at one only.

Both yield the same surface effect — PF reduction — but differ in derivational cost. MD typically uses fewer Merge operations and fewer lexical resources because the shared material is constructed once rather than twice.

Sharing Types

• Non-bulk-sharing: Individual functional heads (C, T) are multiply dominated, but the larger constituents containing them (CP, TP) are NOT shared. Each conjunct is a separate phrase.
• Bulk-sharing: An entire constituent (e.g., C') is multiply dominated. Both conjuncts share everything inside it.

Representation

Since SyntacticObject is a tree (each node has exactly one parent), multiply dominated nodes cannot be represented directly in the tree type. Instead, we model MD as a property of COORDINATION structures: a SharedNode records that a node occurring in two conjuncts is structurally identical — built once and shared rather than duplicated.

Connection to Position-Indexed Maximality

Formal/HeadMovement/Basic.lean defines position-indexed maximality (isMaximalAtPosition) precisely to handle multidominance: the same element can be maximal at its derived position (Spec) while projecting at its base position (VP). The types here complement that treatment by modeling the coordination-level sharing structure.

inductive Minimalism.PFReductionMechanism : Type

The two mechanisms of PF reduction.

Both produce representations where material is interpreted but not pronounced. Economy governs the choice between them.

• ellipsis : PFReductionMechanism

  E-feature on a functional head triggers deletion of its complement at PF. The deleted material is built in full during the derivation.

• multidominance : PFReductionMechanism

  A syntactic object is built once and shared between two dominating nodes. Pronounced at one position only.

instance Minimalism.instReprPFReductionMechanism : Repr PFReductionMechanism

Equations

• Minimalism.instReprPFReductionMechanism = { reprPrec := Minimalism.instReprPFReductionMechanism.repr }

def Minimalism.instReprPFReductionMechanism.repr : PFReductionMechanism → ℕ → Std.Format

Equations

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

instance Minimalism.instDecidableEqPFReductionMechanism : DecidableEq PFReductionMechanism

Equations

• Minimalism.instDecidableEqPFReductionMechanism x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

inductive Minimalism.SharingType : Type

How material is shared between conjuncts in an MD structure.

The distinction is empirically motivated: coordinated wh-questions use non-bulk-sharing (individual heads shared), while coordinated sluices use bulk-sharing (entire C' shared). The two sharing types derive different syntactic and interpretive properties.

• nonBulk : SharingType

  Individual functional heads shared between conjuncts. Each conjunct remains a separate full phrase; only specific heads (e.g., C, T) are multiply dominated.

• bulk : SharingType

  An entire constituent is shared between conjuncts. Both conjuncts dominate the same subtree, so they share all material inside it (C, TP, vP, VP, ...).

def Minimalism.instReprSharingType.repr : SharingType → ℕ → Std.Format

Equations

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

instance Minimalism.instReprSharingType : Repr SharingType

Equations

• Minimalism.instReprSharingType = { reprPrec := Minimalism.instReprSharingType.repr }

instance Minimalism.instDecidableEqSharingType : DecidableEq SharingType

Equations

• Minimalism.instDecidableEqSharingType x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

structure Minimalism.SharedNode : Type

A node shared between two conjuncts in a coordination structure.

The shared node is built once but is structurally accessible from both parent1 and parent2. At PF, it is linearized once.

• node : SyntacticObject

  The multiply dominated node

• category : Option Cat

  Category of the shared node (if it has a label)

• pronounced : Bool

  The shared node is pronounced (has PF content)

def Minimalism.instReprSharedNode.repr : SharedNode → ℕ → Std.Format

Equations

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

instance Minimalism.instReprSharedNode : Repr SharedNode

Equations

• Minimalism.instReprSharedNode = { reprPrec := Minimalism.instReprSharedNode.repr }

structure Minimalism.PFReducedCoordination : Type

A coordination structure with PF reduction.

Models a coordinate &P where material is either multiply dominated (shared between conjuncts) or elided by an E-feature.

• conjunct1 : SyntacticObject

  First conjunct

• conjunct2 : SyntacticObject

  Second conjunct

• mechanisms : List PFReductionMechanism

  PF reduction mechanism(s) used

• sharing : Option SharingType

  Type of sharing (for MD structures)

• sharedNodes : List SharedNode

  Nodes that are shared or deleted

• pfOutput : List String

  PF output after reduction

instance Minimalism.instReprPFReducedCoordination : Repr PFReducedCoordination

Equations

• Minimalism.instReprPFReducedCoordination = { reprPrec := Minimalism.instReprPFReducedCoordination.repr }

def Minimalism.instReprPFReducedCoordination.repr : PFReducedCoordination → ℕ → Std.Format

Equations

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

def Minimalism.PFReducedCoordination.usesMD (c : PFReducedCoordination) : Bool

Does this coordination use multidominance?

Equations

• c.usesMD = c.mechanisms.any fun (x : Minimalism.PFReductionMechanism) => x == Minimalism.PFReductionMechanism.multidominance

def Minimalism.PFReducedCoordination.usesEllipsis (c : PFReducedCoordination) : Bool

Does this coordination use ellipsis?

Equations

• c.usesEllipsis = c.mechanisms.any fun (x : Minimalism.PFReductionMechanism) => x == Minimalism.PFReductionMechanism.ellipsis

def Minimalism.PFReducedCoordination.usesBoth (c : PFReducedCoordination) : Bool

Does this coordination use both MD and ellipsis?

Equations

• c.usesBoth = (c.usesMD && c.usesEllipsis)

structure Minimalism.MWFParameter : Type

The Multiple Wh-Fronting (MWF) parameter.

Languages vary in whether multiple wh-specifiers at a phase edge are tolerable at PF:

• MWF languages (e.g., Bulgarian, Romanian): a phase node with multiple wh-specifiers does NOT receive an asterisk at PF.
• Non-MWF languages (e.g., English, German, Greek): a phase node with multiple wh-specifiers receives an asterisk, which is uninterpretable at PF, crashing the derivation.

In non-MWF languages, structures with multiple wh-specifiers at a phase edge are only grammatical if the offending edge is deleted by ellipsis before PF interprets the asterisk.

• allowsMWF : Bool

  Does this language allow multiple wh-fronting?

instance Minimalism.instReprMWFParameter : Repr MWFParameter

Equations

• Minimalism.instReprMWFParameter = { reprPrec := Minimalism.instReprMWFParameter.repr }

def Minimalism.instReprMWFParameter.repr : MWFParameter → ℕ → Std.Format

Equations

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

instance Minimalism.instDecidableEqMWFParameter : DecidableEq MWFParameter

Equations

• Minimalism.instDecidableEqMWFParameter = Minimalism.instDecidableEqMWFParameter.decEq

def Minimalism.instDecidableEqMWFParameter.decEq (x✝ x✝¹ : MWFParameter) : Decidable (x✝ = x✝¹)

Equations

• Minimalism.instDecidableEqMWFParameter.decEq { allowsMWF := a } { allowsMWF := b } = if h : a = b then h ▸ isTrue ⋯ else isFalse ⋯

def Minimalism.mwfViolation (param : MWFParameter) (numWhSpecifiers : ℕ) : Bool

A phase edge has a MWF violation when it contains multiple wh-specifiers in a non-MWF language.

Equations

• Minimalism.mwfViolation param numWhSpecifiers = (!param.allowsMWF && decide (numWhSpecifiers > 1))

def Minimalism.ellipsisRepairsMWF (param : MWFParameter) (numWhSpecs : ℕ) (edgeDeleted : Bool) : Bool

Ellipsis can repair a MWF violation by deleting the phase edge containing the offending multiple wh-specifiers.

Equations

• Minimalism.ellipsisRepairsMWF param numWhSpecs edgeDeleted = if Minimalism.mwfViolation param numWhSpecs = true then edgeDeleted else true

theorem Minimalism.mwf_language_no_violation (param : MWFParameter) (h : param.allowsMWF = true) (n : ℕ) : mwfViolation param n = false

No repair is needed if the language allows MWF.

theorem Minimalism.single_wh_no_violation (param : MWFParameter) : mwfViolation param 1 = false

A single wh-specifier never causes a MWF violation.

theorem Minimalism.zero_wh_no_violation (param : MWFParameter) : mwfViolation param 0 = false

Zero wh-specifiers never cause a MWF violation.