Documentation

Studies.Baker2015

Baker 2015: dependent case #

Structural case cannot in general be read off agreement with a functional head: ergative languages let the finite verb agree with ergative and absolutive subjects alike, and the subject must already be ergative before Agree applies. The book takes up Marantz's dependent case instead. In a spell-out domain, an NP with lexically governed case keeps it; of two distinct caseless NPs one of which c-commands the other, the lower is valued accusative or the higher ergative — which of these a language does is its alignment parameter, and a tripartite language does both; whatever remains is unmarked, nominative in the clause and genitive in the noun phrase. Sakha, Shipibo and Nez Perce show the three settings on the simplest transitive and intransitive clauses, and the twenty-odd languages the book studies in depth sort into those columns together with marked-nominative and marked-absolutive systems, which differ in how the unmarked case is realized.

Main definitions #

References #

source
def Baker2015.alignment? :
String → Option Alignment.AlignmentType

The book's languages of focus by alignment type: accusative Sakha, Tamil, Amharic, Cuzco Quechua, Korean and Finnish; ergative Shipibo, Burushaski, Chukchi, Lezgian, Ingush, Greenlandic, Kewa and Wardaman; tripartite Nez Perce, Coast Tsimshian, Semelai, Diyari and Warlpiri. The marked-nominative and marked-absolutive languages differ in the realization of the unmarked case, which the algorithm does not fix.

Equations
Instances For
    source
    inductive Baker2015.Observed :
    Type

    The case a gloss shows: a dependent case, or an unmarked form — nominative, absolutive, or no marking at all.

    Instances For
      source
      @[instance_reducible]
      instance Baker2015.instDecidableEqObserved :
      DecidableEq Observed
      Equations
      source
      @[instance_reducible]
      instance Baker2015.instReprObserved :
      Repr Observed
      Equations
      source
      def Baker2015.instReprObserved.repr :
      Observed → ℕ → Std.Format
      Equations
      Instances For
        source
        def Baker2015.Observed.parse? :
        String → Option Observed

        The gloss labels of the book's examples.

        Equations
        Instances For
          source
          def Baker2015.Realizes (c : Case) (src : Case.Mechanism) :
          Observed → Prop

          An assigned case realizes an observed one: the dependent cases as themselves, and the unmarked case as whatever label the language gives it.

          Equations
          Instances For
            source
            @[instance_reducible]
            instance Baker2015.instDecidableRealizes (c : Case) (src : Case.Mechanism) (o : Observed) :
            Decidable (Realizes c src o)
            Equations
            • One or more equations did not get rendered due to their size.
            source
            inductive Baker2015.Arg :
            Type

            The arguments of a clause.

            Instances For
              source
              @[instance_reducible]
              instance Baker2015.instDecidableEqArg :
              DecidableEq Arg
              Equations
              source
              def Baker2015.instReprArg.repr :
              Arg → ℕ → Std.Format
              Equations
              Instances For
                source
                @[instance_reducible]
                instance Baker2015.instReprArg :
                Repr Arg
                Equations
                source
                def Baker2015.Arg.feature :
                Arg → String

                The feature a row records an argument's case under.

                Equations
                Instances For
                  source
                  def Baker2015.domain (r : Datum) :
                  List Arg

                  The arguments of a row's clause, subject first: it c-commands the object.

                  Equations
                  Instances For
                    source
                    def Baker2015.observed? (r : Datum) (np : Arg) :
                    Option Observed

                    The observed case of a row's argument.

                    Equations
                    Instances For
                      source
                      theorem Baker2015.rows_case (r : Datum) :
                      r ∈ Examples.all → ∀ lang ∈ alignment? r.language, ∀ np ∈ [Arg.subject, Arg.object], ∀ o ∈ observed? r np, ∀ v ∈ Case.Valuation.valueOf np (DependentCase.assignCases lang (fun (x : Arg) => none) (domain r)), Realizes v.1 v.2 o

                      Every clause the book introduces its languages with is derived by the algorithm from the language's alignment type: the ergative and accusative NPs are the dependent-case NPs and the nominative, absolutive and unmarked NPs the leftovers.

                      source
                      theorem Baker2015.ergative_subject_independent_of_agreement (r : Datum) :
                      r ∈ Examples.all → alignment? r.language = some Alignment.AlignmentType.ergative → Option.map (fun (x : Case × Case.Mechanism) => x.1) (Case.Valuation.valueOf Arg.subject (DependentCase.assignCases Alignment.AlignmentType.ergative (fun (x : Arg) => none) (domain r))) = some (if r.feature? "transitive" = some "yes" then Case.erg else Case.abs)

                      Agreement does not enter the algorithm: a subject is ergative in a transitive clause and unmarked in an intransitive one whether or not the verb agrees with it, as in Kewa and Burushaski.