@cite{bill-etal-2025} — DP Conjunction Complexity

"Is DP conjunction always complex? The view from child Georgian and Hungarian" Semantics & Pragmatics 18, Article 5, 1-20.

Main Question

@cite{mitrovic-sauerland-2014} claim DP conjunction universally decomposes into J (set intersection) + MU (subset) + ☉ (type-shifter). Combined with the Transparency Principle — children prefer 1-to-1 form-meaning mappings — this predicts J-MU expressions (where all pieces are overt) should be easier for children to comprehend than J-only or MU-only.

Experiment

Act-out task: children and adults hear conjunctive sentences and manipulate objects to match. Two DVs: accuracy and sentence-played-n (replay count).

Key Findings

• Georgian children: J-MU sentences required significantly more replays than J or MU sentences (opposite of prediction). No difference between J and MU.
• Hungarian: no significant sentence-type effects detected on either measure. (Null result — could reflect ceiling effects or insufficient power.)
• Adults: near-ceiling in both languages.

Theoretical Significance

Results challenge both Mitrović & Sauerland's universal decomposition and alternative accounts.

Semantic Connection

The M&S decomposition maps directly onto Montague/Conjunction.lean:

• J = genConj (Partee & Rooth's generalized conjunction / set intersection)
• MU = typeRaise (INCL on singletons = type-raising; structural abbrev)
• ☉ = msShift (individual → singleton set)

coordEntities is defined AS genConj(typeRaise e₁, typeRaise e₂), so the M&S derivation is the definition itself, not a theorem. mu_is_distributive_check proves this equals Link's distMaximal on pairs.

structure BillEtAl2025.ConjParticle : Type

A conjunction particle in a specific language.

• language : String
• form : String
• gloss : String
• role : Features.Coordination.CoordRole
• boundMorpheme : Bool

@[implicit_reducible]

instance BillEtAl2025.instReprConjParticle : Repr ConjParticle

Equations

• BillEtAl2025.instReprConjParticle = { reprPrec := BillEtAl2025.instReprConjParticle.repr }

def BillEtAl2025.instReprConjParticle.repr : ConjParticle → ℕ → Std.Format

Equations

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

def BillEtAl2025.georgian_da : ConjParticle

Georgian J particle

Equations

• BillEtAl2025.georgian_da = { language := "Georgian", form := "da", gloss := "and", role := Features.Coordination.CoordRole.j, boundMorpheme := false }

def BillEtAl2025.georgian_c : ConjParticle

Georgian MU particle (clitic)

Equations

• BillEtAl2025.georgian_c = { language := "Georgian", form := "-c", gloss := "MU/also", role := Features.Coordination.CoordRole.mu, boundMorpheme := true }

def BillEtAl2025.hungarian_es : ConjParticle

Hungarian J particle

Equations

• BillEtAl2025.hungarian_es = { language := "Hungarian", form := "és", gloss := "and", role := Features.Coordination.CoordRole.j, boundMorpheme := false }

def BillEtAl2025.hungarian_is : ConjParticle

Hungarian MU particle

Equations

• BillEtAl2025.hungarian_is = { language := "Hungarian", form := "is", gloss := "MU/also", role := Features.Coordination.CoordRole.mu, boundMorpheme := false }

def BillEtAl2025.georgianStrategies : List Features.Coordination.ConjunctionStrategy

Both Georgian and Hungarian allow all three strategies. This is typologically rare — most languages have only one or two.

Equations

• BillEtAl2025.georgianStrategies = [Features.Coordination.ConjunctionStrategy.jOnly, Features.Coordination.ConjunctionStrategy.muOnly, Features.Coordination.ConjunctionStrategy.jMu]

def BillEtAl2025.hungarianStrategies : List Features.Coordination.ConjunctionStrategy

Equations

• BillEtAl2025.hungarianStrategies = [Features.Coordination.ConjunctionStrategy.jOnly, Features.Coordination.ConjunctionStrategy.muOnly, Features.Coordination.ConjunctionStrategy.jMu]

theorem BillEtAl2025.georgian_mu_bound : georgian_c.boundMorpheme = true

Key morphological difference: Georgian MU (-c) is a bound clitic, Hungarian MU (is) is a free morpheme. This may be relevant to the cross-linguistic difference in results (@cite{clark-2017}: free morphemes may be acquired more readily than bound).

theorem BillEtAl2025.hungarian_mu_free : hungarian_is.boundMorpheme = false

inductive BillEtAl2025.Group : Type

• adult : Group
• child : Group

@[implicit_reducible]

instance BillEtAl2025.instDecidableEqGroup : DecidableEq Group

Equations

• BillEtAl2025.instDecidableEqGroup x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

@[implicit_reducible]

instance BillEtAl2025.instReprGroup : Repr Group

Equations

• BillEtAl2025.instReprGroup = { reprPrec := BillEtAl2025.instReprGroup.repr }

def BillEtAl2025.instReprGroup.repr : Group → ℕ → Std.Format

Equations

• BillEtAl2025.instReprGroup.repr BillEtAl2025.Group.adult prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "BillEtAl2025.Group.adult")).group prec✝
• BillEtAl2025.instReprGroup.repr BillEtAl2025.Group.child prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "BillEtAl2025.Group.child")).group prec✝

structure BillEtAl2025.AgeRange : Type

Age range for a participant group, in months.

• minMonths : ℕ
• maxMonths : ℕ
• meanMonths : ℕ

def BillEtAl2025.instReprAgeRange.repr : AgeRange → ℕ → Std.Format

Equations

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

@[implicit_reducible]

instance BillEtAl2025.instReprAgeRange : Repr AgeRange

Equations

• BillEtAl2025.instReprAgeRange = { reprPrec := BillEtAl2025.instReprAgeRange.repr }

structure BillEtAl2025.ParticipantGroup : Type

Participant group with demographics.

• language : String
• group : Group
• n : ℕ
• ageRange : Option AgeRange

def BillEtAl2025.instReprParticipantGroup.repr : ParticipantGroup → ℕ → Std.Format

Equations

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

@[implicit_reducible]

instance BillEtAl2025.instReprParticipantGroup : Repr ParticipantGroup

Equations

• BillEtAl2025.instReprParticipantGroup = { reprPrec := BillEtAl2025.instReprParticipantGroup.repr }

def BillEtAl2025.georgianChildren : ParticipantGroup

Equations

• BillEtAl2025.georgianChildren = { language := "Georgian", group := BillEtAl2025.Group.child, n := 31, ageRange := some { minMonths := 45, maxMonths := 70, meanMonths := 57 } }

def BillEtAl2025.georgianAdults : ParticipantGroup

Equations

• BillEtAl2025.georgianAdults = { language := "Georgian", group := BillEtAl2025.Group.adult, n := 41, ageRange := none }

def BillEtAl2025.hungarianChildren : ParticipantGroup

Equations

• BillEtAl2025.hungarianChildren = { language := "Hungarian", group := BillEtAl2025.Group.child, n := 25, ageRange := some { minMonths := 36, maxMonths := 60, meanMonths := 50 } }

def BillEtAl2025.hungarianAdults : ParticipantGroup

Equations

• BillEtAl2025.hungarianAdults = { language := "Hungarian", group := BillEtAl2025.Group.adult, n := 30, ageRange := none }

def BillEtAl2025.georgianAgeAccuracyCorrelation : Float

Age-accuracy correlation in Georgian children: medium positive. r(525) = 0.31, p < 0.001 (footnote 8).

Equations

• BillEtAl2025.georgianAgeAccuracyCorrelation = 0.31

def BillEtAl2025.georgianAgeSentencePlayedCorrelation : Float

Age-sentencePlayedN correlation in Georgian children: small negative. r(497) = -0.18, p < 0.001 (footnote 9). Older children needed fewer replays.

Equations

• BillEtAl2025.georgianAgeSentencePlayedCorrelation = -0.18

def BillEtAl2025.hungarianAgeAccuracyCorrelation : Float

Age-accuracy correlation in Hungarian children: small positive. r(423) = 0.19, p < 0.001 (footnote 11).

Equations

• BillEtAl2025.hungarianAgeAccuracyCorrelation = 0.19

def BillEtAl2025.hungarianAgeSentencePlayedCorrelation : Float

Age-sentencePlayedN correlation in Hungarian children: small negative. r(405) = -0.28, p < 0.001 (footnote 11). Older children needed fewer replays.

Equations

• BillEtAl2025.hungarianAgeSentencePlayedCorrelation = -0.28

structure BillEtAl2025.ConditionResult : Type

A single cell in the Group × SentenceType design.

• language : String
• group : Group
• sentenceType : Features.Coordination.ConjunctionStrategy
• accuracyPct : ℕ

  Accuracy (percentage 0-100, approximate from Figure 4/6)

• nParticipants : ℕ

  Number of participants

def BillEtAl2025.instReprConditionResult.repr : ConditionResult → ℕ → Std.Format

Equations

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

@[implicit_reducible]

instance BillEtAl2025.instReprConditionResult : Repr ConditionResult

Equations

• BillEtAl2025.instReprConditionResult = { reprPrec := BillEtAl2025.instReprConditionResult.repr }

def BillEtAl2025.georgianAccuracy : List ConditionResult

Georgian accuracy data (approximate from Figure 4). Adults near ceiling across all conditions. Children lower but no significant sentence-type effect on accuracy.

Equations

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

structure BillEtAl2025.ErrorBreakdown : Type

Error categories for Georgian children (footnote 12). Of 103 total errors:

• 73% placed unmentioned objects (possible ad-hoc implicature failure: children may not derive "nothing else is on the table")
• 20% placed only one of the mentioned objects
• 7% placed neither mentioned object

• totalErrors : ℕ
• unmentionedObjectsPct : ℕ

  Placed unmentioned objects on the table

• oneConjunctOnlyPct : ℕ

  Placed only one of two mentioned objects

• neitherConjunctPct : ℕ

  Placed neither mentioned object

@[implicit_reducible]

instance BillEtAl2025.instReprErrorBreakdown : Repr ErrorBreakdown

Equations

• BillEtAl2025.instReprErrorBreakdown = { reprPrec := BillEtAl2025.instReprErrorBreakdown.repr }

def BillEtAl2025.instReprErrorBreakdown.repr : ErrorBreakdown → ℕ → Std.Format

Equations

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

def BillEtAl2025.georgianChildErrors : ErrorBreakdown

Equations

• BillEtAl2025.georgianChildErrors = { totalErrors := 103, unmentionedObjectsPct := 73, oneConjunctOnlyPct := 20, neitherConjunctPct := 7 }

theorem BillEtAl2025.error_pcts_sum : georgianChildErrors.unmentionedObjectsPct + georgianChildErrors.oneConjunctOnlyPct + georgianChildErrors.neitherConjunctPct = 100

Error percentages sum to 100.

structure BillEtAl2025.LRTResult : Type

Result of a Likelihood Ratio Test comparing nested models.

We encode statistical test results as data, not as theorems about the underlying population. A non-significant result means the test did not detect an effect — not that no effect exists.

• effect : String
• df : ℕ
• chiSquared : Float
• pValue : Float
• significant : Bool

  Whether p < .05 (conventional threshold)

@[implicit_reducible]

instance BillEtAl2025.instReprLRTResult : Repr LRTResult

Equations

• BillEtAl2025.instReprLRTResult = { reprPrec := BillEtAl2025.instReprLRTResult.repr }

def BillEtAl2025.instReprLRTResult.repr : LRTResult → ℕ → Std.Format

Equations

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

def BillEtAl2025.georgianAccuracyLRT : List LRTResult

Table 1: LRT results for Georgian accuracy.

Only group is significant — sentence-type effect NOT detected. NOTE: This is a null result. The act-out task allowed unlimited replays, which may have washed out accuracy differences (see Section 3.1.2).

Equations

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

def BillEtAl2025.georgianSentencePlayedLRT : List LRTResult

Table 2: LRT results for Georgian sentence-played-n.

All effects significant — this is where the key finding emerges.

Equations

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

structure BillEtAl2025.PairwiseComparison : Type

Pairwise comparison for sentence-played-n (Table 3). Tukey-adjusted p-values. Values on log scale, encoded as thousandths (e.g., -176 = -0.176) so that comparisons are decidable.

• group : Group
• contrast : String
• estimate_thou : ℤ

  Estimate on log scale, in thousandths (-176 = -0.176)

• se_thou : ℕ

  Standard error in thousandths

• df : ℕ
• tRatio_thou : ℤ

  t-ratio in thousandths

• pValue_tenThou : ℕ

  p-value in ten-thousandths (1 = 0.0001, 670 = 0.067)

• significant : Bool

def BillEtAl2025.instReprPairwiseComparison.repr : PairwiseComparison → ℕ → Std.Format

Equations

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

@[implicit_reducible]

instance BillEtAl2025.instReprPairwiseComparison : Repr PairwiseComparison

Equations

• BillEtAl2025.instReprPairwiseComparison = { reprPrec := BillEtAl2025.instReprPairwiseComparison.repr }

def BillEtAl2025.georgianChild_j_vs_jmu : PairwiseComparison

Georgian children: J vs J-MU (p < .0001). Negative = J-MU harder.

Equations

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

def BillEtAl2025.georgianChild_j_vs_mu : PairwiseComparison

Georgian children: J vs MU (p = .067, marginal).

Equations

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

def BillEtAl2025.georgianChild_jmu_vs_mu : PairwiseComparison

Georgian children: J-MU vs MU (p < .01). Positive = J-MU harder.

Equations

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

def BillEtAl2025.georgianChildPairwise : List PairwiseComparison

Equations

• BillEtAl2025.georgianChildPairwise = [BillEtAl2025.georgianChild_j_vs_jmu, BillEtAl2025.georgianChild_j_vs_mu, BillEtAl2025.georgianChild_jmu_vs_mu]

def BillEtAl2025.georgianAdultPairwise : List PairwiseComparison

Adults show no pairwise differences (all p > .6).

Equations

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

def BillEtAl2025.hungarianAccuracyLRT : List LRTResult

Table 4: LRT results for Hungarian accuracy.

No significant effects detected. NOTE: Null result — Hungarian children were somewhat older-behaving than Georgian children despite being younger (see fn. 4).

Equations

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

def BillEtAl2025.hungarianSentencePlayedLRT : List LRTResult

Table 5: LRT results for Hungarian sentence-played-n.

Only group significant — sentence-type effect NOT detected. NOTE: Null result for sentence-type. Could reflect: (a) no actual difference, (b) insufficient power (n=25 children), (c) Hungarian MU (free morpheme "is") being easier than Georgian MU (bound clitic "-c"), washing out complexity effects.

Equations

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

theorem BillEtAl2025.georgian_child_jmu_harder_than_j : georgianChild_j_vs_jmu.significant = true ∧ georgianChild_j_vs_jmu.estimate_thou < 0

Georgian children replayed J-MU sentences significantly more than J sentences.

This is the OPPOSITE of what @cite{mitrovic-sauerland-2016} + Transparency Principle predicts. The prediction was that J-MU (most transparent) should be EASIEST.

Negative estimate means J < J-MU in replay count (J-MU harder).

theorem BillEtAl2025.georgian_child_jmu_harder_than_mu : georgianChild_jmu_vs_mu.significant = true ∧ georgianChild_jmu_vs_mu.estimate_thou > 0

Georgian children replayed J-MU sentences significantly more than MU sentences.

Positive estimate means J-MU > MU in replay count (J-MU harder).

theorem BillEtAl2025.georgian_child_j_vs_mu_not_significant : georgianChild_j_vs_mu.significant = false

No significant difference between J and MU for Georgian children.

NOTE: This is a null result (p = .067, marginal). We record the non-significance but do NOT assert that J and MU are equally difficult.

def BillEtAl2025.transparencyPredicts (s1 s2 : Features.Coordination.ConjunctionStrategy) : Bool

The Transparency Principle: Learning is easier for overt and unambiguous (1-to-1) form-meaning mappings than for covert and/or conflated (many-to-1) mappings.

Equations

• BillEtAl2025.transparencyPredicts s1 s2 = decide (s1.overtMorphemeCount > s2.overtMorphemeCount)

theorem BillEtAl2025.jmu_predicted_most_transparent : transparencyPredicts Features.Coordination.ConjunctionStrategy.jMu Features.Coordination.ConjunctionStrategy.jOnly = true ∧ transparencyPredicts Features.Coordination.ConjunctionStrategy.jMu Features.Coordination.ConjunctionStrategy.muOnly = true

@cite{mitrovic-sauerland-2016} + Transparency Principle predicts J-MU is more transparent than both J-only and MU-only.

theorem BillEtAl2025.georgian_contradicts_transparency : transparencyPredicts Features.Coordination.ConjunctionStrategy.jMu Features.Coordination.ConjunctionStrategy.jOnly = true ∧ georgianChild_j_vs_jmu.estimate_thou < 0

The Georgian sentence-played-n data contradicts this prediction: J-MU was HARDER (more replays), not easier. The significant pairwise comparisons go in the wrong direction.

Link to Phenomena/Gradability/Imprecision/FormMeaning.lean

The Transparency Principle is the acquisition-side counterpart of the No Needless Manner Violations principle formalized in FormMeaning.lean.

Both principles relate form complexity to meaning:

• NNMV: More complex form → more precise meaning
• Transparency: More overt form-meaning mapping → easier acquisition

The andBoth datum in FormMeaning.lean is particularly relevant: "Ann and Bert" (J-only) vs "both Ann and Bert" (≈ J+MU). "Both" adds precision (removes homogeneity gap) — it's arguably an overt realization of MU/distributivity, paralleling the J-MU strategy.

Bill et al.'s finding complicates this picture: in Georgian, adding overt MU+J (maximum transparency) made comprehension HARDER, suggesting that morphological complexity can outweigh transparency benefits.

Link to Phenomena/AdditiveParticles/Data.lean

Japanese "mo" (listed as an additive particle in AdditiveParticles/Data.lean) is the canonical MU particle in Mitrović & Sauerland's framework. In conjunction, "mo...mo" = MU-only strategy:

Taroo-mo Hanako-mo neta Taro-MU Hanako-MU slept "Both Taro and Hanako slept"

Similarly, Hungarian "is" and Georgian "-c" serve as both additive particles and conjunction MU particles — unifying two phenomena under a single morpheme.

Semantic Decomposition (@cite{mitrovic-sauerland-2016})

The M&S decomposition maps onto operations in Montague/Conjunction.lean:

M&S piece	Semantic operation	Conjunction.lean
☉	{x} formation	msShift (= Partee's ident)
MU	INCL (subset)	typeRaise (structural abbrev)
J	Set intersection	genConj at GQ type

MU IS typeRaise — the identity is structural (an abbrev), not a theorem. coordEntities is defined AS genConj(typeRaise e₁, typeRaise e₂), so the M&S derivation is the definition itself. The result P(e₁) ∧ P(e₂) equals Link's distMaximal P {e₁, e₂} (mu_is_distributive_check).

theorem BillEtAl2025.typeRaise_incl_reduces {F : Core.Logic.Intensional.Frame} (e : F.Entity) (p : F.Entity → Prop) : Core.Logic.Intensional.Conjunction.typeRaise e p = p e

Type-raising an entity and checking subset inclusion of its singleton is equivalent to applying the predicate directly.

This is the core of the M&S decomposition: the roundtrip through ☉ + MU + J recovers ordinary conjunction semantics.

theorem BillEtAl2025.ms_decomposition_eq_coord {F : Core.Logic.Intensional.Frame} (e1 e2 : F.Entity) (p : F.Entity → Prop) : (Core.Logic.Intensional.Conjunction.typeRaise e1 p ∧ Core.Logic.Intensional.Conjunction.typeRaise e2 p) = Core.Logic.Intensional.Conjunction.coordEntities e1 e2 p

Full M&S derivation: "DP₁ and DP₂ VP" via ☉ + MU + J yields the same result as Partee & Rooth's coordEntities.

MU IS Distributive Predication

The M&S decomposition and Link's distributive inference are the same operation. Both reduce to: check a predicate against each entity individually and conjoin.

Framework	Operation	Result
M&S	J(typeRaise(e₁), typeRaise(e₂))(P)	P(e₁) ∧ P(e₂)
Link	distMaximal P {e₁, e₂} w	P(e₁) ∧ P(e₂)

The M&S side is structural: coordEntities IS genConj(typeRaise e₁, typeRaise e₂) by definition, and MU IS typeRaise by abbrev. The Link side is independently structural: distMaximal IS decide (∀ a ∈ x, P a w).

The theorem below bridges the two type systems (Montague Frame.Entity vs Finset Atom). This bridge can't be made structural — the types are different — but it proves the same operation is being computed.

This explains WHY MU particles are universally additive particles (mu_additive_generalization): additive "also/too" IS the distributive check on a single atom (typeRaise e P = P e = distMaximal P {e}). Conjunction is the two-atom case. Link's distr_atom_part is the general case for arbitrary pluralities.

theorem BillEtAl2025.mu_is_distributive_check {F : Core.Logic.Intensional.Frame} [DecidableEq F.Entity] (e1 e2 : F.Entity) (P : F.Entity → Unit → Prop) [(a : F.Entity) → (u : Unit) → Decidable (P a u)] : (Core.Logic.Intensional.Conjunction.coordEntities e1 e2 fun (a : F.Denot Core.Logic.Intensional.Ty.e) => P a ()) ↔ Semantics.Plurality.Distributivity.distMaximal P {e1, e2} ()

M&S conjunction = Link's distributive predication for pairs.

coordEntities e₁ e₂ P = distMaximal (fun a _ => P a) {e₁, e₂} ()

Both sides compute P(e₁) ∧ P(e₂):

• LHS by definition (coordEntities = genConj(typeRaise e₁, typeRaise e₂))
• RHS by distMaximal_pair

This can't be an abbrev — the types are different (Montague Frame.Entity vs Finset Atom). The theorem is the right tool for cross-theory unification.

theorem BillEtAl2025.ms_universality_challenged : Phenomena.Coordination.Studies.Haspelmath2007.hasAllThreeStrategies Phenomena.Coordination.Studies.Haspelmath2007.georgian = true ∧ transparencyPredicts Features.Coordination.ConjunctionStrategy.jMu Features.Coordination.ConjunctionStrategy.jOnly = true ∧ georgianChild_j_vs_jmu.significant = true ∧ georgianChild_j_vs_jmu.estimate_thou < 0

M&S universality challenged.

Georgian has all three strategies (J-only, MU-only, J-MU). M&S + Transparency predicts J-MU should be easiest (most transparent). But Georgian children found J-MU significantly harder (more replays).

theorem BillEtAl2025.boundness_confound : Phenomena.Coordination.Studies.Haspelmath2007.georgian.muBoundness = some Features.Coordination.Boundness.bound ∧ Phenomena.Coordination.Studies.Haspelmath2007.hungarian.muBoundness = some Features.Coordination.Boundness.free ∧ georgianChild_j_vs_jmu.significant = true ∧ ((List.filter (fun (x : LRTResult) => x.effect == "sentence") hungarianSentencePlayedLRT).all fun (x : LRTResult) => x.significant == false) = true

The boundness confound.

Georgian MU (-c) is bound; Hungarian MU (is) is free. Hungarian children showed no significant sentence-type effect on either accuracy or replays. This raises the possibility that morphological boundness — not the M&S decomposition itself — drives the Georgian difficulty.

If boundness is the real factor, then M&S categories (J, MU, J-MU) are not the right level of analysis for acquisition predictions.