Documentation

Linglib.Studies.Cohen2013

[Coh13]: No Quantification without Reinterpretation #

Ariel Cohen, "No Quantification without Reinterpretation." Chapter 13 in Genericity (ed. Mari, Beyssade, Del Prete), OUP, pp. 334–351.

Thesis #

The generic quantifier GEN is not a phonologically null version of an overt quantifier — it is introduced by the hearer through reinterpretation of quantifier-free input. The two reinterpretation mechanisms (Predicate Transfer for generics, type-shifting for habituals) explain the different scopal properties of generics vs habituals.

Empirical Generalizations (§13.2) #

ConstructionScope behavior
Overt quantifier (every, ∀)Full scope ambiguity
Generic (bare plural subject)Ambiguous, except in opaque contexts
Habitual (no restrictor)Narrow scope only
Habitual (with restrictor)Ambiguous (restrictor provides Q site)
Bare plural in habitualScope below habitual (DRT constraint)

Core Proposal (§§13.3–13.4) #

Argumentation Chain (§13.3.1 → §13.4.2) #

The paper's key argument flows through the Partee-Rooth SHIFT operator:

  1. SHIFT does not commute with negation (shift_neg_noncommutative)
  2. Any type-shift shares this non-commutativity property
  3. γ is a type-shift, so γ does not commute with ∃ (gamma_noncommutative)
  4. Therefore γ must apply at the type-mismatch site (locally)
  5. Therefore the existential from the indefinite scopes over γ
  6. Therefore habituals take narrow scope (habitual_narrow_scope)

Formalization Strategy #

We verify Cohen's scope predictions using finite models, with definitions built directly on transferGen and gamma from (below):

  1. Storks / nesting areas: T_g applied locally vs globally gives different truth conditions → generics are scopally ambiguous
  2. Mary / cigarettes: γ applied locally gives the implausible narrow- scope reading; the plausible wide-scope reading would require global γ, which is unavailable because the type mismatch is at the verb level
  3. Scope hierarchy: overt > predicateTransfer > typeShift

These connect to (below) (T_g, γ, SHIFT, QuantifierSource), the canonical relativized restricted universal Quantification.everyOn (Counting.lean) that both T_g and γ bottom out in, and Scope.lean (ScopeConfig). A local 3-cell Occasion enum (below) supplies the habitual-side domain.

Reinterpretation mechanisms ([Coh13], [Nun95]) #

Two mechanisms that introduce covert quantifiers into logical form with different scope consequences: Predicate Transfer (T_g, [Nun95]), pragmatically triggered and applicable at any composition level (→ scope ambiguity except in opaque contexts), and habitual type-shift (γ, [Coh13]), semantically triggered by type mismatch and applied locally (→ narrow scope only). Same quantifier (GEN), different scope behavior driven by the introducing mechanism.

The argument for γ's locality goes through the Partee-Rooth SHIFT operator: since SHIFT does not commute with negation (shift_neg_noncommutative), neither does γ — so γ must apply before negation, i.e., locally.

@[reducible]
def Cohen2013.transferGen {Kind Ind : Type} (gen : (IndBool)(IndBool)Prop) (instanceOf : IndKindBool) (P : IndBool) :
KindProp

Predicate Transfer for generics ([Nun95]): transforms a kind-level predicate into a quantified predicate over instances of the kind. T_g(P) = λx. gen_y[C(y,x)][P(y)], where C(y,x) says y is an instance of kind x. When P(∩pandas) is pragmatically anomalous (kinds don't eat — individuals do), Predicate Transfer applies, yielding gen_y[C(y, ∩pandas)][P(y)].

Equations
Instances For
    def Cohen2013.SHIFT {E : Type} (V : EEBool) :
    ((EBool)Bool)EBool

    Partee-Rooth SHIFT: lift an extensional transitive verb to take a generalized quantifier as its object argument. SHIFT(V) = λQ.λx.Q(λy.V(x,y)). [PR83] propose this to resolve type mismatches between extensional and intensional transitive verbs. [Coh13] §13.3.1 uses SHIFT's non-commutativity with negation to argue type-shifts must be LOCAL — see shift_neg_noncommutative.

    Equations
    Instances For
      theorem Cohen2013.shift_neg_noncommutative :
      ∃ (V : BoolBoolBool) (Q : (BoolBool)Bool) (x : Bool), (!decide (SHIFT V Q x SHIFT (fun (a b : Bool) => !V a b) Q x)) = true

      SHIFT does not commute with negation. For V(x,y) = y, Q(P) = P true ∨ P false, x = true: LHS !Q(λy.y) = !(true ∨ false) = false; RHS Q(λy.¬y) = false ∨ true = true. This non-commutativity ([Coh13] §13.3.1) forces type-shifts to apply LOCALLY (before negation) — the argument carries over to γ.

      @[reducible]
      def Cohen2013.gamma {Interval Moment : Type} (gen : (IntervalBool)(IntervalBool)Prop) (containedIn : IntervalMomentBool) (P : IntervalBool) :
      MomentProp

      γ: type-shift turning an eventive predicate (property of intervals) into a stative one (property of moments). γP = λt. gen_e[e ≤ int(t)][P(e)]. Triggered by the present-tense / eventive-verb type mismatch, which forces γ to fire at the verb level (locally). Locality is why habituals take narrow scope. Like SHIFT, γ does not commute with other operators — see gamma_noncommutative for the concrete instance.

      Equations
      • Cohen2013.gamma gen containedIn P t = gen (fun (e : Interval) => containedIn e t) P
      Instances For

        The mechanism introducing a covert quantifier; determines its scope behavior ([Coh13] §13.4).

        • predicateTransfer : QuantifierSource

          Pragmatic; can apply at any composition level.

        • typeShift : QuantifierSource

          Semantic; applies locally at the type-mismatch site.

        • overt : QuantifierSource

          Phonologically realized (always, usually, often, …).

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

            Type-shifted elements take narrow scope only (local application); Predicate Transfer and overt quantifiers can take wide scope.

            Equations
            Instances For

              Predicate Transfer cannot scope out of opaque (intensional) contexts — it requires the property's intension, unavailable outside an attitude verb's scope. Overt quantifiers can (de re readings); type-shifts are already local.

              Equations
              Instances For

                A datum recording the scope behavior of a construction type with respect to another operator (negation, existential, attitude).

                • sentence : String
                • constructionType : String
                • scopePartner : String
                • wideAvailable : Bool
                • narrowAvailable : Bool
                • source : String
                Instances For

                  §13.2.1: Generics interact scopally with negation. "Cows do not eat nettles" — ambiguous between gen > ¬ and ¬ > gen.

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

                    §13.2.1: Generics cannot scope out of opaque contexts. "The King believes enemy spies are loyal" — only bel > gen.

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

                      §13.2.1: Generics exhibit scope ambiguity in transparent contexts. "Storks have a favorite nesting area" — gen > ∃ and ∃ > gen.

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

                        §13.2.2: Habituals without restrictor take narrow scope only. "#John smokes a cigarette" — only ∃ > hab (implausible).

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

                          §13.2.2: Habituals WITH restrictor are ambiguous. "John smokes a cigarette when he is nervous" — hab > ∃ and ∃ > hab.

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

                            §13.2.2: Bare plurals in habituals take scope below the habitual. "John smokes cigarettes" — only hab > gen (not gen > hab).

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

                              Storks / Nesting Areas #

                              "Storks have a favorite nesting area"

                              Initial LF: ∃x(nesting-area(x) ∧ have(∩storks, x))

                              This is anomalous: kinds don't have nesting areas — individuals do. So Predicate Transfer applies (T_g from (below)), with two options depending on the level of application:

                              The kind ∩storks is modeled as Unit (a single kind-level entity); instances are individual storks. This follows [Chi98]'s ∩ (down) operator, where ∩storks denotes the kind, and ∪(∩storks) gives the extension (the set of individual storks). Here instanceOfStork plays the role of ∪.

                              Instances For
                                @[implicit_reducible]
                                Equations
                                @[implicit_reducible]
                                Equations
                                def Cohen2013.instReprStork.repr :
                                StorkStd.Format
                                Equations
                                Instances For
                                  Instances For
                                    @[implicit_reducible]
                                    Equations
                                    @[implicit_reducible]
                                    Equations
                                    def Cohen2013.instReprNestArea.repr :
                                    NestAreaStd.Format
                                    Equations
                                    Instances For
                                      def Cohen2013.nestsIn :
                                      StorkNestAreaBool

                                      Each stork nests in a different area: s1→a1, s2→a2

                                      Equations
                                      Instances For
                                        @[reducible]
                                        def Cohen2013.genStork (restrictor scope : StorkBool) :

                                        GEN as the canonical relativized universal over storks (simplified: all storks are "normal").

                                        Equations
                                        Instances For
                                          def Cohen2013.instanceOfStork :
                                          StorkUnitBool

                                          Chierchia's ∪ applied to ∩storks: every Stork is an instance of the kind.

                                          Equations
                                          Instances For

                                            The kind ∩storks (a single kind-level entity).

                                            Equations
                                            Instances For
                                              @[reducible]

                                              Local T_g: ∃area(T_g(λy.nestsIn(y, area))(∩storks)) = ∃area(gen_y[stork(y)][nestsIn(y, area)]) "There is one area that, in general, storks nest in."

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

                                                Global T_g: T_g(λy.∃area(nestsIn(y, area)))(∩storks) = gen_y[stork(y)][∃area(nestsIn(y, area))] "In general, storks nest in some area (possibly different)."

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

                                                  Generic scope ambiguity: local and global T_g yield different truth conditions. This is why generics in transparent contexts are scopally ambiguous — Predicate Transfer can apply at either level.

                                                  The two readings correspond to ScopeConfig.surface (∃ > gen) and ScopeConfig.inverse (gen > ∃).

                                                  The scope ambiguity matches the empirical datum: both readings available.

                                                  From SHIFT Non-Commutativity to γ Locality #

                                                  Cohen's argument for habitual narrow scope flows through the Partee-Rooth SHIFT operator ([PR83]):

                                                  1. shift_neg_noncommutative (in (below)) proves that SHIFT does not commute with negation: ¬SHIFT(V) ≠ SHIFT(¬V).

                                                  2. γ is a type-shift (it resolves a type mismatch between eventive predicates and moments). Like any type-shift, γ does not commute with other operators.

                                                  3. gamma_noncommutative below proves the concrete instance: γ does not commute with the existential quantifier over our finite model.

                                                  4. Therefore γ must apply at the type-mismatch site — the verb level — before the existential from the indefinite object is composed in.

                                                  5. This forces the existential to scope over the habitual GEN.

                                                  Mary / Cigarettes #

                                                  "Mary smokes a cigarette"

                                                  The verb smoke is eventive: λy.λx.λe.smoke(x, y, e). In present tense, it applies to the speech time t₀ (a moment). Since an eventive verb requires an interval but receives a moment, there is a type mismatch. γ fires at the verb level:

                                                  γ(λe.smoke(m, c, e))(t₀) — this is what happens. THEN the object composes, yielding: ∃c(cigarette(c) ∧ γ(λe.smoke(m, c, e))(t₀))

                                                  The existential (from the indefinite) takes wide scope over γ, giving the implausible reading "there is one cigarette that Mary habitually smokes."

                                                  The plausible reading (different cigarettes each time) would require GEN to scope over ∃. But that would need γ to apply globally — after the existential is composed in — which is unavailable because the type mismatch is at the verb level (step 4 of the argumentation chain above).

                                                  Instances For
                                                    @[implicit_reducible]
                                                    Equations
                                                    @[implicit_reducible]
                                                    Equations
                                                    def Cohen2013.instReprOccasion.repr :
                                                    OccasionStd.Format
                                                    Equations
                                                    Instances For
                                                      Instances For
                                                        @[implicit_reducible]
                                                        Equations
                                                        def Cohen2013.instReprCigarette.repr :
                                                        CigaretteStd.Format
                                                        Equations
                                                        Instances For
                                                          @[reducible]
                                                          def Cohen2013.genHab (restrictor scope : OccasionBool) :

                                                          GEN over occasions as the canonical relativized universal (simplified: all occasions are relevant).

                                                          Equations
                                                          Instances For
                                                            def Cohen2013.containedInSpeech :
                                                            OccasionUnitBool

                                                            All occasions are contained in the relevant interval of speech time t₀.

                                                            Equations
                                                            Instances For

                                                              The speech time (a moment).

                                                              Equations
                                                              Instances For
                                                                @[reducible]

                                                                Local γ (γ at verb, then object composes): ∃c(cigarette(c) ∧ γ(λe.smoke(m,c,e))(t₀)) "There is one cigarette that Mary habitually smokes."

                                                                Equations
                                                                Instances For
                                                                  @[reducible]

                                                                  Global γ (hypothetical — if γ could apply to the whole VP): γ(λe.∃c(cigarette(c) ∧ smoke(m,c,e)))(t₀) "Mary is habitually in a situation where she smokes some cigarette."

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

                                                                    Habitual narrow scope: local and global γ differ, but only local is available. The plausible wide-scope reading is blocked because γ must apply at the type-mismatch site (the verb level).

                                                                    This explains why "#John smokes a cigarette" is odd: the only available reading (∃ > hab) is implausible.

                                                                    The narrow-scope-only prediction matches the empirical datum.

                                                                    γ does not commute with ∃ on our model.

                                                                    This is the concrete instance of the general non-commutativity argument from §13.3.1 (proved abstractly for SHIFT in shift_neg_noncommutative). The non-commutativity is what forces γ to apply locally.

                                                                    Cohen's core thesis: the mechanism that introduces GEN determines its scope behavior. The three sources form a strict hierarchy:

                                                                    overt > predicateTransfer > typeShift

                                                                    in scope freedom. QuantifierSource in (below) encodes this hierarchy.

                                                                    Both T_g and γ bottom out in the canonical relativized universal Quantification.everyOn, confirming that they share the common logical form. The difference is upstream (how the quantifier is introduced), not downstream (what it evaluates to).

                                                                    T_g with our stork model reduces to everyOn storks.toFinset with the restrictor instanceOfStork · ∩storks and the scope; γ likewise reduces to everyOn occasions.toFinset. Both are rfl because transferGen/gamma are definitionally the relativized universal applied to the kind/moment.

                                                                    The available scope configurations for generics: both surface and inverse scope (matching Scope.allScopeConfigs).

                                                                    The available scope configuration for unrestricted habituals: surface scope only (the covert Q takes narrow scope).

                                                                    Equations
                                                                    Instances For