Documentation

Linglib.Studies.FrankeBergen2020

[FB20b] — GI-RSA for Nested Aristotelians #

[FB20b] [Fox07] [Fra11]

"Theory-driven statistical modeling for semantics and pragmatics: A case study on grammatically generated implicature readings"

The Model #

Domain: Nested Aristotelian sentences "Q₁ of the aliens drank Q₂ of their water" with Q₁, Q₂ ∈ {none, some, all}. 7 world states based on which alien types exist (none-drinkers, some-drinkers, all-drinkers). 8 grammatical parses (subsets of {M, O, I} EXH positions) as latent variables.

The Global Intentions (GI) model treats the parse as a latent variable: the speaker chooses both an utterance and a parse, the listener marginalizes over parses to recover the world state.

Exhaustification uses compositional enrichment at inner/outer quantifier positions: Exh(Q) conjoins Q with the negation of all strictly stronger lexical alternatives on the {some, all} scale ([Fox07]). Only Exh(some) = "some but not all" is non-vacuous; Exh(all) and Exh(none) have no strictly stronger alternative.

At matrix position, EXH uses exh_MW (eq. A2): negate the LITERAL meanings of sentential alternatives that are strictly stronger than the sub-matrix enriched meaning, with a noncontradictory fallback. Sentential alternatives are the cross-product of scale-mate substitutions ({some, all}) for each on-scale quantifier. "none" is treated as off-scale; the paper notes (fn. 7) that including "not all" as an alternative to "none" has negligible effect on predictions.

Parameters: α = 2 (modeling choice; the paper estimates α jointly with cost and error parameters, reporting MLE ≈ 1.3 for GI), uniform priors. The paper's cost term c(u) for "none"-initial utterances and error term ε are omitted; the qualitative predictions below are robust to these simplifications.

Qualitative Findings #

#FindingTheorem
1SS exhaustifies inner Qss_inner_exh
2SS exhaustifies outer Qss_outer_exh
3AA identifies unique worldaa_identifies
4AS exhaustifies inner Qas_inner_exh
5Full EXH preferred for SSss_parse_pref
6Vanilla gets SS wrong (prefers wNA)vanilla_ss_prefers_wNA
7GI gets SS right (prefers wNS)gi_ss_prefers_wNS
8LU gets SS→wNS rightlu_ss_prefers_wNS
9LI derives outer exh for SSli_ss_outer_exh
10LI also gets SS→wNS rightli_ss_prefers_wNS

Model Comparison #

All four models share one per-parse speaker S(w, p) (the softmax at exponent α = 2 of the parse-p literal listener), because the speaker at a (world, parse) state depends only on that parse's Boolean meaning. They differ only in the latent space the pragmatic listener marginalises over — a joint PMF (World × Latent) posterior (RSA.Canonical.L1) with a uniform prior:

The listener predictions are decided by exact PMF evaluation: each speaker mass S(w, p) u is a rational ENNReal.ofReal value (s_* lemmas below), and each theorem reduces via RSA.Canonical.L1_world_prefers_iff (or _latent_prefers_iff) to a comparison of pooled speaker sums over the latent.

Bayesian model comparison: GI achieves 0.956 posterior probability, LI = 0.033, LU = 0.010, vanilla = 0.

Aristotelian quantifiers: none, some, all.

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

      The 7 world states, distinguished by which alien types exist. Three types: N (drank none), S (drank some but not all), A (drank all). Worlds are the 7 non-empty subsets of {N, S, A}.

      Instances For
        @[implicit_reducible]
        Equations
        def FrankeBergen2020.instReprWorld.repr :
        WorldStd.Format
        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          @[implicit_reducible]
          Equations
          • One or more equations did not get rendered due to their size.

          The 9 nested Aristotelian utterances: Q_outer × Q_inner.

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

              The 8 grammatical parses: subsets of {M, O, I} EXH positions.

              Instances For
                @[implicit_reducible]
                Equations
                def FrankeBergen2020.instReprParse.repr :
                ParseStd.Format
                Equations
                Instances For
                  @[implicit_reducible]
                  Equations
                  • One or more equations did not get rendered due to their size.

                  Whether N-type aliens (drank none) exist.

                  Equations
                  Instances For

                    Whether S-type aliens (drank some but not all) exist.

                    Equations
                    Instances For

                      Whether A-type aliens (drank all) exist.

                      Equations
                      Instances For

                        Whether a quantifier is on the lexical scale {some, all}.

                        Equations
                        Instances For

                          Whether parse includes EXH at inner position.

                          Equations
                          Instances For

                            Whether parse includes EXH at outer position.

                            Equations
                            Instances For

                              Whether parse includes EXH at matrix position.

                              Equations
                              Instances For
                                def FrankeBergen2020.innerTypeSat (qi : AristQuant) :
                                Bool × Bool × Bool

                                Inner VP satisfaction: which alien types satisfy "drank Q"?

                                • Q = none: N-types satisfy (drank none of their water)
                                • Q = some: S-types and A-types satisfy (drank some)
                                • Q = all: only A-types satisfy (drank all)
                                Equations
                                Instances For
                                  def FrankeBergen2020.outerEval (qo : AristQuant) (nSat sSat aSat : Bool) (w : World) :
                                  Bool

                                  Outer quantifier evaluation: does the world satisfy "Q_outer of the aliens [satisfy inner VP]"? nSat, sSat, aSat indicate which alien types satisfy the inner VP.

                                  Equations
                                  Instances For

                                    Literal meaning: compose inner VP satisfaction with outer quantifier.

                                    Equations
                                    Instances For

                                      All 7 worlds for enumeration.

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        def FrankeBergen2020.enrichedInnerTypeSat (qi : AristQuant) (hasI : Bool) :
                                        Bool × Bool × Bool

                                        Inner VP satisfaction after EXH enrichment. Only "some" is enrichable: Exh(some) = "some but not all" — satisfied by S-types only (not A-types). Exh(none) and Exh(all) are vacuous (no strictly stronger alternative).

                                        Equations
                                        Instances For

                                          Sentential alternatives at matrix position: cross-product of scale-mate substitutions for each scalar item in the utterance. Non-scalar positions are held fixed.

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

                                            Exhaustified meaning under a given parse, using compositional enrichment.

                                            Inner/outer EXH enrich quantifiers in situ (at the quantifier level, not the sentence level), following the paper's Appendix. Only "some" → "some but not all" is a meaningful enrichment; Exh(all) and Exh(none) are vacuous (no strictly stronger lexical alternative on the scale).

                                            Matrix EXH uses exh_MW with a strength filter: negate the LITERAL meanings of sentential alternatives that are strictly stronger than the enriched (sub-matrix) meaning. Fall back to no matrix EXH if the conjunction is contradictory (eq. A2).

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

                                              Literal SS is true at 6 of 7 worlds (all except wN).

                                              EXH_I(SS) = worlds with S-types (compositional: "some aliens drank some but not all"). Inner EXH enriches "some" to "some but not all", so S-types satisfy the VP but A-types do not. The outer "some" requires at least one S-type, giving {wNS, wNSA, wS, wSA}.

                                              EXH_OI(SS) = {wNS, wNSA, wSA} — outer "some but not all" alien types satisfy the enriched inner predicate. wS excluded because at wS all types (just S) satisfy the inner pred, so "all" would be true.

                                              EXH_MOI(SS) = EXH_OI(SS) = {wNS, wNSA, wSA} — matrix EXH is vacuous here because no sentential alternative is strictly stronger than the OI-enriched meaning.

                                              AA is true only at wA under all parses.

                                              theorem FrankeBergen2020.table1_ss :
                                              List.map (exhMeaning Parse.none Utterance.ss) allWorlds = [false, true, true, true, true, true, true] List.map (exhMeaning Parse.i Utterance.ss) allWorlds = [false, true, false, true, true, true, false] List.map (exhMeaning Parse.oi Utterance.ss) allWorlds = [false, true, false, true, false, true, false] List.map (exhMeaning Parse.moi Utterance.ss) allWorlds = [false, true, false, true, false, true, false]

                                              Full truth table for SS across key parses, matching Table 1 of the paper. Format: (parse, [wN, wNS, wNA, wNSA, wS, wSA, wA]).

                                              LU lexicon: literal or OI (inner + outer EXH). Each speaker has a fixed lexicon; the listener marginalizes over the two lexica to infer the world state. Mirrors the [PLLF16] architecture.

                                              Instances For
                                                @[implicit_reducible]
                                                Equations
                                                def FrankeBergen2020.instReprLULex.repr :
                                                LULexStd.Format
                                                Equations
                                                • One or more equations did not get rendered due to their size.
                                                Instances For

                                                  LI parse: lit, I, O, or OI. The speaker actively chooses a parse per utterance (unlike LU, where each speaker has a fixed lexicon).

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

                                                      All four models share one speaker family S : World × Parse → PMF Utterance: the [FG12] softmax at exponent α = 2 of the per-parse literal listener L0(· | u, p) (uniform on exhMeaning p u's extension). The speaker at state (w, p) depends only on parse p's Boolean meaning, so vanilla / LU / LI / GI differ only in the latent space their pragmatic listener marginalises over. Built on the RSA.Canonical PMF pipeline (powUtility/L0OfBool), so S = PMF.normalize (L0^2) (RSA.Canonical.S1_powUtility_eq_normalize).

                                                      Every utterance is true at some world under every parse, so each per-parse literal listener is well-defined (L0OfBool's nonempty-extension obligation).

                                                      noncomputable def FrankeBergen2020.L0m :
                                                      ParseUtterancePMF World

                                                      The per-parse literal listener L0(· | u, p) : PMF World, uniform on the extension of exhMeaning p u.

                                                      Equations
                                                      Instances For
                                                        theorem FrankeBergen2020.exists_true (w : World) (p : Parse) :
                                                        ∃ (u : Utterance), exhMeaning p u w = true

                                                        Every (world, parse) state has an applicable (true) utterance — the ViableSpeaker witness that makes the softmax speaker well-defined.

                                                        noncomputable def FrankeBergen2020.S :
                                                        World × ParsePMF Utterance

                                                        The shared pragmatic speaker S(w, p) ∝ L0(w | ·, p)^2 (α = 2, no cost).

                                                        Equations
                                                        Instances For
                                                          noncomputable def FrankeBergen2020.luS (s : World × LULex) :

                                                          LU speaker: the shared speaker re-indexed by the 2-lexicon latent.

                                                          Equations
                                                          Instances For
                                                            noncomputable def FrankeBergen2020.liS (s : World × LIParse) :

                                                            LI speaker: the shared speaker re-indexed by the 4-parse latent.

                                                            Equations
                                                            Instances For
                                                              noncomputable def FrankeBergen2020.vanillaS (w : World) :

                                                              Vanilla speaker: the shared speaker at the literal parse only.

                                                              Equations
                                                              Instances For

                                                                Each speaker mass S(w, p) u is an exact rational: 0 when exhMeaning p u w is false, else |ext(p,u)|⁻² / Z(w,p) where Z(w,p) = Σ_u |ext(p,u)|⁻² sums over utterances true at w. The pw_* lemmas give the unnormalised weight L0^2; the Z_* lemmas the partition; the s_* lemmas the normalised mass as ENNReal.ofReal q. Cards are certified by decide, arithmetic by norm_num.

                                                                theorem FrankeBergen2020.pw_true {p : Parse} {u : Utterance} {w : World} {k : } (h : exhMeaning p u w = true) (hk : (RSA.extensionOf (exhMeaning p) u).card = k) :
                                                                RSA.Canonical.powWeight 2 L0m (w, p) u = ENNReal.ofReal ((↑k)⁻¹ ^ 2)

                                                                Unnormalised speaker weight at a true utterance: |ext(p,u)|⁻².

                                                                theorem FrankeBergen2020.pw_false {p : Parse} {u : Utterance} {w : World} (h : exhMeaning p u w = false) :
                                                                RSA.Canonical.powWeight 2 L0m (w, p) u = ENNReal.ofReal 0

                                                                Unnormalised speaker weight at a false utterance: 0 (as ofReal 0, so partition sums combine uniformly through ENNReal.ofReal_add).

                                                                Enumeration of the nine utterances (for partition sums).

                                                                theorem FrankeBergen2020.S_val {p : Parse} {u : Utterance} {w : World} {k : } {z q : } (h : exhMeaning p u w = true) (hk : (RSA.extensionOf (exhMeaning p) u).card = k) (hz : 0 < z) (hZ : ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (w, p) u' = ENNReal.ofReal z) (hq : (↑k)⁻¹ ^ 2 / z = q) :
                                                                (S (w, p)) u = ENNReal.ofReal q

                                                                Normalised speaker mass at a true utterance: |ext(p,u)|⁻² / Z(w,p), as an exact ENNReal.ofReal rational. hZ supplies the partition Z(w,p).

                                                                theorem FrankeBergen2020.S_zero {p : Parse} {u : Utterance} {w : World} (h : exhMeaning p u w = false) :
                                                                (S (w, p)) u = 0

                                                                Normalised speaker mass at a false utterance: 0.

                                                                theorem FrankeBergen2020.S_zero' {p : Parse} {u : Utterance} {w : World} (h : exhMeaning p u w = false) :
                                                                (S (w, p)) u = ENNReal.ofReal 0

                                                                S_zero in ofReal 0 form, so pooled parse sums combine uniformly.

                                                                theorem FrankeBergen2020.S_ne_zero {p : Parse} {u : Utterance} {w : World} (h : exhMeaning p u w = true) :
                                                                (S (w, p)) u 0

                                                                The shared speaker never assigns zero mass to a true utterance — the witness for the pragmatic listener's marginal-nonzero obligations.

                                                                theorem FrankeBergen2020.Z_none_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.none) u' = ENNReal.ofReal (29 / 144)

                                                                Partition Z(wNS, none) = 1/9 + 1/16 + 1/36 = 29/144 (SS-worlds: na, sn, ss).

                                                                theorem FrankeBergen2020.s_none_wNS_ss :
                                                                (S (World.wNS, Parse.none)) Utterance.ss = ENNReal.ofReal (4 / 29)

                                                                S(wNS, none) ss = 4/29.

                                                                theorem FrankeBergen2020.sumParse (f : ParseENNReal) :
                                                                p : Parse, f p = f Parse.none + f Parse.m + f Parse.o + f Parse.i + f Parse.mo + f Parse.mi + f Parse.oi + f Parse.moi

                                                                Enumeration of the eight parses (for the GI latent marginal).

                                                                wNS partition and speaker masses (SS) #

                                                                theorem FrankeBergen2020.Z_m_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.m) u' = ENNReal.ofReal (49 / 36)
                                                                theorem FrankeBergen2020.Z_o_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.o) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_i_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.i) u' = ENNReal.ofReal (17 / 72)
                                                                theorem FrankeBergen2020.Z_mo_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.mo) u' = ENNReal.ofReal (17 / 36)
                                                                theorem FrankeBergen2020.Z_mi_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.mi) u' = ENNReal.ofReal (61 / 144)
                                                                theorem FrankeBergen2020.Z_oi_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.oi) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_moi_wNS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNS, Parse.moi) u' = ENNReal.ofReal (17 / 36)
                                                                theorem FrankeBergen2020.s_m_wNS_ss :
                                                                (S (World.wNS, Parse.m)) Utterance.ss = ENNReal.ofReal (36 / 49)
                                                                theorem FrankeBergen2020.s_o_wNS_ss :
                                                                (S (World.wNS, Parse.o)) Utterance.ss = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_i_wNS_ss :
                                                                (S (World.wNS, Parse.i)) Utterance.ss = ENNReal.ofReal (9 / 34)
                                                                theorem FrankeBergen2020.s_mo_wNS_ss :
                                                                (S (World.wNS, Parse.mo)) Utterance.ss = ENNReal.ofReal (4 / 17)
                                                                theorem FrankeBergen2020.s_mi_wNS_ss :
                                                                (S (World.wNS, Parse.mi)) Utterance.ss = ENNReal.ofReal (9 / 61)
                                                                theorem FrankeBergen2020.s_oi_wNS_ss :
                                                                (S (World.wNS, Parse.oi)) Utterance.ss = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_moi_wNS_ss :
                                                                (S (World.wNS, Parse.moi)) Utterance.ss = ENNReal.ofReal (4 / 17)
                                                                theorem FrankeBergen2020.sumP_wNS_ss :
                                                                p : Parse, (S (World.wNS, p)) Utterance.ss = ENNReal.ofReal (21415141 / 8841462)

                                                                wNSA partition and speaker masses (SS) #

                                                                theorem FrankeBergen2020.Z_none_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.none) u' = ENNReal.ofReal (11 / 72)
                                                                theorem FrankeBergen2020.Z_o_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.o) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_i_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.i) u' = ENNReal.ofReal (3 / 16)
                                                                theorem FrankeBergen2020.Z_mo_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.mo) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_mi_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.mi) u' = ENNReal.ofReal (41 / 144)
                                                                theorem FrankeBergen2020.Z_oi_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.oi) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_moi_wNSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNSA, Parse.moi) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_o_wNSA_ss :
                                                                (S (World.wNSA, Parse.o)) Utterance.ss = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_i_wNSA_ss :
                                                                (S (World.wNSA, Parse.i)) Utterance.ss = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_mi_wNSA_ss :
                                                                (S (World.wNSA, Parse.mi)) Utterance.ss = ENNReal.ofReal (9 / 41)
                                                                theorem FrankeBergen2020.sumP_wNSA_ss :
                                                                p : Parse, (S (World.wNSA, p)) Utterance.ss = ENNReal.ofReal (2798 / 1353)

                                                                wS partition and speaker masses (SS and AS) #

                                                                theorem FrankeBergen2020.Z_none_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.none) u' = ENNReal.ofReal (13 / 36)
                                                                theorem FrankeBergen2020.Z_m_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.m) u' = ENNReal.ofReal (11 / 18)
                                                                theorem FrankeBergen2020.Z_o_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.o) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_i_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.i) u' = ENNReal.ofReal (185 / 144)
                                                                theorem FrankeBergen2020.Z_mo_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.mo) u' = ENNReal.ofReal (11 / 18)
                                                                theorem FrankeBergen2020.Z_mi_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.mi) u' = ENNReal.ofReal (205 / 144)
                                                                theorem FrankeBergen2020.Z_oi_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.oi) u' = ENNReal.ofReal (11 / 9)
                                                                theorem FrankeBergen2020.Z_moi_wS :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wS, Parse.moi) u' = ENNReal.ofReal (49 / 36)
                                                                theorem FrankeBergen2020.s_none_wS_ss :
                                                                (S (World.wS, Parse.none)) Utterance.ss = ENNReal.ofReal (1 / 13)
                                                                theorem FrankeBergen2020.s_i_wS_ss :
                                                                (S (World.wS, Parse.i)) Utterance.ss = ENNReal.ofReal (9 / 185)
                                                                theorem FrankeBergen2020.s_mi_wS_ss :
                                                                (S (World.wS, Parse.mi)) Utterance.ss = ENNReal.ofReal (9 / 205)
                                                                theorem FrankeBergen2020.s_m_wS_as :
                                                                (S (World.wS, Parse.m)) Utterance.as_ = ENNReal.ofReal (9 / 22)
                                                                theorem FrankeBergen2020.s_o_wS_as :
                                                                (S (World.wS, Parse.o)) Utterance.as_ = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_i_wS_as :
                                                                (S (World.wS, Parse.i)) Utterance.as_ = ENNReal.ofReal (144 / 185)
                                                                theorem FrankeBergen2020.s_mo_wS_as :
                                                                (S (World.wS, Parse.mo)) Utterance.as_ = ENNReal.ofReal (9 / 22)
                                                                theorem FrankeBergen2020.s_mi_wS_as :
                                                                (S (World.wS, Parse.mi)) Utterance.as_ = ENNReal.ofReal (144 / 205)
                                                                theorem FrankeBergen2020.s_oi_wS_as :
                                                                (S (World.wS, Parse.oi)) Utterance.as_ = ENNReal.ofReal (9 / 11)
                                                                theorem FrankeBergen2020.s_moi_wS_as :
                                                                (S (World.wS, Parse.moi)) Utterance.as_ = ENNReal.ofReal (36 / 49)

                                                                wNA, wSA, wA partitions and speaker masses #

                                                                theorem FrankeBergen2020.Z_none_wNA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNA, Parse.none) u' = ENNReal.ofReal (11 / 72)
                                                                theorem FrankeBergen2020.Z_o_wNA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNA, Parse.o) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_mo_wNA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wNA, Parse.mo) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_o_wNA_ss :
                                                                (S (World.wNA, Parse.o)) Utterance.ss = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.s_mo_wNA_ss :
                                                                (S (World.wNA, Parse.mo)) Utterance.ss = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_none_wSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wSA, Parse.none) u' = ENNReal.ofReal (5 / 16)
                                                                theorem FrankeBergen2020.Z_moi_wSA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wSA, Parse.moi) u' = ENNReal.ofReal (1 / 3)
                                                                theorem FrankeBergen2020.Z_none_wA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wA, Parse.none) u' = ENNReal.ofReal (21 / 16)
                                                                theorem FrankeBergen2020.Z_o_wA :
                                                                ∑' (u' : Utterance), RSA.Canonical.powWeight 2 L0m (World.wA, Parse.o) u' = ENNReal.ofReal (11 / 9)
                                                                theorem FrankeBergen2020.s_none_wA_ss :
                                                                (S (World.wA, Parse.none)) Utterance.ss = ENNReal.ofReal (4 / 189)
                                                                theorem FrankeBergen2020.s_none_wA_as :
                                                                (S (World.wA, Parse.none)) Utterance.as_ = ENNReal.ofReal (16 / 189)
                                                                theorem FrankeBergen2020.s_o_wA_as :
                                                                (S (World.wA, Parse.o)) Utterance.as_ = ENNReal.ofReal (1 / 11)

                                                                Pooled speaker sums for the remaining worlds #

                                                                theorem FrankeBergen2020.sumP_wS_ss :
                                                                p : Parse, (S (World.wS, p)) Utterance.ss = ENNReal.ofReal (16711 / 98605)
                                                                theorem FrankeBergen2020.sumP_wNA_ss :
                                                                p : Parse, (S (World.wNA, p)) Utterance.ss = ENNReal.ofReal (28 / 33)
                                                                theorem FrankeBergen2020.sumP_wS_as :
                                                                p : Parse, (S (World.wS, p)) Utterance.as_ = ENNReal.ofReal (716367317 / 159444285)
                                                                theorem FrankeBergen2020.sumP_wA_as :
                                                                p : Parse, (S (World.wA, p)) Utterance.as_ = ENNReal.ofReal (365 / 2079)

                                                                AA is false at wSA under every parse, so its pooled speaker sum is 0.

                                                                Latent pooling over worlds (parse-preference) #

                                                                theorem FrankeBergen2020.sumWorld (f : WorldENNReal) :
                                                                w : World, f w = f World.wN + f World.wNS + f World.wNA + f World.wNSA + f World.wS + f World.wSA + f World.wA

                                                                Enumeration of the seven worlds (for the GI parse marginal).

                                                                theorem FrankeBergen2020.sumW_none_ss :
                                                                w : World, (S (w, Parse.none)) Utterance.ss = ENNReal.ofReal (2698343 / 3918915)
                                                                theorem FrankeBergen2020.sumW_moi_ss :
                                                                w : World, (S (w, Parse.moi)) Utterance.ss = ENNReal.ofReal (46 / 51)

                                                                LU / LI pooling over the smaller latent spaces #

                                                                theorem FrankeBergen2020.sumLULex (f : LULexENNReal) :
                                                                l : LULex, f l = f LULex.lit + f LULex.oi
                                                                theorem FrankeBergen2020.sumLU_wNS_ss :
                                                                l : LULex, (luS (World.wNS, l)) Utterance.ss = ENNReal.ofReal (41 / 87)
                                                                theorem FrankeBergen2020.sumLU_wNA_ss :
                                                                l : LULex, (luS (World.wNA, l)) Utterance.ss = ENNReal.ofReal (2 / 11)
                                                                theorem FrankeBergen2020.sumLIParse (f : LIParseENNReal) :
                                                                l : LIParse, f l = f LIParse.lit + f LIParse.i + f LIParse.o + f LIParse.oi
                                                                theorem FrankeBergen2020.sumLI_wNS_ss :
                                                                l : LIParse, (liS (World.wNS, l)) Utterance.ss = ENNReal.ofReal (3163 / 2958)
                                                                theorem FrankeBergen2020.sumLI_wS_ss :
                                                                l : LIParse, (liS (World.wS, l)) Utterance.ss = ENNReal.ofReal (302 / 2405)
                                                                theorem FrankeBergen2020.sumLI_wNA_ss :
                                                                l : LIParse, (liS (World.wNA, l)) Utterance.ss = ENNReal.ofReal (17 / 33)
                                                                noncomputable def FrankeBergen2020.giListener (u : Utterance) (h : PMF.marginal S (PMF.uniformOfFintype (World × Parse)) u 0) :
                                                                PMF (World × Parse)

                                                                GI (§3.4): joint posterior over World × Parse (8 parses).

                                                                Equations
                                                                Instances For
                                                                  noncomputable def FrankeBergen2020.luListener (u : Utterance) (h : PMF.marginal luS (PMF.uniformOfFintype (World × LULex)) u 0) :
                                                                  PMF (World × LULex)

                                                                  LU (§3.2): joint posterior over World × LULex.

                                                                  Equations
                                                                  Instances For
                                                                    noncomputable def FrankeBergen2020.liListener (u : Utterance) (h : PMF.marginal liS (PMF.uniformOfFintype (World × LIParse)) u 0) :
                                                                    PMF (World × LIParse)

                                                                    LI (§3.3): joint posterior over World × LIParse.

                                                                    Equations
                                                                    Instances For
                                                                      noncomputable def FrankeBergen2020.vanillaListener (u : Utterance) (h : PMF.marginal vanillaS (PMF.uniformOfFintype World) u 0) :
                                                                      PMF World

                                                                      Vanilla (§3.1): posterior over World for the single literal parse.

                                                                      Equations
                                                                      Instances For

                                                                        Listener-preference reductions #

                                                                        Each pragmatic listener's preference cancels the uniform joint prior, leaving a comparison of pooled speaker sums over the model's latent space (L1_world_/ _latent_prefers_iff).

                                                                        theorem FrankeBergen2020.giListener_fst_lt (u : Utterance) (h : PMF.marginal S (PMF.uniformOfFintype (World × Parse)) u 0) (w₁ w₂ : World) :
                                                                        (giListener u h).fst w₁ < (giListener u h).fst w₂ p : Parse, (S (w₁, p)) u < p : Parse, (S (w₂, p)) u

                                                                        GI world preference reduces to the pooled speaker sum over the 8 parses.

                                                                        theorem FrankeBergen2020.giListener_snd_lt (u : Utterance) (h : PMF.marginal S (PMF.uniformOfFintype (World × Parse)) u 0) (l₁ l₂ : Parse) :
                                                                        (giListener u h).snd l₁ < (giListener u h).snd l₂ w : World, (S (w, l₁)) u < w : World, (S (w, l₂)) u

                                                                        GI parse preference reduces to the pooled speaker sum over the 7 worlds.

                                                                        theorem FrankeBergen2020.luListener_fst_lt (u : Utterance) (h : PMF.marginal luS (PMF.uniformOfFintype (World × LULex)) u 0) (w₁ w₂ : World) :
                                                                        (luListener u h).fst w₁ < (luListener u h).fst w₂ l : LULex, (luS (w₁, l)) u < l : LULex, (luS (w₂, l)) u

                                                                        LU world preference reduces to the pooled speaker sum over the 2 lexica.

                                                                        theorem FrankeBergen2020.liListener_fst_lt (u : Utterance) (h : PMF.marginal liS (PMF.uniformOfFintype (World × LIParse)) u 0) (w₁ w₂ : World) :
                                                                        (liListener u h).fst w₁ < (liListener u h).fst w₂ l : LIParse, (liS (w₁, l)) u < l : LIParse, (liS (w₂, l)) u

                                                                        LI world preference reduces to the pooled speaker sum over the 4 parses.

                                                                        Marginal-nonzero witnesses #

                                                                        theorem FrankeBergen2020.gi_marg_ss :
                                                                        PMF.marginal S (PMF.uniformOfFintype (World × Parse)) Utterance.ss 0
                                                                        theorem FrankeBergen2020.gi_marg_aa :
                                                                        PMF.marginal S (PMF.uniformOfFintype (World × Parse)) Utterance.aa 0
                                                                        theorem FrankeBergen2020.gi_marg_as :
                                                                        PMF.marginal S (PMF.uniformOfFintype (World × Parse)) Utterance.as_ 0
                                                                        theorem FrankeBergen2020.lu_marg_ss :
                                                                        PMF.marginal luS (PMF.uniformOfFintype (World × LULex)) Utterance.ss 0
                                                                        theorem FrankeBergen2020.li_marg_ss :
                                                                        PMF.marginal liS (PMF.uniformOfFintype (World × LIParse)) Utterance.ss 0

                                                                        The ten qualitative findings #

                                                                        SS exhaustifies inner quantifier: L1 prefers wNS (N and S types, no A) over wNSA (all three types including A). Inner EXH negates "some drank all", disfavoring worlds with A-type aliens.

                                                                        SS exhaustifies outer quantifier: L1 prefers wNS (mixed N+S types) over wS (only S-type). At wS, "all aliens drank some but not all" would be true, but outer EXH negates the "all" reading.

                                                                        AA correctly identifies the unique world where all aliens drank all: L1 prefers wA over wSA. AA is false at wSA under every parse (pooled sum 0), while at wA the literal parse already makes it true.

                                                                        AS exhaustifies inner: L1 prefers wS (all aliens are "some" drinkers) over wA (all aliens are "all" drinkers).

                                                                        Full exhaustification is preferred: for SS, the GI parse marginal assigns more probability to the fully exhaustified parse (MOI) than to the literal parse (NONE).

                                                                        Vanilla RSA hearing SS prefers wNA over wNS — the wrong prediction. Without exhaustification SS is literally true at 6/7 worlds, and the competing utterances make wNA "win" more of the S1 score. Production data show SS is used for wNS, evidence for grammatical enrichment.

                                                                        GI correctly predicts the opposite: SS → wNS, not wNA. The exhaustified parses concentrate probability on worlds with S-types but not A-types.

                                                                        LU also gets the key SS prediction right: wNS > wNA. The OI lexicon gives ⟦SS⟧^OI = {wNS, wNSA, wSA}, which excludes wNA, tipping the balance.

                                                                        LI derives outer exhaustification for SS via the OI parse: ⟦SS⟧^OI = {wNS, wNSA, wSA} pins down worlds with mixed types (wNS > wS).

                                                                        theorem FrankeBergen2020.table1_nn (p : Parse) :
                                                                        List.map (exhMeaning p Utterance.nn) allWorlds = [false, false, false, false, true, true, true]

                                                                        NN is vacuously exhaustified: "none" is off-scale, so EXH at any position has no alternatives to exclude. All parses agree.

                                                                        theorem FrankeBergen2020.table1_an (p : Parse) :
                                                                        List.map (exhMeaning p Utterance.an) allWorlds = [true, false, false, false, false, false, false]

                                                                        AN is maximally informative: all types must satisfy "drank none." Only wN (all N-types) works. All parses agree.

                                                                        theorem FrankeBergen2020.table1_aa (p : Parse) :
                                                                        List.map (exhMeaning p Utterance.aa) allWorlds = [false, false, false, false, false, false, true]

                                                                        AA is maximally informative: all types must satisfy "drank all." Only wA works. All parses agree (already proved in aa_singleton).

                                                                        theorem FrankeBergen2020.table1_ns :
                                                                        List.map (exhMeaning Parse.none Utterance.ns) allWorlds = [true, false, false, false, false, false, false]

                                                                        NS lit = {wN}: "none drank some" requires no type to satisfy "drank some." S-types and A-types satisfy, so they must be absent. Only wN (all N-types) works.

                                                                        theorem FrankeBergen2020.table1_sa :
                                                                        List.map (exhMeaning Parse.none Utterance.sa) allWorlds = [false, false, true, true, false, true, true] List.map (exhMeaning Parse.o Utterance.sa) allWorlds = [false, false, true, true, false, true, false]

                                                                        SA: "some drank all" requires ≥1 A-type. EXH_I vacuous (inner=all). EXH_O enriches outer "some" to "some but not all," excluding wA (where all types are A → "all" would hold).

                                                                        theorem FrankeBergen2020.table1_na :
                                                                        List.map (exhMeaning Parse.none Utterance.na) allWorlds = [true, true, false, false, true, false, false] List.map (exhMeaning Parse.m Utterance.na) allWorlds = [false, true, false, false, true, false, false]

                                                                        NA: "none drank all" requires no A-types. True at {wN, wNS, wS}. Matrix EXH negates the stronger alternative NS (= "none drank some" = {wN}), removing wN.

                                                                        theorem FrankeBergen2020.table1_sn :
                                                                        List.map (exhMeaning Parse.none Utterance.sn) allWorlds = [true, true, true, true, false, false, false] List.map (exhMeaning Parse.o Utterance.sn) allWorlds = [false, true, true, true, false, false, false]

                                                                        SN: "some drank none" requires ≥1 N-type. True at {wN, wNS, wNA, wNSA}. EXH_O enriches outer "some" to "some but not all," negating AN = {wN}. Matrix EXH gives the same result (M ⊆ O for SN).

                                                                        theorem FrankeBergen2020.table1_as_full :
                                                                        List.map (exhMeaning Parse.none Utterance.as_) allWorlds = [false, false, false, false, true, true, true] List.map (exhMeaning Parse.i Utterance.as_) allWorlds = [false, false, false, false, true, false, false] List.map (exhMeaning Parse.m Utterance.as_) allWorlds = [false, false, false, false, true, true, false]

                                                                        AS: "all drank some" requires every type to satisfy "drank some." EXH_I enriches to "all drank [some but not all]" — only S-types satisfy, so only wS (all S-types) works. Matrix EXH without I negates AA, excluding wA (where "all drank all" holds).

                                                                        Literal meaning equals exhaustified meaning under the empty parse.

                                                                        ⟦SS⟧^M = {wNS}: matrix EXH narrows SS to a single world. This is the paper's key finding (§6): the M reading "uniquely singles out this world state" (p. e86, eq. 22), giving GI its decisive advantage over LI and LU.

                                                                        LI cannot access M-containing parses: none of {lit, I, O, OI} include matrix EXH. This excludes ⟦SS⟧^M from LI's parse space.

                                                                        LU cannot access M-containing parses: neither lit nor OI include matrix EXH. This excludes ⟦SS⟧^M from LU's parse space.

                                                                        theorem FrankeBergen2020.latent_space_hierarchy :
                                                                        Fintype.card Unit = 1 Fintype.card LULex = 2 Fintype.card LIParse = 4 Fintype.card Parse = 8

                                                                        The latent space grows across models: 1 → 2 → 4 → 8.

                                                                        Connection to [PLLF16] #

                                                                        The LU model here uses latent LULex (2 lexica: lit, OI), the same latent-variable architecture as [PLLF16]'s weak/strong "some" lexica. Both implement Bergen et al.'s lexical uncertainty via the pragmatic listener's marginalisation over a latent lexicon — no special LUScenario infrastructure needed. Our LU uses L1 only; the paper adds an S2/L2 layer (eqs. 14a-14b) for production predictions.

                                                                        Connection to [CWS23] #

                                                                        Cremers et al. test 9 model variants, including EXH-LU and RSA-LI, which correspond to our LU and LI listeners (luListener, liListener). Their key finding — grammatical models (EXH-LU, RSA-LI) block anti-exhaustivity regardless of prior bias — is consistent with our LU and LI predictions: both correctly derive exhaustification for SS (lu_ss_prefers_wNS, li_ss_outer_exh), concentrating probability on the exhaustified worlds.

                                                                        Connection to [Fra11] #

                                                                        The matrix EXH in exhMeaning uses exh_MW: conjoin the sub-matrix meaning with the negation of all strictly stronger alternatives' literal meanings. [Fra11] proves that IBR fixed points equal exh_MW for scalar games (Franke2011.r1_eq_exhMW_under_totality). This grounds the matrix position of our GI model in game-theoretic equilibrium semantics.

                                                                        Connection to [Fox07] #

                                                                        The exhaustification implementation uses compositional enrichment at inner/outer quantifier positions (scale-mate substitution on {some, all}) and MW-style sentential alternative negation at matrix position. The models differ only in which EXH positions are available to the speaker/listener, demonstrating that the key theoretical question is not HOW to exhaustify but WHERE EXH can be inserted and WHO controls the insertion (grammar vs. speaker vs. listener).

                                                                        Why GI wins (§6) #

                                                                        The decisive advantage of GI over LI and LU is the M parse: m_ss_singleton proves ⟦SS⟧^M = {wNS}, and li_excludes_matrix / lu_excludes_matrix prove that M-containing parses are structurally unavailable to the smaller models. Only GI can access the reading that uniquely identifies wNS, explaining its superior production predictions for SS (Figure 5, Figure 7c).