Longobardi (2005): Toward a Unified Grammar of Reference

@cite{longobardi-2005} @cite{longobardi-1994}

Zeitschrift für Sprachwissenschaft 24(1): 5–44.

Core Contribution

A syntax–semantics mapping theory reducing reference to nominal head position: a nominal refers to an individual (constant) iff its D position contains referential content. This unifies object reference and kind reference under a single structural generalization.

The paper rests on two axioms and a licensing condition, from which the Core Generalization — reference (to individuals) iff N-to-D — follows as a theorem.

Axioms

• (52) Denotation Hypothesis: individuals are denoted in D.
• (53) Licensing Condition: arguments denote individuals.
• (54) Constants vs Variables: a referential value is constant if a lexically referential expression occupies (or chains to) D; otherwise the argument is a variable bound by an operator.

Derived Theorems

• (55) arguments with empty D are variables.
• (56) an argument is a constant only if D contains a lexically referential expression.
• (33) Core Generalization: reference (to individuals) iff N-to-D.

File Structure

§1–§4 formalize the axioms, derived theorems, and noun taxonomy. §5–§7 formalize the Last Resort consequences and the bridge to the character semantics of Reference/Basic. §8–§13 instantiate the theory: N-to-D raising as head movement, Italian solo diagnostic, expletive articles, and the bridge to @cite{longobardi-2001}'s DPParameter/ArgumentType.

inductive Longobardi2005.NominalHeadClass : Type

The four classes of nominal heads, ranked from most prototypically referential (pronouns) to least (common nouns).

@cite{longobardi-2005} table (28): these four classes are distinguished by three tests — object-referentiality (in D), predicative restrictions (not in D), and kind-referentiality (with definite article).

• pronoun : NominalHeadClass

  Always in D in all argument environments. Object-referential only. Cannot function predicatively or as kind-denoting expressions.

• properName : NominalHeadClass

  Raise to D obligatorily in argument function (Romance). Object-referential. Predicative use conditioned. No kind reading.

• specialCommon : NominalHeadClass

  Raise to D only under special conditions (genitive modifier, deictic context). Object-referential when raised. Full predicative use. Kind-referential with definite article. Examples: casa 'home', mamma 'mom', lunedì 'Monday'.

• commonNoun : NominalHeadClass

  Never raise to D. Never object-referential. Full predicative use. Kind-referential with definite article.

@[implicit_reducible]

instance Longobardi2005.instDecidableEqNominalHeadClass : DecidableEq NominalHeadClass

Equations

• Longobardi2005.instDecidableEqNominalHeadClass x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

@[implicit_reducible]

instance Longobardi2005.instReprNominalHeadClass : Repr NominalHeadClass

Equations

• Longobardi2005.instReprNominalHeadClass = { reprPrec := Longobardi2005.instReprNominalHeadClass.repr }

def Longobardi2005.instReprNominalHeadClass.repr : NominalHeadClass → ℕ → Std.Format

Equations

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

def Longobardi2005.ObjectReferential : NominalHeadClass → Prop

Object-referential: the nominal can denote a specific object (individual in Carlson's sense) by occupying the D position.

Equations

• Longobardi2005.ObjectReferential Longobardi2005.NominalHeadClass.pronoun = True
• Longobardi2005.ObjectReferential Longobardi2005.NominalHeadClass.properName = True
• Longobardi2005.ObjectReferential Longobardi2005.NominalHeadClass.specialCommon = True
• Longobardi2005.ObjectReferential Longobardi2005.NominalHeadClass.commonNoun = False

@[implicit_reducible]

instance Longobardi2005.instDecidablePredNominalHeadClassObjectReferential : DecidablePred ObjectReferential

Equations

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

def Longobardi2005.CanBePredicate : NominalHeadClass → Prop

Can function as a predicate (i.e., survive without D).

Equations

• Longobardi2005.CanBePredicate Longobardi2005.NominalHeadClass.pronoun = False
• Longobardi2005.CanBePredicate Longobardi2005.NominalHeadClass.properName = True
• Longobardi2005.CanBePredicate Longobardi2005.NominalHeadClass.specialCommon = True
• Longobardi2005.CanBePredicate Longobardi2005.NominalHeadClass.commonNoun = True

@[implicit_reducible]

instance Longobardi2005.instDecidablePredNominalHeadClassCanBePredicate : DecidablePred CanBePredicate

Equations

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

def Longobardi2005.KindReferential : NominalHeadClass → Prop

Kind-referential: can denote a kind when introduced by definite article.

Equations

• Longobardi2005.KindReferential Longobardi2005.NominalHeadClass.pronoun = False
• Longobardi2005.KindReferential Longobardi2005.NominalHeadClass.properName = False
• Longobardi2005.KindReferential Longobardi2005.NominalHeadClass.specialCommon = True
• Longobardi2005.KindReferential Longobardi2005.NominalHeadClass.commonNoun = True

@[implicit_reducible]

instance Longobardi2005.instDecidablePredNominalHeadClassKindReferential : DecidablePred KindReferential

Equations

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

def Longobardi2005.RaisingObligatory : NominalHeadClass → Prop

Whether N-to-D raising is obligatory in argument position.

Equations

• Longobardi2005.RaisingObligatory Longobardi2005.NominalHeadClass.pronoun = True
• Longobardi2005.RaisingObligatory Longobardi2005.NominalHeadClass.properName = True
• Longobardi2005.RaisingObligatory Longobardi2005.NominalHeadClass.specialCommon = False
• Longobardi2005.RaisingObligatory Longobardi2005.NominalHeadClass.commonNoun = False

@[implicit_reducible]

instance Longobardi2005.instDecidablePredNominalHeadClassRaisingObligatory : DecidablePred RaisingObligatory

Equations

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

def Longobardi2005.propernessRank : NominalHeadClass → ℕ

The scalar hierarchy of properness from @cite{longobardi-2005} (25).

Nominal expressions are ranked along a scale from most prototypically proper-like to most common-like. Access to the N-to-D derivational strategy decreases monotonically along this scale.

a. Pronouns: always in D. b. Names of persons, geographical units: raise whenever D is empty. c. Names of days: raise only under particular semantic conditions. d. Casa, kinship terms: raise only if followed by genitive modifier. e. Normal common nouns: never raise.

Equations

• Longobardi2005.propernessRank Longobardi2005.NominalHeadClass.pronoun = 0
• Longobardi2005.propernessRank Longobardi2005.NominalHeadClass.properName = 1
• Longobardi2005.propernessRank Longobardi2005.NominalHeadClass.specialCommon = 2
• Longobardi2005.propernessRank Longobardi2005.NominalHeadClass.commonNoun = 3

theorem Longobardi2005.raising_monotone (c₁ c₂ : NominalHeadClass) : propernessRank c₁ ≤ propernessRank c₂ → RaisingObligatory c₂ → RaisingObligatory c₁

Raising access decreases monotonically with properness rank: if class c₁ is more proper than c₂, then c₁'s raising is at least as obligatory as c₂'s.

inductive Longobardi2005.LexicalNamingType : Type

The lexical type of a noun: whether it names objects or kinds.

@cite{longobardi-2005} §4: nouns lexically divide into object-naming (proper names, pronouns — intrinsically referential) and kind-naming (common nouns — denote kinds, not individuals).

• objectNaming : LexicalNamingType

  Object-naming: learning the name means learning to apply it to a particular object. Proper names, pronouns.

• kindNaming : LexicalNamingType

  Kind-naming: learning the name means learning to recognize a potentially open set of objects. Common nouns.

@[implicit_reducible]

instance Longobardi2005.instDecidableEqLexicalNamingType : DecidableEq LexicalNamingType

Equations

• Longobardi2005.instDecidableEqLexicalNamingType x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Longobardi2005.instReprLexicalNamingType.repr : LexicalNamingType → ℕ → Std.Format

Equations

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

@[implicit_reducible]

instance Longobardi2005.instReprLexicalNamingType : Repr LexicalNamingType

Equations

• Longobardi2005.instReprLexicalNamingType = { reprPrec := Longobardi2005.instReprLexicalNamingType.repr }

structure Longobardi2005.NominalConfig : Type

A nominal argument configuration, capturing the syntactic and semantic state of a DP in argument position.

• namingType : LexicalNamingType

  The head noun's lexical naming type.

• dHasReferentialContent : Bool

  Does D contain a lexically referential expression? (either an overt determiner/quantifier, or N raised to D, or an expletive article linked to a raised N in a CHAIN)

• isArgument : Bool

  Is the nominal in argument function?

@[implicit_reducible]

instance Longobardi2005.instDecidableEqNominalConfig : DecidableEq NominalConfig

Equations

• Longobardi2005.instDecidableEqNominalConfig = Longobardi2005.instDecidableEqNominalConfig.decEq

def Longobardi2005.instDecidableEqNominalConfig.decEq (x✝ x✝¹ : NominalConfig) : Decidable (x✝ = x✝¹)

Equations

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

@[implicit_reducible]

instance Longobardi2005.instReprNominalConfig : Repr NominalConfig

Equations

• Longobardi2005.instReprNominalConfig = { reprPrec := Longobardi2005.instReprNominalConfig.repr }

def Longobardi2005.instReprNominalConfig.repr : NominalConfig → ℕ → Std.Format

Equations

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

def Longobardi2005.denotesIndividual (nc : NominalConfig) : Bool

(52) Denotation Hypothesis: individuals are denoted in D.

The D position is the locus of referential interpretation. A nominal denotes an individual (object or kind) iff its D position is associated with referential content.

Equations

• Longobardi2005.denotesIndividual nc = nc.dHasReferentialContent

def Longobardi2005.argumentLicensed (nc : NominalConfig) : Bool

(53) Licensing Condition: arguments denote individuals.

Full Interpretation requires arguments to have a referential value (whether constant or variable).

Equations

• Longobardi2005.argumentLicensed nc = (!nc.isArgument || Longobardi2005.denotesIndividual nc)

def Longobardi2005.isConstant (nc : NominalConfig) : Bool

(54a) A constant: a fixed referential value denoting one and only one entity (kind or object). Requires D to contain (or CHAIN-link to) a lexically referential expression — either a raised N, an overt determiner, or a pronoun base-generated in D.

Equations

• Longobardi2005.isConstant nc = nc.dHasReferentialContent

def Longobardi2005.isVariable (nc : NominalConfig) : Bool

(54b) A variable: bound by an operator (existential, generic, or the variable-binding force of a lexical determiner) and ranging over a set of entities. Arises when D is empty (no referential content).

Equations

• Longobardi2005.isVariable nc = !nc.dHasReferentialContent

theorem Longobardi2005.empty_d_arguments_are_variables (nc : NominalConfig) (_hArg : nc.isArgument = true) (hEmptyD : nc.dHasReferentialContent = false) : isVariable nc = true

(55) Arguments with empty D are variables.

From (52)+(53)+(54): if D is empty, then by (52) the nominal cannot denote an individual via D. By (53) it must still denote (being an argument). By (54b) the only remaining option is variable interpretation.

theorem Longobardi2005.constant_requires_d_content (nc : NominalConfig) (hConst : isConstant nc = true) : nc.dHasReferentialContent = true

(56) An argument is a constant only if D contains a lexically referential expression.

Equivalently: constant interpretation requires N-to-D (for proper names), an overt determiner, or a pronoun in D.

theorem Longobardi2005.argument_requires_d (nc : NominalConfig) (hArg : nc.isArgument = true) (hLicensed : argumentLicensed nc = true) : denotesIndividual nc = true

(41) A nominal is an argument only if introduced by D.

@cite{longobardi-2005} §7: this principle, from @cite{szabolcsi-1987} and @cite{stowell-1989-1991}, is derived from (52)+(53). In non-argument environments (predicates, vocatives, exclamations), nominals can occur without D.

theorem Longobardi2005.proper_names_must_raise (nc : NominalConfig) : nc.namingType = LexicalNamingType.objectNaming → nc.isArgument = true → argumentLicensed nc = true → isConstant nc = true

@cite{longobardi-2005} §10, question (57c): why must proper names raise?

Object-naming nouns cannot satisfy (54b) — they name objects, not kinds, so they cannot enter the interpretive formula Dx.x ∈ kind(N) that gives variables their meaning. Their only route to argumenthood is constant interpretation via (54a), which requires D content. Since proper names are bare (no overt determiner), they must raise N-to-D to fill D.

theorem Longobardi2005.common_nouns_need_not_raise (nc : NominalConfig) : nc.namingType = LexicalNamingType.kindNaming → nc.isArgument = true → nc.dHasReferentialContent = false → isVariable nc = true

@cite{longobardi-2005} §10, question (57a): why do common nouns not have to raise?

Kind-naming nouns can satisfy (54b): they name kinds, so they can enter the formula Dx.x ∈ kind(N) as the restrictor of a variable. Empty D yields a variable bound by an existential or generic operator. No raising is needed for convergence.

inductive Longobardi2005.ArticleType : Type

Whether a definite article is expletive (semantically vacuous placeholder) or a genuine semantic operator.

@cite{longobardi-2005} §8: when a proper name appears with a definite article (la Maria, il Gianni), the article is expletive — it does not contribute uniqueness or familiarity semantics. It merely fills the D position that N-raising would otherwise occupy.

• expletive : ArticleType

  Expletive: phonological placeholder for D, no semantic content. Forms a CHAIN with the noun. la Maria ≈ Maria raised to D.

• operator : ArticleType

  Semantic operator: contributes uniqueness (ι), familiarity, or quantificational force. il tavolo 'the table' — real definite.

@[implicit_reducible]

instance Longobardi2005.instDecidableEqArticleType : DecidableEq ArticleType

Equations

• Longobardi2005.instDecidableEqArticleType x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Longobardi2005.instReprArticleType.repr : ArticleType → ℕ → Std.Format

Equations

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

@[implicit_reducible]

instance Longobardi2005.instReprArticleType : Repr ArticleType

Equations

• Longobardi2005.instReprArticleType = { reprPrec := Longobardi2005.instReprArticleType.repr }

def Longobardi2005.ExpletiveBlocksKindReading : ArticleType → Prop

An expletive article does not induce kind readings.

@cite{longobardi-2005} (46)–(47): la Maria behaves identically to bare Maria — wide scope, rigid, no generic/kind reading. This distinguishes expletive articles from genuine definite operators, which CAN induce kind readings (i cani 'the dogs' = the dog-kind).

Equations

• Longobardi2005.ExpletiveBlocksKindReading Longobardi2005.ArticleType.expletive = True
• Longobardi2005.ExpletiveBlocksKindReading Longobardi2005.ArticleType.operator = False

@[implicit_reducible]

instance Longobardi2005.instDecidablePredArticleTypeExpletiveBlocksKindReading : DecidablePred ExpletiveBlocksKindReading

Equations

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

theorem Longobardi2005.proper_name_in_d_is_constant {C : Type u_1} {W : Type u_2} {E : Type u_3} (e : E) : Semantics.Reference.Basic.isDirectlyReferential (Semantics.Reference.Basic.properName e).character ∧ Semantics.Reference.Basic.constantCharacter (Semantics.Reference.Basic.properName e).character

Proper names in D are directly referential.

Bridge connecting the syntactic analysis (N-to-D raising creates constant interpretation) to the semantic analysis (proper names have constant character and rigid content). The two perspectives converge: syntactically, D is the locus of reference; semantically, proper names are rigid designators.

structure Longobardi2005.NtoDRaising : Type

N-to-D raising is head-to-head movement within the nominal extended projection.

@cite{longobardi-2005} §5: proper names in Romance undergo N-to-D raising — the noun head moves from N to D, crossing intervening material (adjectives, modifiers in α). This is the nominal analogue of V-to-T raising (@cite{pollock-1989}).

The movement is head-to-head (not head-to-spec): the noun stays minimal and reprojects in D. Evidence: the raised name forms a morphological unit with D, not a phrasal specifier.

• nHead : NominalHeadClass

  The N head (proper name or special common noun)

• dpParam : Longobardi2001.DPParameter

  Language parametric setting

• raises : Bool

  Raising actually occurs

• obligatory : Bool

  Raising is obligatory (convergence requires it)

def Longobardi2005.italianPN : NtoDRaising

Italian proper names raise obligatorily to D.

@cite{longobardi-2005} §5: Gianni ha telefonato vs *Ha telefonato Gianni (in neutral intonation). The name must precede adjectives and modifiers that intervene between N and D.

Equations

• Longobardi2005.italianPN = { nHead := Longobardi2005.NominalHeadClass.properName, dpParam := Longobardi2001.romance, raises := true, obligatory := true }

def Longobardi2005.italianCN : NtoDRaising

Italian common nouns do NOT raise to D.

Equations

• Longobardi2005.italianCN = { nHead := Longobardi2005.NominalHeadClass.commonNoun, dpParam := Longobardi2001.romance, raises := false, obligatory := false }

def Longobardi2005.englishPN : NtoDRaising

English proper names: D is weak, so raising is vacuous (no overt D to target). Names occur bare in argument position.

Equations

• Longobardi2005.englishPN = { nHead := Longobardi2005.NominalHeadClass.properName, dpParam := Longobardi2001.english, raises := false, obligatory := false }

structure Longobardi2005.SoloDiagnostic : Type

@cite{longobardi-2005} §2: the solo paradigm. Solo 'only' is an adverb that must c-command its associate. When solo precedes a proper name but follows a common noun, this diagnoses the structural position of the noun head.

• Solo Gianni... — name has raised past solo (N-to-D)
• Il solo tavolo... — common noun stays below solo

This asymmetry is the primary diagnostic for N-to-D.

• headClass : NominalHeadClass

  The noun tested

• precedesSolo : Bool

  Does the noun precede solo?

def Longobardi2005.soloPN : SoloDiagnostic

Proper names precede solo (they have raised past it).

Equations

• Longobardi2005.soloPN = { headClass := Longobardi2005.NominalHeadClass.properName, precedesSolo := true }

def Longobardi2005.soloCN : SoloDiagnostic

Common nouns follow solo (they remain in situ).

Equations

• Longobardi2005.soloCN = { headClass := Longobardi2005.NominalHeadClass.commonNoun, precedesSolo := false }

theorem Longobardi2005.solo_diagnoses_raising : soloPN.precedesSolo = true ∧ soloCN.precedesSolo = false

The solo diagnostic confirms raising iff precedesSolo.

structure Longobardi2005.ExpletiveArticleDatum : Type

@cite{longobardi-2005} §8: Italian proper names optionally appear with a definite article (la Maria, il Gianni). This article is expletive — semantically vacuous, serving only as a phonological placeholder for D.

Evidence: la Maria behaves identically to bare Maria:

• Wide scope only (no narrow scope under quantifiers)
• Rigid reference (same individual at every world)
• No kind/generic reading This contrasts with genuine definite articles (il tavolo 'the table'), which CAN have narrow scope and kind readings.

• form : String

  The nominal expression

• articleType : ArticleType

  Article type

• wideScopeOnly : Bool

  Has wide scope only (rigid)

• kindReading : Bool

  Admits kind/generic reading

def Longobardi2005.laMaria : ExpletiveArticleDatum

Equations

• Longobardi2005.laMaria = { form := "la Maria", articleType := Longobardi2005.ArticleType.expletive, wideScopeOnly := true, kindReading := false }

def Longobardi2005.ilTavolo : ExpletiveArticleDatum

Equations

• Longobardi2005.ilTavolo = { form := "il tavolo", articleType := Longobardi2005.ArticleType.operator, wideScopeOnly := false, kindReading := true }

theorem Longobardi2005.expletive_vs_operator : ExpletiveBlocksKindReading laMaria.articleType ∧ ¬ExpletiveBlocksKindReading ilTavolo.articleType

Expletive articles block kind readings; operator articles allow them.

theorem Longobardi2005.expletive_preserves_rigidity : laMaria.wideScopeOnly = true ∧ laMaria.kindReading = false

Expletive articles preserve rigidity (wide scope only).

def Longobardi2005.argumentTypeToConfig (at_ : Longobardi2001.ArgumentType) : NominalConfig

Map @cite{longobardi-2001}'s ArgumentType to the topological mapping's constant/variable distinction.

Referential arguments = constants (D has referential content). Quantificational arguments = variables (D is empty, operator-bound).

Equations

• Longobardi2005.argumentTypeToConfig Longobardi2001.ArgumentType.referential = { namingType := Longobardi2005.LexicalNamingType.objectNaming, dHasReferentialContent := true, isArgument := true }
• Longobardi2005.argumentTypeToConfig Longobardi2001.ArgumentType.quantificational = { namingType := Longobardi2005.LexicalNamingType.kindNaming, dHasReferentialContent := false, isArgument := true }

theorem Longobardi2005.referential_is_constant : isConstant (argumentTypeToConfig Longobardi2001.ArgumentType.referential) = true

Referential arguments are constants in the topological mapping.

theorem Longobardi2005.quantificational_is_variable : isVariable (argumentTypeToConfig Longobardi2001.ArgumentType.quantificational) = true

Quantificational arguments are variables in the topological mapping.

theorem Longobardi2005.strong_d_bridge : Longobardi2001.pnRequiresOvertD Longobardi2001.romance = true ∧ Longobardi2001.pnRequiresOvertD Longobardi2001.english = false ∧ Longobardi2001.bnCanBeReferential Longobardi2001.romance = false ∧ Longobardi2001.bnCanBeReferential Longobardi2001.english = true

@cite{longobardi-2001}'s strongD parameter corresponds to the topological mapping's requirement for overt referential content in D.

When D is strong (Romance), referential interpretation requires visible association with D — either N-to-D raising or an overt determiner. When D is weak (English), the association can be covert.

theorem Longobardi2005.greek_confirms : Longobardi2001.pnRequiresOvertD Longobardi2001.greek = true ∧ Longobardi2001.bnCanBeReferential Longobardi2001.greek = false

Greek confirms the prediction: strong D + opaque α forces overt articles on all referential arguments including proper names.