Documentation

Studies.FrankeBergen2020

Franke and Bergen (2020): Theory-Driven Statistical Modeling for Semantics and Pragmatics #

Franke and Bergen compare four rational speech act models, in the style of Frank and Goodman, of the nested Aristotelians Q₁ of the aliens drank Q₂ of their water, with none, some and all in each position. An alien's type is the vertex of the triangle of opposition its drinking falls on (Aristotelian.Triangle), none of its water, some but not all, or all, a world state is the nonempty set of types some alien realizes, and a parse is the set of sites, among the whole sentence and the two quantifiers, at which an exhaustivity operator applies. The vanilla model has only the literal parse; lexical uncertainty, after Bergen, Levy and Goodman and Potts et al., fixes a lexicon per speaker; the local- and global-implicature speakers choose an utterance together with a matrix-free or arbitrary parse, one softmax over pairs per world.

Main results #

Implementation notes #

References #

The grammar of readings #

Domain #

A world state is the set of alien types realized by at least one alien, a nonempty set of vertices of the triangle.

Equations
Instances For
    @[instance_reducible]
    Equations
    @[instance_reducible]
    Equations
    @[instance_reducible]
    Equations
    @[instance_reducible]
    Equations

    The world with only N-type aliens (each drank none).

    Equations
    Instances For

      The world with only S-type aliens (each drank some but not all).

      Equations
      Instances For

        The world with only A-type aliens (each drank all).

        Equations
        Instances For

          An EXH operator can be inserted at the whole sentence, the outer quantifier, or the inner quantifier.

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

            A parse is the set of EXH insertion sites.

            Equations
            Instances For
              @[instance_reducible]
              Equations

              The matrix-only parse M.

              Equations
              Instances For

                The outer-only parse O.

                Equations
                Instances For

                  The Aristotelian quantifiers make up the utterance vocabulary.

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

                      The nine nested Aristotelian utterances are named outer quantifier first, so that .ns is "None of the aliens drank some of their water".

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

                          Alternative quantifiers #

                          Sentential alternatives (A3a) substitute lexical alternatives per quantifier position: some ↔ all, and not all for none.

                          The quantifiers of sentential alternatives are the utterance quantifiers and not all, the lexical alternative of none.

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

                              Compositional semantics #

                              An alien of a given type satisfies "drank Q" according to its place on the scale, some holding above the bottom vertex and all at the top one.

                              Equations
                              Instances For

                                Quantifier denotation over the alien types realized in a world.

                                Equations
                                Instances For
                                  @[instance_reducible]
                                  instance FrankeBergen2020.instDecidableEvalOfDecidablePredTriangle (q : AltQuant) (w : World) (sat : Aristotelian.Triangle → Prop) [DecidablePred sat] :
                                  Decidable (q.eval w sat)
                                  Equations

                                  not all is the negation of all, definitionally.

                                  none is the negation of some.

                                  @[reducible, inline]

                                  A sentential alternative is a pair of alternative quantifiers.

                                  Equations
                                  Instances For

                                    Literal meaning of a sentential alternative.

                                    Equations
                                    Instances For

                                      Literal meaning of an utterance.

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

                                        Compositional exhaustification #

                                        The sentential alternatives at matrix position (A3a) combine the scale-mate candidates at the two quantifier positions.

                                        Equations
                                        Instances For

                                          After EXH enrichment, when licensed, inner some is conjoined with its not-all implicature and holds at the IO vertex exactly; Exh(none) and Exh(all) are vacuous.

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

                                            The sub-matrix reading applies the in-situ enrichments, with outer EXH (Exh(some) at the outer position) as an implication guard.

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

                                              A sentential alternative is strictly stronger than the sub-matrix reading when its literal meaning is a proper subset of it (A3b), so an utterance's own literal meaning qualifies when a parse weakens it, as for NS under MI.

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

                                                The matrix-exhaustified reading is the sub-matrix reading with the literal meaning of every strictly stronger sentential alternative negated.

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

                                                  The exhaustified meaning under a parse is the sub-matrix reading, negating the strictly stronger alternatives when M is in the parse and doing so is noncontradictory (eq. A2).

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

                                                    Truth-table verification (the paper's Table 1) #

                                                    One characterization per utterance, total over all eight parses — the paper's row-groups appear as the guards. Each reading is a membership predicate on the world's alien-type set, not a truth vector.

                                                    In Table 1, NN excludes N-types, and matrix parses also negate "none drank not all", which is {wA}, the reading of fn. 7 from the alternative not all of none.

                                                    theorem FrankeBergen2020.table1_ns (p : Parse) (w : World) :
                                                    exhMeaning p Utterance.ns w ↔ if ExhPosition.inner ∈ p then Aristotelian.Triangle.IO ∉ w ∧ (ExhPosition.matrix ∈ p → w ≠ wN) else w = wN

                                                    In Table 1, NS literally holds at wN alone; inner EXH weakens it to the S-free worlds, whereupon matrix EXH negates the sentence's own now-stronger literal meaning {wN}.

                                                    In Table 1, NA excludes A-types, and matrix EXH negates the stronger NS, which is {wN}.

                                                    In Table 1, SN requires an N-type, and outer or matrix EXH negates AN, which is {wN}.

                                                    theorem FrankeBergen2020.table1_ss (p : Parse) (w : World) :
                                                    exhMeaning p Utterance.ss w ↔ if ExhPosition.inner ∈ p then Aristotelian.Triangle.IO ∈ w ∧ (ExhPosition.outer ∈ p → w ≠ wS) else if ExhPosition.outer ∈ p then Aristotelian.Triangle.E ∈ w ∧ w ≠ wN else if ExhPosition.matrix ∈ p then w = wNS else w ≠ wN

                                                    In Table 1, SS has five row-groups. Inner EXH requires an S-type, matrix EXH then being vacuous, and adding outer EXH excludes wS; outer EXH alone keeps the mixed worlds, matrix EXH alone pins wNS, and the literal parse excludes wN alone.

                                                    In Table 1, SA requires an A-type, and outer or matrix EXH excludes wA.

                                                    In Table 1, AN holds at wN alone under every parse.

                                                    theorem FrankeBergen2020.table1_as (p : Parse) (w : World) :
                                                    exhMeaning p Utterance.as w ↔ if ExhPosition.inner ∈ p then w = wS else Aristotelian.Triangle.E ∉ w ∧ (ExhPosition.matrix ∈ p → w ≠ wA)

                                                    In Table 1, AS excludes N-types; inner EXH pins wS, and matrix EXH without inner EXH negates AA, excluding wA.

                                                    In Table 1, AA holds at wA alone under every parse.

                                                    Literal meaning is the empty parse's exhaustified meaning.

                                                    ⟦SS⟧^M = {wNS}, the reading that "uniquely singles out this world state" in the discussion of eq. 22 and drives GI's win; the matrix-alone case of table1_ss.

                                                    The matrix operator (eq. A2) is not innocent exclusion, since at MOI its strictly-stronger filter is empty and ⟦SS⟧^MOI keeps wSA, which innocent exclusion over the same alternatives excludes.

                                                    theorem FrankeBergen2020.exists_true (w : World) (p : Parse) :
                                                    ∃ (u : Utterance), exhMeaning p u w

                                                    Every (world, parse) state has a true utterance.

                                                    The models #

                                                    The reading family and the pooled models #

                                                    Each parse gives every utterance an extension, and every model is the speaker and listener of RSA at a uniform prior over this family. The vanilla model (§3.1) uses the literal parse. In GI (eq. 21a) and LI (eq. 18a) the speaker chooses an utterance together with a parse and the listener hears the utterance, while in LU (eq. 11) the lexicon is an argument of the speaker, who addresses that lexicon's literal listener. The weights agree, so the models differ only in the position of the latent parameter (p. e86), and ss_m_parse_pref against perParse_ss_prefers_o turns that difference into diverging predictions.

                                                    def FrankeBergen2020.ext (p : Parse) (u : Utterance) :
                                                    Finset World

                                                    The extension of an utterance under a parse.

                                                    Equations
                                                    Instances For
                                                      @[simp]
                                                      theorem FrankeBergen2020.mem_ext {p : Parse} {u : Utterance} {w : World} :
                                                      w ∈ ext p u ↔ exhMeaning p u w
                                                      @[reducible, inline]
                                                      noncomputable abbrev FrankeBergen2020.literal (p : Parse) :
                                                      ProbabilityTheory.Kernel Utterance World

                                                      The literal listener under a parse (eq. 5) is uniform on the extension of the utterance.

                                                      Equations
                                                      Instances For
                                                        @[reducible, inline]
                                                        noncomputable abbrev FrankeBergen2020.speaker (p : Parse) (α : ℝ) :
                                                        ProbabilityTheory.Kernel World Utterance

                                                        The speaker under a parse (eq. 7) knows the world and addresses that parse's literal listener.

                                                        Equations
                                                        Instances For
                                                          @[reducible, inline]
                                                          noncomputable abbrev FrankeBergen2020.vanillaListener (α : ℝ) :
                                                          ProbabilityTheory.Kernel Utterance World

                                                          The vanilla listener (eq. 9) inverts the speaker of the literal parse.

                                                          Equations
                                                          Instances For

                                                            The GI choice space (eq. 21a) consists of utterance–parse pairs over the full reading family, heard as the utterance.

                                                            Equations
                                                            Instances For
                                                              @[reducible, inline]
                                                              noncomputable abbrev FrankeBergen2020.giSpeaker (α : ℝ) :
                                                              ProbabilityTheory.Kernel World (Utterance × Parse)

                                                              The GI speaker (eq. 21a) chooses an utterance together with a parse.

                                                              Equations
                                                              • One or more equations did not get rendered due to their size.
                                                              Instances For
                                                                @[reducible, inline]
                                                                noncomputable abbrev FrankeBergen2020.giJointListener (α : ℝ) :
                                                                ProbabilityTheory.Kernel Utterance (World × Utterance × Parse)

                                                                The GI listener (eq. 21b) hears the utterance of the speaker's choice and infers the world and the choice.

                                                                Equations
                                                                • One or more equations did not get rendered due to their size.
                                                                Instances For
                                                                  @[reducible, inline]
                                                                  noncomputable abbrev FrankeBergen2020.giListener (α : ℝ) :
                                                                  ProbabilityTheory.Kernel Utterance World

                                                                  The GI listener marginalized to worlds.

                                                                  Equations
                                                                  Instances For
                                                                    @[reducible, inline]
                                                                    noncomputable abbrev FrankeBergen2020.giParsePosterior (α : ℝ) :
                                                                    ProbabilityTheory.Kernel Utterance (Utterance × Parse)

                                                                    The GI listener marginalized to the speaker's choice of utterance and parse.

                                                                    Equations
                                                                    Instances For

                                                                      An LI parse is lit, I, O or OI, matrix-EXH parses being unavailable.

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

                                                                          LI cannot access matrix EXH, since no LI parse includes M.

                                                                          The LI choice space (eq. 18a) consists of pairs over the matrix-free parses.

                                                                          Equations
                                                                          Instances For
                                                                            @[reducible, inline]
                                                                            noncomputable abbrev FrankeBergen2020.liSpeaker (α : ℝ) :
                                                                            ProbabilityTheory.Kernel World (Utterance × LIParse)

                                                                            The LI speaker (eq. 18a) chooses an utterance together with a matrix-free parse.

                                                                            Equations
                                                                            • One or more equations did not get rendered due to their size.
                                                                            Instances For
                                                                              @[reducible, inline]
                                                                              noncomputable abbrev FrankeBergen2020.liListener (α : ℝ) :
                                                                              ProbabilityTheory.Kernel Utterance World

                                                                              The LI listener (eq. 18b), marginalized to worlds.

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

                                                                                Lexical uncertainty: the latent as a speaker argument #

                                                                                An LU lexicon is literal or OI, with inner and outer EXH. Each speaker has a fixed lexicon, and the listener marginalizes over the two lexica.

                                                                                Instances For
                                                                                  @[instance_reducible]
                                                                                  Equations
                                                                                  def FrankeBergen2020.instReprLULex.repr :
                                                                                  LULex → ℕ → Std.Format
                                                                                  Equations
                                                                                  • One or more equations did not get rendered due to their size.
                                                                                  Instances For
                                                                                    @[instance_reducible]
                                                                                    Equations
                                                                                    • One or more equations did not get rendered due to their size.
                                                                                    @[instance_reducible]
                                                                                    Equations

                                                                                    LU cannot access matrix EXH, since neither lexicon includes M.

                                                                                    noncomputable def FrankeBergen2020.luListener (α : ℝ) :
                                                                                    ProbabilityTheory.Kernel Utterance (World × LULex)

                                                                                    The LU listener (eqs. 12–13) inverts the speaker of eq. 11, who has a fixed lexicon, at a uniform prior over worlds and lexica.

                                                                                    Equations
                                                                                    Instances For

                                                                                      The rejected architecture: per-parse normalization #

                                                                                      noncomputable def FrankeBergen2020.perParseListener (α : ℝ) :
                                                                                      ProbabilityTheory.Kernel Utterance (World × Parse)

                                                                                      The architecture the paper rejects as "conceptually highly implausible" (p. e85) takes the full parse family with the parse as a speaker argument, eq. 11 with an enlarged latent set rather than the pooled choice of eq. 21a. Its listener inverts the per-parse speaker at a uniform prior over worlds and parses.

                                                                                      Equations
                                                                                      Instances For

                                                                                        The findings #

                                                                                        Exhaustified interpretation #

                                                                                        Hearing "some of the aliens drank some of their water", the pooled listener favors the world where no alien drank all of its water over the one where some did (inner exhaustification).

                                                                                        theorem FrankeBergen2020.ss_outer_exh {α : ℝ} (hα : 0 < α) :
                                                                                        ((giListener α) Utterance.ss).real {wS} < ((giListener α) Utterance.ss).real {wNS}

                                                                                        Hearing "some of the aliens drank some of their water", the pooled listener favors a world where some alien drank nothing (outer exhaustification).

                                                                                        theorem FrankeBergen2020.aa_identifies {α : ℝ} (hα : 0 < α) :
                                                                                        ((giListener α) Utterance.aa).real {wSA} < ((giListener α) Utterance.aa).real {wA}

                                                                                        Hearing "all of the aliens drank all of their water", the pooled listener favors the unique world where every alien did just that.

                                                                                        theorem FrankeBergen2020.as_inner_exh {α : ℝ} (hα : 0 < α) :
                                                                                        ((giListener α) Utterance.as).real {wA} < ((giListener α) Utterance.as).real {wS}

                                                                                        Hearing "all of the aliens drank some of their water", the pooled listener favors the world where every alien drank some but not all (inner exhaustification).

                                                                                        The model comparison #

                                                                                        theorem FrankeBergen2020.vanilla_ss_prefers_wNA {α : ℝ} (hα : 0 < α) :

                                                                                        Hearing "some of the aliens drank some of their water", the literal-semantics listener favors all-drinkers over some-but-not-all drinkers — opposite to the attested preference.

                                                                                        theorem FrankeBergen2020.gi_ss_prefers_wNS {α : ℝ} (hα : 0 < α) :
                                                                                        ((giListener α) Utterance.ss).real {wNA} < ((giListener α) Utterance.ss).real {wNS}

                                                                                        Hearing "some of the aliens drank some of their water", the pooled listener favors some-but-not-all drinkers over all-drinkers, as attested.

                                                                                        theorem FrankeBergen2020.li_ss_outer_exh {α : ℝ} (hα : 0 < α) :
                                                                                        ((liListener α) Utterance.ss).real {wS} < ((liListener α) Utterance.ss).real {wNS}

                                                                                        Hearing "some of the aliens drank some of their water", the matrix-free pooled listener still favors a world where some alien drank nothing (outer exhaustification).

                                                                                        theorem FrankeBergen2020.li_ss_prefers_wNS {α : ℝ} (hα : 0 < α) :
                                                                                        ((liListener α) Utterance.ss).real {wNA} < ((liListener α) Utterance.ss).real {wNS}

                                                                                        Hearing "some of the aliens drank some of their water", the matrix-free pooled listener favors some-but-not-all drinkers over all-drinkers.

                                                                                        theorem FrankeBergen2020.lu_ss_prefers_wNS {α : ℝ} (hα : 0 < α) :
                                                                                        ((luListener α) Utterance.ss).fst.real {wNA} < ((luListener α) Utterance.ss).fst.real {wNS}

                                                                                        Hearing "some of the aliens drank some of their water", the lexical-uncertainty listener favors some-but-not-all drinkers over all-drinkers.

                                                                                        The position of the latent parameter #

                                                                                        Hearing "some of the aliens drank some of their water", the pooled listener's parse posterior peaks at exhaustification of the whole sentence.

                                                                                        theorem FrankeBergen2020.perParse_ss_prefers_o {α : ℝ} (hα : 0 < α) :
                                                                                        ((perParseListener α) Utterance.ss).snd.real {pM} < ((perParseListener α) Utterance.ss).snd.real {pO}

                                                                                        Hearing "some of the aliens drank some of their water", the per-parse listener favors exhaustifying the outer quantifier over exhaustifying the whole sentence.