Documentation

Studies.CoppockBeaver2015

Coppock and Beaver's definiteness and determinacy #

This file formalizes Coppock and Beaver's theory of definiteness: definite, indefinite and possessive descriptions are underlyingly predicates, the definite article presupposes weak uniqueness and no existence, and a description acquires existential import only through the type shifts that place it in argument position. The entries are terms of the paper's Weak Kleene logic with the presupposition operator of Beaver and Krahmer, and the definite article competes with the indefinite under an expression-level Maximize Presupposition.

Main statements #

Implementation notes #

TODO #

References #

Weak uniqueness and the lexical entries #

def CoppockBeaver2015.WeakUnique {E : Type u_1} (P : E → SignType) :

A predicate is weakly unique, the paper's |P| ≤ 1, when its positive extension is a subsingleton.

Equations
Instances For
    @[instance_reducible]
    instance CoppockBeaver2015.instDecidableWeakUniqueOfFintypeOfDecidableEq {E : Type u_1} [Fintype E] [DecidableEq E] (P : E → SignType) :
    Decidable (WeakUnique P)
    Equations
    def CoppockBeaver2015.Exclusive {E : Type u_1} (P : E → SignType) (x : E) :

    Nothing other than x is a P — the exclusive component of only (57).

    Equations
    Instances For
      @[instance_reducible]
      instance CoppockBeaver2015.instDecidableRelForallSignTypeExclusiveOfFintypeOfDecidableEq {E : Type u_1} [Fintype E] [DecidableEq E] :
      DecidableRel Exclusive
      Equations
      theorem CoppockBeaver2015.not_exclusive_iff {E : Type u_1} {P : E → SignType} {x : E} :
      ¬Exclusive P x ↔ ∃ (y : E), y ≠ x ∧ P y = 1
      theorem CoppockBeaver2015.exclusive_iff_subset_singleton {E : Type u_1} {P : E → SignType} {x : E} :
      Exclusive P x ↔ Trivalent.posExt P ⊆ {x}

      Exclusivity is containment of the positive extension in the singleton.

      def CoppockBeaver2015.the {E : Type u_1} [DecidablePred WeakUnique] (P : E → SignType) :
      E → SignType

      The Weak Fregean definite article (50) returns the restrictor, presupposing weak uniqueness and no existence.

      Equations
      Instances For
        def CoppockBeaver2015.an {E : Type u_1} (P : E → SignType) :
        E → SignType

        The indefinite article (65) is an identity on predicates.

        Equations
        Instances For
          def CoppockBeaver2015.only {E : Type u_1} [DecidableRel Exclusive] (P : E → SignType) :
          E → SignType

          Adjectival only (57) presupposes the prejacent and asserts exclusivity.

          Equations
          Instances For
            theorem CoppockBeaver2015.only_eq_one_iff {E : Type u_1} [DecidableRel Exclusive] {P : E → SignType} {x : E} :
            only P x = 1 ↔ P x = 1 ∧ Exclusive P x
            theorem CoppockBeaver2015.only_eq_neg_one_iff {E : Type u_1} [DecidableRel Exclusive] {P : E → SignType} {x : E} :
            only P x = -1 ↔ P x = 1 ∧ ∃ (y : E), y ≠ x ∧ P y = 1
            theorem CoppockBeaver2015.only_eq_zero_iff {E : Type u_1} [DecidableRel Exclusive] {P : E → SignType} {x : E} :
            only P x = 0 ↔ P x ≠ 1

            Only presupposes its prejacent.

            theorem CoppockBeaver2015.weakUnique_only {E : Type u_1} [DecidableRel Exclusive] (P : E → SignType) :

            An only phrase satisfies weak uniqueness, so there is never more than one only P.

            theorem CoppockBeaver2015.the_eq_of_weakUnique {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} (h : WeakUnique P) :
            the P = P
            theorem CoppockBeaver2015.the_eq_zero_of_not_weakUnique {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} (h : ¬WeakUnique P) (x : E) :
            the P x = 0
            theorem CoppockBeaver2015.the_eq_zero_iff {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} {x : E} :
            the P x = 0 ↔ ¬WeakUnique P ∨ P x = 0
            theorem CoppockBeaver2015.the_ne_zero_iff {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} {x : E} :
            the P x ≠ 0 ↔ WeakUnique P ∧ P x ≠ 0

            The definite is classical exactly on weakly unique restrictors, where the noun is.

            theorem CoppockBeaver2015.neg_the_eq_zero_iff {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} {x : E} :
            -the P x = 0 ↔ ¬WeakUnique P ∨ P x = 0

            The uniqueness presupposition projects through negation, (45)–(46), so the negated definite is undefined exactly where the definite is.

            theorem CoppockBeaver2015.the_neg_one {E : Type u_1} [DecidablePred WeakUnique] (x : E) :
            the (fun (x : E) => -1) x = -1

            The empty restrictor is weakly unique, so the definite of an empty noun is false rather than undefined — uniqueness without existence, the predicative reading of (13).

            theorem CoppockBeaver2015.neg_the_neg_one {E : Type u_1} [DecidablePred WeakUnique] (x : E) :
            -the (fun (x : E) => -1) x = 1

            Existence does not project, (45a), so that is not the heart is true when there are no hearts.

            theorem CoppockBeaver2015.eq_of_the_eq_one {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} {a b : E} (ha : the P a = 1) (hb : the P b = 1) :
            a = b

            Two subjects of a true predicative definite coincide. Weak uniqueness is what makes Löbner's negation test contradictory and his conjunction test equivalent, (114)–(115).

            theorem CoppockBeaver2015.the_only {E : Type u_1} [DecidablePred WeakUnique] [DecidableRel Exclusive] (P : E → SignType) :
            the (only P) = only P

            The uniqueness presupposition of the is trivially satisfied by an only phrase, so the only P means only P, (60).

            theorem CoppockBeaver2015.anti_uniqueness {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} {x : E} [DecidableRel Exclusive] :
            -the (only P) x = 1 ↔ P x = 1 ∧ ∃ (y : E), y ≠ x ∧ P y = 1

            x is not the only P is true exactly when x is a P and so is something else, the anti-uniqueness inference (64).

            theorem CoppockBeaver2015.anti_uniqueness_presup {E : Type u_1} [DecidablePred WeakUnique] {P : E → SignType} {x : E} [DecidableRel Exclusive] :
            -the (only P) x = 0 ↔ P x ≠ 1

            The presupposition of only projects through negation (63), so x is not the only P is undefined exactly when x is no P.

            The entries as formulas of the paper's logic #

            The abbreviation |P| ≤ 1 of footnote 18 and the exclusive component of (57) are formulas of IL3, read with Haug's universal quantifier and the Weak Kleene conditional. On a restrictor that is somewhere defined the first is classical weak uniqueness, and where the prejacent holds the second is classical exclusivity, so the entries above are the paper's pointwise.

            noncomputable def CoppockBeaver2015.atMostOneFormula {E : Type u_1} (P : E → SignType) :
            SignType

            |P| ≤ 1 as a formula is ∀x[P(x) → ∀y[P(y) → x = y]].

            Equations
            Instances For
              noncomputable def CoppockBeaver2015.exclusiveFormula {E : Type u_1} (P : E → SignType) (x : E) :
              SignType

              The exclusive component of only as a formula is ∀y[x ≠ y → ¬P(y)].

              Equations
              Instances For
                theorem CoppockBeaver2015.atMostOne_eq_ofProp {E : Type u_1} {P : E → SignType} [Decidable (WeakUnique P)] (h : ∃ (x : E), P x ≠ 0) :
                theorem CoppockBeaver2015.the_eq_meetWeak_atMostOne {E : Type u_1} [DecidablePred WeakUnique] (P : E → SignType) (x : E) :
                the P x = (max (atMostOneFormula P) 0).meetWeak (P x)

                The definite article is the paper's entry (50) pointwise.

                theorem CoppockBeaver2015.exclusiveFormula_eq_ofProp {E : Type u_1} {P : E → SignType} {x : E} [Decidable (Exclusive P x)] (h : P x = 1) :
                theorem CoppockBeaver2015.only_eq_meetWeak_exclusiveFormula {E : Type u_1} [DecidableRel Exclusive] (P : E → SignType) (x : E) :
                only P x = (max (P x) 0).meetWeak (exclusiveFormula P x)

                Adjectival only is the paper's entry (57) pointwise.

                The exclusive schema #

                Footnote 22: adjectival only instantiates the exclusive schema of [CB14], whose entry for the adjectival case constrains the current question to what things are P, its answers ranked by entailment and predicating cumulative sums. Read on the space of extensions of the noun, those answers are the propositions that the Ps include a given collection — upper sets, with the vacuous answer weakest and inert — and the schema's value at an extension is the entry (57).

                def CoppockBeaver2015.answer {E : Type u_1} (X : Set E) :
                Set (Set E)

                A partial answer to what things are P on the space of extensions says that the Ps include X.

                Equations
                Instances For
                  theorem CoppockBeaver2015.mem_atLeast_answer {E : Type u_1} {w : Set E} {x : E} :
                  w ∈ Focus.Particles.atLeast (fun (x1 x2 : Set (Set E)) => x1 ⊆ x2) (Set.range answer) (answer {x}) ↔ x ∈ w

                  Some true answer is at least as strong as the prejacent exactly when the Ps include x, so the schema's presupposition is the prejacent.

                  theorem CoppockBeaver2015.mem_atMost_answer {E : Type u_1} {w : Set E} {x : E} :
                  w ∈ Focus.Particles.atMost (fun (x1 x2 : Set (Set E)) => x1 ⊆ x2) (Set.range answer) (answer {x}) ↔ w ⊆ {x}

                  No true answer is stronger than the prejacent exactly when the Ps are contained in {x}, so the schema's assertion is exclusivity.

                  theorem CoppockBeaver2015.only_answer_apply {E : Type u_1} [DecidableRel Exclusive] (w : Set E) [DecidablePred fun (x : E) => x ∈ w] (x : E) :
                  Focus.Particles.only (fun (x1 x2 : Set (Set E)) => x1 ⊆ x2) (Set.range answer) (answer {x}) w = only (fun (y : E) => SignType.ofProp (y ∈ w)) x

                  Adjectival only is the exclusive schema at the question what things are P. The schema of [CB14] over the answers, on the entailment scale, evaluated at an extension, is the entry (57) of the predicate with that extension.

                  Presupposition profiles of the entries in Table 1 #

                  def CoppockBeaver2015.PresupposesUniqueness {E : Type u_1} (D : (E → SignType) → E → SignType) :

                  An entry presupposes uniqueness when it is classical only on weakly unique restrictors.

                  Equations
                  Instances For
                    def CoppockBeaver2015.PresupposesExistence {E : Type u_1} (D : (E → SignType) → E → SignType) :

                    An entry presupposes existence when it is classical only on nonempty restrictors.

                    Equations
                    Instances For
                      theorem CoppockBeaver2015.not_presupposesUniqueness_of_ne_zero {E : Type u_1} [Nontrivial E] {D : (E → SignType) → E → SignType} {x : E} (h : D (fun (x : E) => 1) x ≠ 0) :

                      An entry classical on the full restrictor presupposes no uniqueness.

                      theorem CoppockBeaver2015.not_presupposesExistence_of_ne_zero {E : Type u_1} {D : (E → SignType) → E → SignType} {x : E} (h : D (fun (x : E) => -1) x ≠ 0) :

                      An entry classical on the empty restrictor presupposes no existence.

                      noncomputable def CoppockBeaver2015.theRussellian {E : Type u_1} (P : E → SignType) :
                      E → SignType

                      The Russellian predicative entry (52a) asserts existence and uniqueness.

                      Equations
                      Instances For
                        noncomputable def CoppockBeaver2015.theFregean {E : Type u_1} (P : E → SignType) :
                        E → SignType

                        The Fregean predicative entry (52b) presupposes existence and uniqueness.

                        Equations
                        Instances For
                          noncomputable def CoppockBeaver2015.theRussellianGQ {E : Type u_1} (P Q : E → SignType) :
                          SignType

                          The Russellian quantificational entry (53a) asserts unique existence of the restrictor.

                          Equations
                          Instances For
                            noncomputable def CoppockBeaver2015.theFregeanGQ {E : Type u_1} (P Q : E → SignType) :
                            SignType

                            The Fregean quantificational entry (53b) presupposes unique existence of the restrictor.

                            Equations
                            Instances For
                              noncomputable def CoppockBeaver2015.be {E : Type u_1} (G : (E → SignType) → SignType) :
                              E → SignType

                              Partee's be lowers a generalized quantifier to a predicate.

                              Equations
                              Instances For
                                noncomputable def CoppockBeaver2015.identIota {E : Type u_1} (P : E → SignType) :
                                E → SignType

                                Partee's ident applied to the individual-denoting Fregean entry yields the property of being the unique P, undefined when there is none (Table 2).

                                Equations
                                Instances For
                                  theorem CoppockBeaver2015.theFregean_ne_zero_iff {E : Type u_1} {P : E → SignType} {x : E} :
                                  theFregean P x ≠ 0 ↔ (∃! y : E, P y = 1) ∧ P x ≠ 0
                                  theorem CoppockBeaver2015.not_presupposesUniqueness_be_theRussellianGQ {E : Type u_1} [Nontrivial E] :
                                  ¬PresupposesUniqueness fun (P : E → SignType) => be (theRussellianGQ P)

                                  Lowering the Russellian quantifier by be presupposes nothing (Table 2).

                                  theorem CoppockBeaver2015.be_theFregeanGQ_ne_zero_iff {E : Type u_1} {P : E → SignType} {x : E} :
                                  be (theFregeanGQ P) x ≠ 0 ↔ ∃! y : E, P y = 1

                                  Lowering the Fregean quantifier by be presupposes both existence and uniqueness.

                                  theorem CoppockBeaver2015.identIota_ne_zero_iff {E : Type u_1} {P : E → SignType} {x : E} :
                                  identIota P x ≠ 0 ↔ ∃! y : E, P y = 1

                                  Lowering the individual-denoting Fregean entry by ident presupposes both existence and uniqueness (Table 2).

                                  theorem CoppockBeaver2015.no_anti_uniqueness_fregean {E : Type u_1} [DecidableRel Exclusive] (P : E → SignType) (x : E) :
                                  -theFregean (only P) x ≠ 1

                                  Under the Fregean entry x is not the only P is never true (§2.2.3), since the presupposition that there is exactly one only P is inconsistent with the assertion that x, a P, is not one. The Weak Fregean entry has no such clash (anti_uniqueness).

                                  Maximize Presupposition #

                                  def CoppockBeaver2015.ClassicallyEquivalent {E : Type u_1} (α β : (E → SignType) → E → SignType) :

                                  Two entries are classically equivalent (70) when, on bivalent restrictors, they agree wherever both are classical.

                                  Equations
                                  Instances For
                                    def CoppockBeaver2015.AtLeastAsStrong {E : Type u_1} (α β : (E → SignType) → E → SignType) :

                                    α is presuppositionally at least as strong as β when, on bivalent restrictors, wherever α is classical so is β. As printed, (71) quantifies the other way around, which with (72) would have the indefinite dominate the definite; the paper's own derivation of the opposite on the same page needs this transposition.

                                    Equations
                                    Instances For
                                      def CoppockBeaver2015.Dominates {E : Type u_1} (α β : (E → SignType) → E → SignType) :

                                      α presuppositionally dominates β (72) when the two are classically equivalent and α is strictly stronger.

                                      Equations
                                      Instances For
                                        theorem CoppockBeaver2015.the_dominates_an {E : Type u_1} [Nontrivial E] [DecidablePred WeakUnique] :

                                        The definite article dominates the indefinite.

                                        def CoppockBeaver2015.Blocks {E : Type u_1} {W : Type u_2} (C : Set W) (D : ((E → SignType) → E → SignType) → W → SignType) (α β : (E → SignType) → E → SignType) :

                                        Under Maximize Presupposition (75), α blocks its competitor β in context C and derivation D, the sentence meaning as a function of the article's meaning, when α dominates β and the two derivations update C alike; the update of a context with a meaning (74) is the substrate's Heimian partial update CCP.Partial.ofTrivalent. Clause (i), competitorhood, is glossed in the appendix as classical equivalence with a high-frequency item and is carried by Dominates.

                                        Equations
                                        Instances For
                                          theorem CoppockBeaver2015.blocks_of_weakUnique {E : Type u_1} {W : Type u_2} [DecidablePred WeakUnique] {C : Set W} (F : W → (E → SignType) → SignType) (π : W → E → SignType) [Nontrivial E] (h : ∀ w ∈ C, WeakUnique (π w)) :
                                          Blocks C (fun (α : (E → SignType) → E → SignType) (w : W) => F w (α (π w))) the an

                                          Where the restrictor is weakly unique throughout the context, the blocks a in every derivation applying the article to it.

                                          theorem CoppockBeaver2015.not_blocks_of_not_weakUnique {E : Type u_1} {W : Type u_2} [DecidablePred WeakUnique] {C : Set W} (F : W → (E → SignType) → SignType) (π : W → E → SignType) (hF : ∀ (w : W), (F w fun (x : E) => 0) = 0) {w : W} (hw : w ∈ C) (h : ¬WeakUnique (π w)) (hdom : ∀ w ∈ C, F w (π w) ≠ 0) :
                                          ¬Blocks C (fun (α : (E → SignType) → E → SignType) (w : W) => F w (α (π w))) the an

                                          Where weak uniqueness fails at a world of the context, the fails to block a provided the indefinite sentence is classical on the context and the material around the description is strict in its undefinedness.

                                          theorem CoppockBeaver2015.an_only_blocked {E : Type u_1} {W : Type u_2} [DecidablePred WeakUnique] {C : Set W} (F : W → (E → SignType) → SignType) (π : W → E → SignType) [DecidableRel Exclusive] [Nontrivial E] :
                                          Blocks C (fun (α : (E → SignType) → E → SignType) (w : W) => F w (α (only (π w)))) the an

                                          An only P is blocked in every context (66), since an only phrase meets the definite's presupposition and the two derivations coincide.

                                          theorem CoppockBeaver2015.sentence_the_only_eq_an_only {E : Type u_1} {W : Type u_2} [DecidablePred WeakUnique] (F : W → (E → SignType) → SignType) (π : W → E → SignType) [DecidableRel Exclusive] :
                                          (fun (w : W) => F w (the (only (π w)))) = fun (w : W) => F w (an (only (π w)))

                                          The sentence with the and the sentence with a(n) mean the same whenever the description is an only phrase, since the article contributes nothing to an inherently unique description.

                                          theorem CoppockBeaver2015.not_blocked_sentence_an_only {E : Type u_1} {W : Type u_2} [DecidablePred WeakUnique] (F : W → (E → SignType) → SignType) (π : W → E → SignType) [DecidableRel Exclusive] :
                                          ¬Competition.Blocked (Competition.sameAssertion (fun (x : W → SignType) => {fun (w : W) => F w (the (only (π w)))}) fun (p : W → SignType) => {w : W | p w = 1}) (fun (p : W → SignType) => {w : W | p w ≠ 0}) fun (w : W) => F w (an (only (π w)))

                                          With the the-sentence as the alternative, the an-sentence is not blocked at sentence level, although an_only_blocked blocks it at expression level, so Maximize Presupposition must compare expressions rather than sentences.

                                          Existence in argument position #

                                          noncomputable def CoppockBeaver2015.iota {E : Type u_1} (P : E → SignType) :
                                          Option E

                                          The iota shift (84) returns the unique satisfier, or the undefined individual.

                                          Equations
                                          Instances For
                                            theorem CoppockBeaver2015.iota_isSome_iff {E : Type u_1} (P : E → SignType) :
                                            (iota P).isSome = true ↔ ∃! x : E, P x = 1
                                            theorem CoppockBeaver2015.iota_eq_none_iff {E : Type u_1} (P : E → SignType) :
                                            iota P = none ↔ ¬∃! x : E, P x = 1
                                            theorem CoppockBeaver2015.iota_neg_one {E : Type u_1} :
                                            (iota fun (x : E) => -1) = none

                                            On the argumental reading of (14), the empty restrictor has no referent.

                                            theorem CoppockBeaver2015.iota_the {E : Type u_1} [DecidablePred WeakUnique] (P : E → SignType) :
                                            iota (the P) = iota P

                                            Under iota the article's presupposition adds nothing, since iota presupposes uniqueness.

                                            theorem CoppockBeaver2015.elim_iota_ne_zero_iff {E : Type u_1} (P f : E → SignType) (hf : ∀ (x : E), f x ≠ 0) :
                                            (iota P).elim 0 f ≠ 0 ↔ ∃! x : E, P x = 1

                                            On the determinate reading (87), undefinedness of the individual percolates (86), so the sentence is classical exactly when the description has exactly one satisfier.

                                            noncomputable def CoppockBeaver2015.ex {E : Type u_1} (P Q : E → SignType) :
                                            SignType

                                            The existential shift (85) asserts a common satisfier of restrictor and scope.

                                            Equations
                                            Instances For
                                              theorem CoppockBeaver2015.ex_zero_left {E : Type u_1} (Q : E → SignType) :
                                              ex (fun (x : E) => 0) Q = 0
                                              def CoppockBeaver2015.scopeInside {E : Type u_1} (T : E → E → SignType) (Q : (E → SignType) → SignType) (M : (E → SignType) → E → SignType) :
                                              E → SignType

                                              The type shift of footnote 26 scopes an argument quantifier inside the modified description — the further existential within the nominal that intervenes between the determiner and the exclusive.

                                              Equations
                                              Instances For
                                                theorem CoppockBeaver2015.not_update_dom_iota {E : Type u_1} {W : Type u_2} {C : Set W} {π : W → E → SignType} (G : W → E → SignType) {w : W} (hw : w ∈ C) (h : ¬∃! x : E, π w x = 1) :
                                                ¬(DynamicSemantics.CCP.Partial.ofTrivalent (fun (w : W) => (iota (π w)).elim 0 (G w)) C).Dom

                                                Where some world of the context lacks a unique satisfier, the determinate reading has no defined update (§3.2–3.3).

                                                theorem CoppockBeaver2015.readings_agree_of_existsUnique {E : Type u_1} {W : Type u_2} {C : Set W} {π Q : W → E → SignType} (hπ : ∀ w ∈ C, Trivalent.IsBivalent (π w)) (hQ : ∀ w ∈ C, Trivalent.IsBivalent (Q w)) (h : ∀ w ∈ C, ∃! x : E, π w x = 1) :
                                                DynamicSemantics.CCP.Partial.ofTrivalent (fun (w : W) => (iota (π w)).elim 0 (Q w)) C = DynamicSemantics.CCP.Partial.ofTrivalent (fun (w : W) => ex (π w) (Q w)) C

                                                Where every world of the context has exactly one satisfier, the determinate and the indeterminate readings update the context alike (§3.4).

                                                theorem CoppockBeaver2015.no_determinate_indefinites {E : Type u_1} {W : Type u_2} [Nontrivial E] [DecidablePred WeakUnique] (F : W → (E → SignType) → SignType) (π G : W → E → SignType) {C : Set W} (h : ¬Blocks C (fun (α : (E → SignType) → E → SignType) (w : W) => F w (α (π w))) the an) :
                                                ¬(DynamicSemantics.CCP.Partial.ofTrivalent (fun (w : W) => (iota (π w)).elim 0 (G w)) C).Dom

                                                An indefinite the definite fails to block has, at some world of the context, a restrictor without a unique satisfier, so its reading under iota has no defined update — no determinate indefinites (§3.3).

                                                theorem CoppockBeaver2015.neg_ex_the_only {E : Type u_1} [DecidablePred WeakUnique] [DecidableRel Exclusive] {P Q : E → SignType} (hP : Trivalent.IsBivalent P) (hQ : Trivalent.IsBivalent Q) :
                                                -ex (the (only P)) Q = (Trivalent.existsHaug fun (x : E) => max (P x) 0).meetWeak (-Trivalent.existsHaug fun (x : E) => (P x).meetWeak ((SignType.ofProp (Exclusive P x)).meetWeak (Q x)))

                                                By Quantifier Projection (A.4.2), negated the only P under the existential shift presupposes that there is a P and denies that any sole P bears Q, the anti-uniqueness reading (89)–(94).

                                                theorem CoppockBeaver2015.argumental_anti_uniqueness_presup {E : Type u_1} [DecidablePred WeakUnique] [DecidableRel Exclusive] {P Q : E → SignType} (hQ : Trivalent.IsBivalent Q) :
                                                -ex (the (only P)) Q = 0 ↔ ∀ (x : E), P x ≠ 1

                                                The argumental reading presupposes a P, not an only P (§3.2), so it is undefined exactly when there is no P.

                                                theorem CoppockBeaver2015.argumental_anti_uniqueness {E : Type u_1} [DecidablePred WeakUnique] [DecidableRel Exclusive] {P Q : E → SignType} (hQ : Trivalent.IsBivalent Q) :
                                                -ex (the (only P)) Q = 1 ↔ (∃ (x : E), P x = 1) ∧ ∀ (x : E), P x = 1 → Exclusive P x → Q x ≠ 1

                                                The argumental anti-uniqueness reading is true exactly when there is a P and no sole P bears Q, as in (80a) with several talks, one of which Anna gave.

                                                Possessives #

                                                def CoppockBeaver2015.toRelational {E : Type u_1} (poss : E → E → SignType) (P : E → SignType) (y : E) :
                                                E → SignType

                                                The sortal-to-relational shift (129) sends a noun to the Ps possessed by y. The appendix's TS3 prints the possessor arguments in the opposite order; the main text's is followed.

                                                Equations
                                                Instances For
                                                  theorem CoppockBeaver2015.isBivalent_toRelational {E : Type u_1} {poss : E → E → SignType} {P : E → SignType} (hP : Trivalent.IsBivalent P) (hposs : ∀ (x y : E), poss x y ≠ 0) (y : E) :

                                                  A possessive predicate presupposes nothing beyond its parts (§4.1, §4.3). It is classical wherever noun and possession are, so predicative possessives signal no uniqueness.

                                                  theorem CoppockBeaver2015.possessive_not_competitor {E : Type u_1} [DecidableEq E] [DecidablePred WeakUnique] {poss : E → E → SignType} {x y : E} (h : poss x y = -1) :
                                                  ¬ClassicallyEquivalent (fun (P : E → SignType) => toRelational poss P y) the

                                                  Possessives do not compete with the definite article (§4). A possessive predicate is not classically equivalent to the, since a weakly unique noun true of an individual the possessor does not own separates them.

                                                  theorem CoppockBeaver2015.possessive_anti_uniqueness {E : Type u_1} [DecidableRel Exclusive] {poss : E → E → SignType} {P Q : E → SignType} (hQ : Trivalent.IsBivalent Q) (hposs : ∀ (x y : E), poss x y ≠ 0) (y : E) :
                                                  -ex (toRelational poss (only P) y) Q = 1 ↔ (∃ (x : E), P x = 1) ∧ ∀ (x : E), P x = 1 → Exclusive P x → poss x y = 1 → Q x ≠ 1

                                                  On the indeterminate reading of an argumental possessive (134), he didn't make his only appearance presupposes an appearance and denies that he made any sole appearance of his.

                                                  The paper's models #

                                                  Two worlds settle whether Frida wrote one book or two, the contexts of (73); two crashes with a single survivor each make only survivor of a plane crash, with the crash scoped inside the description as in (69), hold of two people.

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

                                                      The speaker is reading the first book.

                                                      Equations
                                                      Instances For
                                                        noncomputable def CoppockBeaver2015.Frida.sentence (α : (Book → SignType) → Book → SignType) :
                                                        World → SignType

                                                        sentence α interprets I'm now reading (a/the) book she wrote with the description shifted existentially.

                                                        Equations
                                                        Instances For

                                                          Once the context settles that Frida wrote exactly one book, the blocks a, (73b).

                                                          While the context leaves the number of books open, a is not blocked, (73a).

                                                          Instances For
                                                            @[instance_reducible]
                                                            Equations
                                                            @[instance_reducible]
                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            def CoppockBeaver2015.Crash.survived (z : Ind) :
                                                            Ind → SignType

                                                            Each crash has a single survivor, Scott of the first and Sam of the second.

                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            Instances For
                                                              noncomputable def CoppockBeaver2015.Crash.onlySurvivor :
                                                              Ind → SignType

                                                              In only survivor of a plane crash (69), the type shift of footnote 26 scopes the crash inside the description.

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

                                                                The description holds of as many people as there are crashes with a single survivor.

                                                                theorem CoppockBeaver2015.Crash.an_only_survivor_not_blocked :
                                                                ¬Blocks Set.univ (fun (α : (Ind → SignType) → Ind → SignType) (x : Unit) => α onlySurvivor Ind.scott) the an

                                                                An only survivor of a plane crash is not blocked on the derivation scoping the crash inside the description, (68).

                                                                noncomputable def CoppockBeaver2015.Crash.high (α : (Ind → SignType) → Ind → SignType) :
                                                                Unit → SignType

                                                                The high-scope derivation places the crash above the article.

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

                                                                  The only survivor of a plane crash with the crash scoped high means what an only survivor of a plane crash means with the crash scoped low.

                                                                  On the high-scope derivation the blocks a. Together with an_only_survivor_not_blocked, this shows that blocking compares derivations rather than strings, so the surviving surface form owes its life to the low-scope derivation.

                                                                  The paper's judgments #

                                                                  The rows of Data/Examples/CoppockBeaver2015.json with a restrictor feature are the predicative definites whose felicity turns on weak uniqueness alone, (10)–(12) and (44)–(46): a restrictor that holds of nothing, the scenario in which iguanas have no hearts, one that holds of both items of a two-item scenario, and an only phrase over the latter. The rows with an expression feature are Löbner's predicative tests (114)–(115), in the scenario where both subjects satisfy the noun.

                                                                  Instances For
                                                                    @[instance_reducible]
                                                                    Equations
                                                                    @[instance_reducible]
                                                                    Equations
                                                                    • One or more equations did not get rendered due to their size.
                                                                    def CoppockBeaver2015.Scenario.restrictors :
                                                                    List (String × (Item → SignType))

                                                                    restrictors maps a row's restrictor feature to its predicate.

                                                                    Equations
                                                                    • One or more equations did not get rendered due to their size.
                                                                    Instances For
                                                                      theorem CoppockBeaver2015.Scenario.restrictor_rows (row : Datum) :
                                                                      row ∈ Examples.all → ∀ P ∈ row.parse? "restrictor" restrictors, row.judgment = Judgment.acceptable ↔ the P Item.this ≠ 0

                                                                      A predicative-definite row is acceptable exactly when the definite of its restrictor is classical of the subject.

                                                                      def CoppockBeaver2015.Lobner.expressions :
                                                                      List (String × (Scenario.Item → SignType))

                                                                      expressions maps a row's expression, a predicative definite, indefinite, or possessive with a single possessor, to the predicate it forms from the noun in the scenario where both subjects satisfy it.

                                                                      Equations
                                                                      • One or more equations did not get rendered due to their size.
                                                                      Instances For
                                                                        def CoppockBeaver2015.Lobner.verdicts :
                                                                        List (String × Bool)

                                                                        verdicts reads a row's verdict as whether its test forces the two subjects to coincide.

                                                                        Equations
                                                                        Instances For
                                                                          theorem CoppockBeaver2015.Lobner.rows (row : Datum) :
                                                                          row ∈ Examples.all → ∀ p ∈ row.parse? "expression" expressions, ∀ v ∈ row.parse? "verdict" verdicts, v = true ↔ ∀ (a b : Scenario.Item), (p a).meetWeak (p b) = 1 → a = b

                                                                          With both subjects satisfying the noun, a row's test verdict is coincidence of the two subjects exactly for the definite (eq_of_the_eq_one), the predicative tests (114)–(115).