Documentation

Studies.Kalin2018

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 #

References #

Licensers and nominals #

Whether a licenser merges in every derivation or only as a last resort.

Instances For
    @[instance_reducible]
    Equations
    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      A licenser: a head with a φ-probe, the phase whose domain it probes, and whether it merges in every derivation.

      Instances For
        def Kalin2018.instDecidableEqLicenser.decEq (x✝ x✝¹ : Licenser) :
        Decidable (x✝ = x✝¹)
        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          @[instance_reducible]
          Equations
          def Kalin2018.instReprLicenser.repr :
          Licenser → ℕ → Std.Format
          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.

            Instances For
              def Kalin2018.instDecidableEqLicensedNP.decEq (x✝ x✝¹ : LicensedNP) :
              Decidable (x✝ = x✝¹)
              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                def Kalin2018.instReprLicensedNP.repr :
                LicensedNP → ℕ → Std.Format
                Equations
                • One or more equations did not get rendered due to their size.
                Instances For

                  What valued a nominal's Case: a lexical head, with the case it assigned, or a licenser.

                  Instances For
                    def Kalin2018.instReprCaseValue.repr :
                    CaseValue → ℕ → Std.Format
                    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
                      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
                          Instances For
                            def Kalin2018.Converges (ds : List Minimalist.Cat) (ls : List Licenser) (nps : List LicensedNP) :

                            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
                              @[instance_reducible]
                              instance Kalin2018.instDecidableConverges (ds : List Minimalist.Cat) (ls : List Licenser) (nps : List LicensedNP) :
                              Decidable (Converges ds ls nps)
                              Equations

                              A nominal is DOM-marked iff a secondary licenser valued its Case.

                              Equations
                              Instances For
                                theorem Kalin2018.agree_cons_none {l : Licenser} {np : Minimalist.PhasedNP} (hnp : np.visible l.domain = true) (s : Case.Valuation Minimalist.PhasedNP CaseValue) :
                                l.agree ((np, none) :: s) = (np, some (CaseValue.licenser l)) :: s

                                A licenser values the highest nominal of its domain if that nominal's Case is unvalued.

                                theorem Kalin2018.agree_cons_some {l : Licenser} (np : Minimalist.PhasedNP) (v : CaseValue) (s : Case.Valuation Minimalist.PhasedNP CaseValue) :
                                l.agree ((np, some v) :: s) = (np, some v) :: l.agree s

                                A licenser passes over a nominal whose Case is already valued.

                                theorem Kalin2018.extends_license (ds : List Minimalist.Cat) (ls : List Licenser) (nps : List Minimalist.PhasedNP) :
                                Case.Valuation.Extends (fun (v : CaseValue) => ∀ (l : Licenser), v = CaseValue.licenser l → l ∈ ls) (initial nps) (license ds ls nps)

                                The derivation extends the lexical valuation, each value it adds naming a licenser of the clause.

                                @[simp]
                                theorem Kalin2018.length_license (ds : List Minimalist.Cat) (ls : List Licenser) (nps : List Minimalist.PhasedNP) :
                                List.length (license ds ls nps) = nps.length
                                theorem Kalin2018.mem_of_mem_license {l : Licenser} {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List Minimalist.PhasedNP} {np : Minimalist.PhasedNP} (h : (np, some (CaseValue.licenser l)) ∈ license ds ls nps) :
                                l ∈ ls

                                Every licenser that values a nominal's Case is a licenser of the clause.

                                Monotonicity #

                                theorem Kalin2018.license_mono {ls ls' : List Licenser} (h : ls.Sublist ls') (ds : List Minimalist.Cat) (nps : List Minimalist.PhasedNP) :
                                (license ds ls nps).ValuedLE (license ds ls' nps)

                                Adding licensers to a clause never leaves a nominal unvalued.

                                theorem Kalin2018.Converges.mono {ds : List Minimalist.Cat} {ls ls' : List Licenser} {nps : List LicensedNP} (hc : Converges ds ls nps) (h : ls.Sublist ls') :
                                Converges ds ls' nps
                                theorem Kalin2018.converges_of_forall_needsLicensing_eq_false {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} (h : ∀ np ∈ nps, np.needsLicensing = false) :
                                Converges ds ls nps

                                A clause with no nominal that needs licensing converges.

                                The Licensing Economy Principle #

                                def Kalin2018.activate (ls : List Licenser) (S : Finset Licenser) :

                                The licensers of a clause when the secondaries in S are activated: the obligatory ones and the activated ones, in place.

                                Equations
                                Instances For
                                  def Kalin2018.Economical (ds : List Minimalist.Cat) (ls : List Licenser) (nps : List LicensedNP) (S : Finset Licenser) :

                                  An activation is economical iff it converges and no activation of fewer licensers does: the derivation with fewer licensers is preferred.

                                  Equations
                                  Instances For
                                    theorem Kalin2018.activate_sublist (ls : List Licenser) (S : Finset Licenser) :
                                    (activate ls S).Sublist ls
                                    theorem Kalin2018.monotone_converges_activate (ds : List Minimalist.Cat) (ls : List Licenser) (nps : List LicensedNP) :
                                    Monotone fun (S : Finset Licenser) => Converges ds (activate ls S) nps
                                    theorem Kalin2018.economical_iff {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} {S : Finset Licenser} :
                                    Economical ds ls nps S ↔ Converges ds (activate ls S) nps ∧ ∀ l ∈ S, ¬Converges ds (activate ls (S.erase l)) nps

                                    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.

                                    @[instance_reducible]
                                    instance Kalin2018.instDecidableEconomical {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} {S : Finset Licenser} :
                                    Decidable (Economical ds ls nps S)
                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    theorem Kalin2018.Economical.mem {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} {S : Finset Licenser} (h : Economical ds ls nps S) {l : Licenser} (hl : l ∈ S) :
                                    l ∈ ls ∧ l.kind = LicenserKind.secondary

                                    Every activated licenser is a secondary licenser of the clause.

                                    theorem Kalin2018.Economical.subset_toFinset {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} {S : Finset Licenser} (h : Economical ds ls nps S) :
                                    S ⊆ ls.toFinset
                                    theorem Kalin2018.exists_economical_iff {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} :
                                    (∃ (S : Finset Licenser), Economical ds ls nps S) ↔ Converges ds ls nps

                                    An economical activation exists iff the clause converges with all its licensers.

                                    theorem Kalin2018.Economical.eq_empty {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} {S : Finset Licenser} (h : Economical ds ls nps S) (h₀ : Converges ds (activate ls ∅) nps) :
                                    S = ∅

                                    If the obligatory licensers suffice, no secondary licenser is activated.

                                    theorem Kalin2018.Economical.not_isDOMMarked {ds : List Minimalist.Cat} {ls : List Licenser} {nps : List LicensedNP} {S : Finset Licenser} (h : Economical ds ls nps S) (h₀ : Converges ds (activate ls ∅) nps) (p : Minimalist.PhasedNP × Option CaseValue) :
                                    p ∈ license ds (activate ls S) (List.map (fun (x : LicensedNP) => x.toPhasedNP) nps) → ¬IsDOMMarked p.2

                                    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
                                      theorem Kalin2018.assign_eq_map_license (g : Minimalist.CaseAssigners) (hg : ∀ d ∈ g.domains, d.2 = { }) (κ : Minimalist.Cat → Case) {ls : List Licenser} (hκ : ∀ l ∈ ls, g.agreeCase l.head = some (κ l.head)) (nps : List Minimalist.PhasedNP) :
                                      g.assign id (List.map (fun (l : Licenser) => (l.head, l.domain)) ls) nps = List.map (Prod.map id (Option.map (CaseValue.assigned κ))) (license (List.map (fun (x : Minimalist.Cat × DependentCase.Rules) => x.1) g.domains) ls nps)

                                      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
                                      Instances For

                                        The T selecting imperfective Asp, a secondary licenser, (43).

                                        Equations
                                        Instances For

                                          The T selecting perfective Asp, the one obligatory licenser of the perfective, (49).

                                          Equations
                                          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
                                                    @[instance_reducible]
                                                    Equations
                                                    @[instance_reducible]
                                                    Equations
                                                    def Kalin2018.instReprSuffix.repr :
                                                    Suffix → ℕ → Std.Format
                                                    Equations
                                                    Instances For
                                                      def Kalin2018.suffixOf :
                                                      Option CaseValue → Option Suffix

                                                      The suffix of a nominal's Case value: that of the head that licensed it, if any.

                                                      Equations
                                                      Instances For
                                                        def Kalin2018.nominal (specific : Bool) :

                                                        A Senaya nominal, which needs licensing exactly when specific, (40) to (42).

                                                        Equations
                                                        Instances For
                                                          def Kalin2018.transitive (subject object : Bool) :

                                                          A transitive clause's subject and object.

                                                          Equations
                                                          Instances For

                                                            The agreement data (Section 2.1) #

                                                            structure Kalin2018.Row :

                                                            A row carries the aspect's licensers, the object if any, the subject's and the object's suffix, and the judgment.

                                                            • clause : List Licenser
                                                            • object : Option Bool
                                                            • subjectSuffix : Suffix
                                                            • objectSuffix : Option Suffix
                                                            • grammatical : Bool
                                                            Instances For
                                                              def Kalin2018.suffixFeature :
                                                              String → Option (Option Suffix)

                                                              A suffix feature value.

                                                              Equations
                                                              Instances For
                                                                def Kalin2018.Row.ofDatum (e : Datum) :
                                                                Option Row

                                                                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
                                                                  Instances For
                                                                    def Kalin2018.Row.nominals (r : Row) (subject : Bool) :

                                                                    The nominals of a row: a subject of the given specificity, and the row's object if any.

                                                                    Equations
                                                                    Instances For
                                                                      def Kalin2018.Row.suffixes (r : Row) :
                                                                      List (Option Suffix)

                                                                      The suffixes of a row: the subject's, then the object's if there is an object.

                                                                      Equations
                                                                      Instances For

                                                                        The suffixes a derivation spells out, nominal by nominal.

                                                                        Equations
                                                                        Instances For
                                                                          theorem Kalin2018.rows_agree (r : Row) :
                                                                          r ∈ rows → ∀ (subject : Bool), (r.grammatical = true ↔ ∃ (S : Finset Licenser), Economical domains r.clause (r.nominals subject) S) ∧ ∀ (S : Finset Licenser), Economical domains r.clause (r.nominals subject) S → suffixes (license domains (activate r.clause S) (List.map (fun (x : LicensedNP) => x.toPhasedNP) (r.nominals subject))) = r.suffixes

                                                                          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.

                                                                          theorem Kalin2018.imperfective_object (subject : Bool) :
                                                                          Economical domains imperfective (transitive subject true) {tImpf} ∧ List.map (fun (x : Minimalist.PhasedNP × Option CaseValue) => x.2) (license domains (activate imperfective {tImpf}) (List.map (fun (x : LicensedNP) => x.toPhasedNP) (transitive subject true))) = [some (CaseValue.licenser aspImpf), some (CaseValue.licenser tImpf)] ∧ Economical domains imperfective (transitive subject false) ∅ ∧ List.map (fun (x : Minimalist.PhasedNP × Option CaseValue) => x.2) (license domains (activate imperfective ∅) (List.map (fun (x : LicensedNP) => x.toPhasedNP) (transitive subject false))) = [some (CaseValue.licenser aspImpf), none]

                                                                          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
                                                                          Instances For

                                                                            v, a secondary licenser probing its own domain.

                                                                            Equations
                                                                            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
                                                                                  def Kalin2018.toyTransitive (subject object : Bool) :

                                                                                  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
                                                                                  Instances For
                                                                                    theorem Kalin2018.toy_animate_object (subject : Bool) :
                                                                                    ¬Converges toyDomains (activate toy ∅) (toyTransitive subject true) ∧ Economical toyDomains toy (toyTransitive subject true) {toyV} ∧ List.map (fun (x : Minimalist.PhasedNP × Option CaseValue) => x.2) (license toyDomains toy (List.map (fun (x : LicensedNP) => x.toPhasedNP) (toyTransitive subject true))) = [some (CaseValue.licenser toyT), some (CaseValue.licenser toyV)]

                                                                                    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).

                                                                                    theorem Kalin2018.toy_inanimate_object (subject : Bool) :
                                                                                    Economical toyDomains toy (toyTransitive subject false) ∅ ∧ List.map (fun (x : Minimalist.PhasedNP × Option CaseValue) => x.2) (license toyDomains (activate toy ∅) (List.map (fun (x : LicensedNP) => x.toPhasedNP) (toyTransitive subject false))) = [some (CaseValue.licenser toyT), none]

                                                                                    An inanimate object activates nothing and goes unlicensed and unmarked, (23).

                                                                                    Licensing against dependent case #

                                                                                    theorem Kalin2018.dependentCase_values_banned_object (subject : Bool) :
                                                                                    ((DependentCase.assignCases Alignment.AlignmentType.accusative (fun (x : LicensedNP) => x.lexicalCase) (transitive subject true))[1]?.bind fun (x : LicensedNP × Option (Case × Case.Mechanism)) => Option.map (fun (x : Case × Case.Mechanism) => x.1) x.2) = some Case.acc ∧ ¬Converges domains perfective (transitive subject true)

                                                                                    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.