Kalin (2018): Licensing and Differential Object Marking #
This file formalizes [Kal18], which derives differential object marking from nominal
licensing rather than from object visibility, raising or differentiation. Two parameters
interact: which nominals require licensing, in Senaya only the specific ones, and where the
licensers are, every clause carrying an obligatory licenser that licenses the closest nominal
whatever its needs, and secondary licensers that merge only when the derivation would otherwise
crash, the Licensing Economy Principle, (36). In Senaya the marking is verbal agreement: in the
imperfective, Asp is the obligatory licenser and agrees with the subject as an S-suffix, and T is
a secondary licenser that agrees with a specific object as an L-suffix, (43) and (47); in the
perfective, Asp is no licenser and T is obligatory, so T agrees with the subject and a specific
object cannot be licensed at all, (49) and (50), the ban of (12). The licensing derivation
reproduces the agreement data (8) to (12) and (38) whatever the specificity of the subject
(rows_agree), and the toy nominative-accusative language of §3.1 shows differential marking by
a secondary v (toy_animate_object, toy_inanimate_object). The perfective ban is the paper's
argument against a theory without licensing: the dependent-case rules of [Mar91] value the
perfective object accusative, but a specific object there crashes
(dependentCase_values_banned_object).
The theory is formalized first. Every nominal bears a Case feature, unvalued unless a lexical
head has valued it, so every nominal is visible to a licenser; only some bear uninterpretable
Case ([PT07]), and those alone crash the derivation when it goes unvalued. A
licenser is a head with a φ-probe that Agrees with the highest nominal in the phase domain it
probes whose Case is unvalued, the Agree of Minimalist.agreeValue, and a secondary licenser
merges only as a last resort ([Rez11]). The derivation never sees which nominals need
licensing, since it runs on positions alone, and needs are read only by convergence. Licensing
is monotone in the licensers (license_mono), so the Licensing Economy Principle stated for each
secondary licenser coincides with the preference for a derivation with fewer licensers
(economical_iff). Licensing is the Agree modality of case assignment of
[BV10]: case assigners with no dependent or elsewhere case assign exactly what
the licensing derivation does (assign_eq_map_license).
Implementation notes #
- The agreement suffix is read off the licensing head, the S-suffix from Asp and the L-suffix from T, the analysis of [KvU15] that the paper adopts in §4.1.
- In Senaya v is not a phase head (§4.1), so both arguments are in the domain T and Asp probe; in the toy language the object is in the domain of v, which the subject is not.
- Nominals are listed from the highest down; the licensers probing one phase domain are listed in merge order, the lowest first, and the domains spell out in the order given.
- Only structural licensing under c-command is modelled: an inherent licenser that values only its specifier is not.
- Word order and the position of agreement within the verbal complex are not modelled.
References #
Licensers and nominals #
Whether a licenser merges in every derivation or only as a last resort.
- obligatory : LicenserKind
- secondary : LicenserKind
Instances For
Equations
- Kalin2018.instDecidableEqLicenserKind x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯
Equations
- One or more equations did not get rendered due to their size.
Instances For
Equations
- Kalin2018.instReprLicenserKind = { reprPrec := Kalin2018.instReprLicenserKind.repr }
A licenser: a head with a φ-probe, the phase whose domain it probes, and whether it merges in every derivation.
- head : Minimalist.Cat
- domain : Minimalist.Cat
- kind : LicenserKind
Instances For
Equations
- One or more equations did not get rendered due to their size.
Instances For
Equations
- Kalin2018.instReprLicenser = { reprPrec := Kalin2018.instReprLicenser.repr }
Equations
- One or more equations did not get rendered due to their size.
Instances For
A nominal together with whether it bears uninterpretable Case and so needs licensing.
- lexicalCase : Option Case
- shifted : Bool
- needsLicensing : Bool
Instances For
Equations
- One or more equations did not get rendered due to their size.
Instances For
Equations
- Kalin2018.instReprLicensedNP = { reprPrec := Kalin2018.instReprLicensedNP.repr }
Equations
- One or more equations did not get rendered due to their size.
Instances For
Equations
- Kalin2018.instDecidableEqCaseValue.decEq (Kalin2018.CaseValue.lexical a) (Kalin2018.CaseValue.lexical b) = if h : a = b then h ▸ isTrue ⋯ else isFalse ⋯
- Kalin2018.instDecidableEqCaseValue.decEq (Kalin2018.CaseValue.lexical c) (Kalin2018.CaseValue.licenser l) = isFalse ⋯
- Kalin2018.instDecidableEqCaseValue.decEq (Kalin2018.CaseValue.licenser l) (Kalin2018.CaseValue.lexical c) = isFalse ⋯
- Kalin2018.instDecidableEqCaseValue.decEq (Kalin2018.CaseValue.licenser a) (Kalin2018.CaseValue.licenser b) = if h : a = b then h ▸ isTrue ⋯ else isFalse ⋯
Instances For
Equations
- Kalin2018.instReprCaseValue = { reprPrec := Kalin2018.instReprCaseValue.repr }
Equations
- One or more equations did not get rendered due to their size.
Instances For
The derivation #
The Case of each nominal before any licenser probes: valued only by a lexical head.
Equations
- Kalin2018.initial nps = Case.Valuation.initial (fun (x : Minimalist.PhasedNP) => Option.map Kalin2018.CaseValue.lexical x.lexicalCase) nps
Instances For
The Agree of licenser l.
Equations
- l.agree = Minimalist.agreeValue (fun (x : Minimalist.PhasedNP) => x.visible l.domain) (Kalin2018.CaseValue.licenser l)
Instances For
The licensers probing the domain of c merge, the lowest first.
Equations
- One or more equations did not get rendered due to their size.
Instances For
The derivation: the phase domains ds spell out in order, each with its licensers.
Equations
- Kalin2018.license ds ls nps = List.foldl (fun (st : Case.Valuation Minimalist.PhasedNP Kalin2018.CaseValue) (c : Minimalist.Cat) => Kalin2018.cycle ls c st) (Kalin2018.initial nps) ds
Instances For
A derivation converges iff every nominal that needs licensing has its Case valued.
Equations
- One or more equations did not get rendered due to their size.
Instances For
Equations
- Kalin2018.instDecidableConverges ds ls nps = Kalin2018.instDecidableConverges._aux_1 ds ls nps
A nominal is DOM-marked iff a secondary licenser valued its Case.
Equations
- Kalin2018.IsDOMMarked (some (Kalin2018.CaseValue.licenser l)) = (l.kind = Kalin2018.LicenserKind.secondary)
- Kalin2018.IsDOMMarked x✝ = False
Instances For
Equations
- Kalin2018.instDecidablePredOptionCaseValueIsDOMMarked (some (Kalin2018.CaseValue.licenser l)) = Kalin2018.instDecidablePredOptionCaseValueIsDOMMarked._aux_1 l
- Kalin2018.instDecidablePredOptionCaseValueIsDOMMarked (some (Kalin2018.CaseValue.lexical c)) = { decide := false, reflects_decide := ⋯ }
- Kalin2018.instDecidablePredOptionCaseValueIsDOMMarked none = { decide := false, reflects_decide := Kalin2018.instDecidablePredOptionCaseValueIsDOMMarked._proof_4 }
A licenser values the highest nominal of its domain if that nominal's Case is unvalued.
A licenser passes over a nominal whose Case is already valued.
The derivation extends the lexical valuation, each value it adds naming a licenser of the clause.
Every licenser that values a nominal's Case is a licenser of the clause.
Monotonicity #
Adding licensers to a clause never leaves a nominal unvalued.
A clause with no nominal that needs licensing converges.
The Licensing Economy Principle #
The licensers of a clause when the secondaries in S are activated: the obligatory ones
and the activated ones, in place.
Equations
- Kalin2018.activate ls S = List.filter (fun (l : Kalin2018.Licenser) => decide (l.kind = Kalin2018.LicenserKind.obligatory ∨ l ∈ S)) ls
Instances For
An activation is economical iff it converges and no activation of fewer licensers does: the derivation with fewer licensers is preferred.
Equations
- Kalin2018.Economical ds ls nps S = Minimal (fun (S : Finset Kalin2018.Licenser) => Kalin2018.Converges ds (Kalin2018.activate ls S) nps) S
Instances For
The Licensing Economy Principle, (36) of [Kal18]: an activation is economical iff it converges and each activated secondary licenser is activated because the derivation would otherwise not converge.
Equations
- One or more equations did not get rendered due to their size.
Every activated licenser is a secondary licenser of the clause.
An economical activation exists iff the clause converges with all its licensers.
If the obligatory licensers suffice, no secondary licenser is activated.
If the obligatory licensers suffice, the economical derivation marks no nominal.
Licensing as the Agree modality of case assignment #
The case and mechanism a Case value amounts to: the lexical case, or under Agree the case
κ gives the licensing head.
Equations
Instances For
Licensing is the Agree modality of case assignment: case assigners with no dependent or
elsewhere case in any domain, under which each licenser's head values the case κ gives it,
assign what the licensing derivation does, each licenser read as that case.
Senaya's licensers #
Imperfective Asp, the obligatory licenser of the imperfective, (43).
Equations
- Kalin2018.aspImpf = { head := Minimalist.Cat.Asp, kind := Kalin2018.LicenserKind.obligatory }
Instances For
The T selecting imperfective Asp, a secondary licenser, (43).
Equations
- Kalin2018.tImpf = { head := Minimalist.Cat.T, kind := Kalin2018.LicenserKind.secondary }
Instances For
The T selecting perfective Asp, the one obligatory licenser of the perfective, (49).
Equations
- Kalin2018.tPfv = { head := Minimalist.Cat.T, kind := Kalin2018.LicenserKind.obligatory }
Instances For
The imperfective's licensers in merge order: Asp, then T.
Equations
Instances For
The perfective's licenser: T alone.
Equations
Instances For
The one phase domain of a Senaya clause, v being no phase head.
Equations
Instances For
The agreement suffix a licensing head yields, an S-suffix from Asp and an L-suffix from T.
Instances For
Equations
- Kalin2018.instDecidableEqSuffix x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯
Equations
- Kalin2018.instReprSuffix = { reprPrec := Kalin2018.instReprSuffix.repr }
Equations
- Kalin2018.instReprSuffix.repr Kalin2018.Suffix.S prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Kalin2018.Suffix.S")).group prec✝
- Kalin2018.instReprSuffix.repr Kalin2018.Suffix.L prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Kalin2018.Suffix.L")).group prec✝
Instances For
The suffix agreement with a head yields.
Equations
Instances For
The suffix of a nominal's Case value: that of the head that licensed it, if any.
Equations
- Kalin2018.suffixOf (some (Kalin2018.CaseValue.licenser l)) = Kalin2018.headSuffix l.head
- Kalin2018.suffixOf x✝ = none
Instances For
A Senaya nominal, which needs licensing exactly when specific, (40) to (42).
Equations
- Kalin2018.nominal specific = { needsLicensing := specific }
Instances For
A transitive clause's subject and object.
Equations
- Kalin2018.transitive subject object = [Kalin2018.nominal subject, Kalin2018.nominal object]
Instances For
The agreement data (Section 2.1) #
A suffix feature value.
Equations
- Kalin2018.suffixFeature "S" = some (some Kalin2018.Suffix.S)
- Kalin2018.suffixFeature "L" = some (some Kalin2018.Suffix.L)
- Kalin2018.suffixFeature "none" = some none
- Kalin2018.suffixFeature x✝ = none
Instances For
A row from the paper's features.
Equations
- One or more equations did not get rendered due to their size.
Instances For
The Senaya data, (8) to (12) and (38).
Equations
- Kalin2018.rows = List.filterMap Kalin2018.Row.ofDatum Kalin2018.Examples.all
Instances For
The nominals of a row: a subject of the given specificity, and the row's object if any.
Equations
- r.nominals subject = Kalin2018.nominal subject :: (Option.map Kalin2018.nominal r.object).toList
Instances For
The suffixes of a row: the subject's, then the object's if there is an object.
Equations
- r.suffixes = some r.subjectSuffix :: (Option.map (fun (x : Bool) => r.objectSuffix) r.object).toList
Instances For
The suffixes a derivation spells out, nominal by nominal.
Equations
- Kalin2018.suffixes st = List.map (fun (x : Minimalist.PhasedNP × Option Kalin2018.CaseValue) => Kalin2018.suffixOf x.2) st
Instances For
Licensing reproduces the data whatever the specificity of the subject: a sentence is grammatical exactly when some activation of the licensers is economical, so that a specific object in the perfective crashes, and under every economical activation the subject carries the suffix of the obligatory licenser and the object the L-suffix exactly when it is specific, the secondary T having been activated for it.
The object agreement is differential marking: a specific object in the imperfective is licensed by the secondary T, activated for it alone, (47), and a nonspecific object activates nothing and goes unlicensed, (48).
The toy language of Section 3.1 #
Finite T, the obligatory licenser of the toy language.
Equations
- Kalin2018.toyT = { head := Minimalist.Cat.T, kind := Kalin2018.LicenserKind.obligatory }
Instances For
v, a secondary licenser probing its own domain.
Equations
- Kalin2018.toyV = { head := Minimalist.Cat.v, domain := Minimalist.Cat.v, kind := Kalin2018.LicenserKind.secondary }
Instances For
The toy language's licensers.
Equations
Instances For
The toy language's phase domains, v's spelling out before C's.
Equations
Instances For
A transitive clause of the toy language, in which a nominal needs licensing exactly when animate: the subject above v, the object in its domain.
Equations
- Kalin2018.toyTransitive subject object = [{ needsLicensing := subject }, { phase := Minimalist.Cat.v, needsLicensing := object }]
Instances For
An animate object activates v, which licenses it: T licenses the subject whatever its animacy and never the object, so without v the derivation crashes, (24).
An inanimate object activates nothing and goes unlicensed and unmarked, (23).
Licensing against dependent case #
The perfective ban is an argument for licensing (Section 2.1.3): the dependent-case rules of an accusative language value a specific perfective object accusative, but licensing leaves it unvalued, and the derivation crashes whatever the specificity of the subject.