Documentation

Linglib.Studies.Bennett2018

Bennett 2018: recursion of the prosodic word in Kaqchikel #

[Ben18]

Bennett, R. (2018). Recursive prosodic words in Kaqchikel (Mayan). Glossa: a journal of general linguistics 3(1): 67, 1–33.

Kaqchikel splits prefixes into low-attaching (parsed inside the stem's ω, [ω LowPref-Stem]) and high-attaching (parsed outside it). Two diagnostics converge on this cut: initial glottal-stop insertion (/V…/ → [ʔV…], bled by low prefixes but co-occurring with high ones) and degemination (triggered across a low-prefix juncture but not a high-prefix one). Bennett argues the high-attaching structure is recursive, [ω HighPref [ω Stem]]: the stem keeps its own ω, and the prefix adjoins to a dominating ω. A non-recursive analysis must invent an ad hoc Clitic/Composite Group, and derivational or transderivational alternatives fail on morphological grounds. The conclusion: ω-recursion is indispensable.

Formally this is one ranking fact: a Match(X⁰, ω) faithfulness constraint ([IK22], recasting Selkirk's Match as Max/Dep) outranks NoRecursion ([IM03]). The recursive parse violates NoRecursion once but satisfies Match; the flat parse satisfies NoRecursion but violates Match. With Match ≫ NoRecursion, the recursive parse is the optimum — a prediction the flat List-of-weights Word could not even state.

The prosodic candidates are Trees; the constraints are Constraints.Constraint Tree values (NoRecursion is the carrier constraint Prosody.noRec; Match is the local matchStem), and EVAL is the OT engine OptimalityTheory.Tableau.ofRanking … |>.optimal — the same machinery every OT study in the library uses.

Implementation note #

matchStem here is a stand-in for the full Match(X⁰, ω) constraint: it penalises the stem morpheme not surfacing as its own ω, with the stem baked in (the morpheme under analysis). The general syntax↔prosody Match, built on OptimalityTheory.Correspondence, is future work.

Candidate prosodifications of a high-prefix + stem #

source
def Bennett2018.prefσ :
Prosody.Tree

A high-attaching prefix syllable (light).

Equations
Instances For
    source
    def Bennett2018.stemσ :
    Prosody.Tree

    The stem syllable (heavy).

    Equations
    Instances For
      source
      def Bennett2018.flatParse :
      Prosody.Tree

      Flat parse [ω HighPref Stem]: no recursion, but the stem has no ω of its own.

      Equations
      Instances For
        source
        def Bennett2018.recParse :
        Prosody.Tree

        Recursive parse [ω HighPref [ω Stem]]: the stem keeps its ω; the prefix adjoins to a dominating ω ([Ben18]).

        Equations
        Instances For

          Match(Stem, ω) (stand-in) #

          source
          def Bennett2018.hasOmegaOver (stem : Prosody.Tree) :
          Prosody.Tree → Bool

          Does some ω-node dominate exactly the stem (i.e. have children [stem])?

          Equations
          Instances For
            source
            def Bennett2018.hasOmegaOver.go (stem : Prosody.Tree) :
            Prosody.Tree → Bool
            Equations
            Instances For
              source
              def Bennett2018.hasOmegaOver.goList (stem : Prosody.Tree) :
              List Prosody.Tree → Bool
              Equations
              Instances For
                source
                def Bennett2018.matchStem :
                Constraints.Constraint Prosody.Tree

                Match(Stem, ω) ([IK22]) as a Constraint Tree: 1 if the stem is not exhaustively matched by an ω of its own, else 0.

                Equations
                Instances For

                  The ranking and the prediction #

                  EVAL is the OT tableau engine: Tableau.ofRanking candidates ranking |>.optimal selects the lexicographic optimum under the constraint ranking (priority = list order). The ranking Match(X⁰,ω) ≫ NoRecursion is [matchStem, noRec].

                  source
                  theorem Bennett2018.recParse_optimal :
                  (OptimalityTheory.Tableau.ofRanking [recParse, flatParse] [matchStem, Prosody.noRec] ⋯).optimal = {recParse}

                  Under Match(X⁰,ω) ≫ NoRecursion, the recursive parse is the unique optimum — Bennett's central result, that ω-recursion is forced.