Documentation

Linglib.Studies.CremersWilcoxSpector2023

[CWS23]: Exhaustivity and Anti-Exhaustivity in RSA #

"Exhaustivity and Anti-Exhaustivity in the RSA Framework: Testing the Effect of Prior Beliefs." Cognitive Science 47(5), e13286.

The Symmetry Problem #

In baseline RSA, hearing "A" can increase belief in w_ab (where both A and B are true) when priors are biased toward w_ab. This "anti-exhaustive" behavior contradicts human interpretation — humans always exhaust "A" to mean "A and not B."

Key Result #

Models with grammatical exhaustification (EXH-LU, RSA-LI) block anti-exhaustivity regardless of prior bias. The EXH parse makes A false in w_ab, so S1 never uses A to convey w_ab under that parse. The prior bias is overridden by the structural asymmetry in meaning.

The paper's experimental data (comprehension task) found no evidence of anti-exhaustivity: listeners consistently infer "A and not B" from "A", regardless of prior bias. This supports grammatical models (EXH-LU, RSA-LI, svRSA) over baseline RSA and wRSA.

Domain #

PMF stack #

Each model is a latent-variable RSA model on mathlib PMF, with the latent type the model's distinctive mechanism (parse / QUD / interpretation). For a fixed config with latent meaning meaning : Latent → Utterance → World → ℝ≥0∞:

The L1 anti-exhaustivity test is L1(.A) .w_ab > L1(.A) .w_a, which under a uniform world prior reduces (via PMF.posterior_lt_iff_kernel_lt_of_uniform) to marginalSpeaker .w_ab .A > marginalSpeaker .w_a .A — exactly the marginalised speaker comparison T(w) = Σ_l S1(.A | w, l) of the paper (Appendix A.1).

Prior Placement #

The paper's L0 includes the prior (eq. 1): L0(w|u) ∝ P(w) · ⟦u⟧(w). The paper also has P(w) at L1 (eq. 3): L1(w|u) ∝ P(w) · S1(u|w). So P(w) enters twice. For the anti-exhaustivity classification at equal costs (Appendix A.1, eq. A.4) the L1 prior is a constant factor that cancels in the comparison, so we use a uniform world prior at L1 and bake P(w) into meaning for the prior-in-L0 models (baseline, EXH-LU, FREE-LU). For svRSA the prior does NOT enter meaning; under the coarse QUD all A-true worlds collapse into one cell, neutralising the prior's effect on S1 (Appendix A.3), which we encode by unit meaning weights.

Anti-Exhaustivity Definition #

The paper's definition (Eq. 6b, equal costs): L1(w_ab|A) > P(w_ab), equivalently T(w_ab) > T(w_a) (Appendix A.1, eq. A.4), with T(w) = Σ_l S1(A|w,l). With the uniform world prior this reduces to marginalSpeaker .w_ab .A > marginalSpeaker .w_a .A.

Utterance Costs #

The paper includes costs c(A) = 0, c(A∧B) = c(A∧¬B) = c (eq. 2): S1(u|w) ∝ L0(w|u)^α · exp(-λc(u)). With equal costs for A∧B and A∧¬B, the cost terms cancel in the anti-exhaustivity condition (eq. 6b). We set all costs to 0 (costFactor = fun _ => 1); the analytic condition in antiExhaustivityCondition handles the general case.

Model Classification #

The paper's 9 models fall into two groups by anti-exhaustivity behavior:

#ModelMechanismAnti-exhaustive?Listener
1Baseline RSAYesbaselineL1
2wRSAPrior-in-L0 via backgroundYeswRSAL1
3BwRSABayesian wRSAYes (= wRSA at L1)wRSAL1
4svRSA1QUD blocks at S1NosvRSAL1
5svRSA2QUD blocks at S1NosvRSAL1
6FREE-LUFree parse choiceYesfreeLUL1
7EXH-LUEXH blocks at L0NoexhLUL1
8RSA-LI1EXH blocks at L0No (= EXH-LU at L1)rsaLIL1
9RSA-LI2EXH blocks at L0No (= EXH-LU at L1)rsaLIL1

RSA-LI (Models 8–9) is [FB20b]'s Lexical Intentions model; at L1 with uniform P(i) and equal costs it equals EXH-LU (Table 1). wRSA and BwRSA are identical at L1 (BwRSA adds a Bayesian S2 layer). svRSA uses no prior in L0 meaning — QUD projection neutralizes it (Appendix A.3), giving categorical blocking.

wRSA is a joint world–background listener #

wRSA's latent prior is world-dependent: P(w|b)·P(b) ([DTG15]) puts the 3:1 bias on the default_ background and a uniform world prior on wonky (§4.1). Rather than a marginalised per-world speaker, the listener is jointly uncertain about (w, b): its world belief is the World-marginal of the (World × Background) posterior, built with RSA.jointPrior + RSA.jointListener (the world-dependent-latent-prior siblings of marginalizeKernel/PMF.posterior). The anti-exhaustivity test reduces — via RSA.jointListener_lt_iff_sum_score_lt, the marginal normaliser cancelling — to the latent-summed score comparison Σ_b μ(w_ab,b)·S1(.A|w_ab,b) > Σ_b μ(w_a,b)·S1(.A|w_a,b). The per-background speaker reuses the file's proven closed forms: default_ is baselineS1 (biased prior in L0) and wonky is svRSAS1 .coarse (unit meaning). The other four configs have world-independent uniform latent priors and use the marginalizeKernel stack.

Connection to Other Formalizations #

Domain types #

Two-world model for exhaustivity.

  • w_a: A true, B false (A ∧ ¬B)
  • w_ab: A and B both true (A ∧ B)

No w_b or w_none because we condition on A being true. The question is whether B is also true.

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.

      Three utterances in the minimal exhaustivity domain.

      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.

          Literal semantics #

          Exhaustification (Innocent Exclusion) #

          Alternatives for each utterance: A has scale-mate A∧B.

          Equations
          Instances For

            Exhaustified meaning derived via Innocent Exclusion. IE negates A∧B (the non-entailed stronger alternative to A), giving EXH(A) = A ∧ ¬(A∧B) = A ∧ ¬B.

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

              EXH(A) is only true in w_a — derived from IE, not stipulated.

              EXH(A∧B) unchanged: A∧B has no stronger alternative.

              EXH(A∧¬B) unchanged: A∧¬B has no stronger alternative.

              Parse-dependent meaning #

              Parse = whether EXH is applied.

              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.

                  Prior weight and cost #

                  Prior weight for each world: 1:3 bias toward w_ab.

                  Baked into meaning for prior-in-L0 models so that L0(w|u) ∝ P(w) · ⟦u⟧(w), matching the paper's eq. (1). This makes S1 asymmetric for utterances true in both worlds, which is the source of anti-exhaustivity.

                  Equations
                  Instances For

                    Utterance cost (Appendix A.1, eq. A.1). The paper uses c(A) = 0 and positive c for A∧B and A∧¬B, but with equal costs the classification is prior-determined (eq. 6b). We set all costs to 0; the general case is handled analytically by antiExhaustivityCondition.

                    Equations
                    Instances For

                      Anti-exhaustivity condition (Eq. 6b) #

                      def CremersWilcoxSpector2023.antiExhaustivityCondition (log_p_wab log_p_wa c_AnotB c_AB : ) :
                      Bool

                      The paper's analytic condition for when baseline RSA is anti-exhaustive.

                      Full condition (Eq. 6b): log P(w_ab) - log P(w_a) > c(A∧¬B) - c(A∧B). When the cost of the exhaustive paraphrase A∧¬B exceeds the conjunctive alternative A∧B, the speaker's dispreference for the paraphrase makes anti-exhaustivity easier to trigger. With equal costs, any prior bias toward w_ab suffices.

                      Equations
                      Instances For
                        theorem CremersWilcoxSpector2023.equal_costs_reduces_to_prior (log_wab log_wa c : ) :
                        (antiExhaustivityCondition log_wab log_wa c c = true) = (log_wab > log_wa)

                        Equal costs: anti-exhaustivity iff P(w_ab) > P(w_a) (i.e., log ratio > 0).

                        Uniform prior with equal costs: no anti-exhaustivity.

                        Biased prior with equal costs: anti-exhaustivity triggered.

                        Asymmetric costs can block anti-exhaustivity even with biased prior: if c(A∧¬B) is much more expensive than c(A∧B), the cost gap c(A∧¬B) - c(A∧B) exceeds the log prior ratio.

                        Shared sum unfolders and α = 2 score reduction #

                        The PMF stack below reduces partition functions over CWSWorld / CWSUtterance to concrete two/three-term sums via the rfl unfolders, and the speaker score (L0 u w)^(2:ℝ) · 1 to a nat power (L0 u w)^(2:ℕ) so it lands as ofReal (r^2).

                        theorem CremersWilcoxSpector2023.CWSWorld_sum_univ {β : Type u_1} [AddCommMonoid β] (f : CWSWorldβ) :
                        i : CWSWorld, f i = f CWSWorld.w_a + (f CWSWorld.w_ab + 0)

                        Sum-over-CWSWorld unfolder, proved by rfl.

                        theorem CremersWilcoxSpector2023.CWSUtterance_sum_univ {β : Type u_1} [AddCommMonoid β] (f : CWSUtteranceβ) :

                        Sum-over-CWSUtterance unfolder, proved by rfl.

                        theorem CremersWilcoxSpector2023.rpow_two_mul_one (x : ENNReal) :
                        x ^ 2 * 1 = x ^ 2

                        α = 2 score reduction: the speaker score (L0 u w)^(2:ℝ) · 1 is the square (L0 u w)^(2:ℕ). The (2:ℝ) rpow becomes a (2:ℕ) power via ENNReal.rpow_natCast; this is the α≠1 analogue of Potts' rpow_one collapse. local pmf_eval_simps (file-local, not substrate-global) so partition functions reduce squared L0 values.

                        theorem CremersWilcoxSpector2023.sq_ofReal (r : ) (hr : 0 r) :
                        ENNReal.ofReal r ^ 2 = ENNReal.ofReal (r ^ 2)

                        ofReal r squared (α = 2): (ofReal r)^(2:ℕ) = ofReal (r^2) for 0 ≤ r. Carries the squared L0 closed forms into the Z / marginalSpeaker arithmetic.

                        Baseline RSA (Model 1) #

                        Prior-in-L0, no latent (Unit): meaning(u,w) = P(w) · ⟦u⟧(w), so L0(w_a|A) = 1/4, L0(w_ab|A) = 3/4. With α = 2 the speaker is asymmetric: S1(A|w_ab) = 9/25 > 1/17 = S1(A|w_a). The speaker preferentially uses the cheap utterance A when w_ab is true (L0 already favours w_ab given A), driving genuine anti-exhaustivity (Eq. 6b, Fig. 1). With no latent, the marginal speaker is S1 itself.

                        Baseline meaning: P(w)·⟦u⟧(w) lifted to ℝ≥0∞.

                        Equations
                        Instances For
                          theorem CremersWilcoxSpector2023.baselineMeaning_apply (u : CWSUtterance) (w : CWSWorld) :
                          baselineMeaning u w = if literalTruth w u = true then ENNReal.ofReal (priorWeight w) else 0

                          Baseline literal listener: L0(w|u) ∝ P(w)·⟦u⟧(w) (eq. 1).

                          Equations
                          Instances For
                            noncomputable def CremersWilcoxSpector2023.baselineZ (w : CWSWorld) :
                            ENNReal

                            Baseline speaker normaliser at world w.

                            Equations
                            Instances For

                              Baseline speaker (α = 2, no cost). With Unit latent this is the marginal speaker the listener inverts.

                              Equations
                              Instances For
                                theorem CremersWilcoxSpector2023.baselineS1_apply (w : CWSWorld) (u : CWSUtterance) :
                                (baselineS1 w) u = (baselineL0 u) w ^ 2 * 1 * (∑' (u' : CWSUtterance), (baselineL0 u') w ^ 2 * 1)⁻¹
                                noncomputable def CremersWilcoxSpector2023.baselineL1 (u : CWSUtterance) (h : PMF.marginal baselineS1 (PMF.uniformOfFintype CWSWorld) u 0) :

                                Baseline pragmatic listener: Bayesian inversion of baselineS1 against the uniform world prior.

                                Equations
                                Instances For

                                  EXH-LU RSA (Models 7–9) #

                                  Parse is a latent variable; meaning under each parse bakes in the prior, meaning(p,u,w) = P(w)·⟦u⟧_p(w). Under the exh parse EXH(A) is false at w_ab, so L0(·|A, exh) puts all mass on w_a and S1(A|w_ab, exh) = 0. The exh-parse blocking (S1(A|w_a, exh) = 1/2) outweighs the literal parse's prior amplification, giving T(w_a) = 19/34 > 9/25 = T(w_ab) despite the 3:1 bias. With a uniform parse prior the marginal speaker halves these, so the listener inverts ms(w_a) = 19/68 > 9/50 = ms(w_ab).

                                  RSA-LI (Models 8–9) is [FB20b]'s Lexical Intentions model; at L1 with uniform P(i) and equal costs it equals EXH-LU (rsaLI* := exhLU*).

                                  Parse-dependent meaning lifted to ℝ≥0∞ (prior baked in).

                                  Equations
                                  Instances For
                                    theorem CremersWilcoxSpector2023.parseMeaningE_apply (p : CWSParse) (u : CWSUtterance) (w : CWSWorld) :
                                    parseMeaningE p u w = if parseMeaning p w u = true then ENNReal.ofReal (priorWeight w) else 0

                                    EXH-LU per-parse literal listener.

                                    Equations
                                    Instances For
                                      theorem CremersWilcoxSpector2023.CWSParse_sum_univ {β : Type u_1} [AddCommMonoid β] (f : CWSParseβ) :
                                      i : CWSParse, f i = f CWSParse.literal + (f CWSParse.exh + 0)

                                      Sum-over-CWSParse unfolder, proved by rfl.

                                      theorem CremersWilcoxSpector2023.exhLUZ_ne_top (p : CWSParse) (w : CWSWorld) :
                                      ∑' (u : CWSUtterance), (exhLUL0 p u) w ^ 2 * 1
                                      theorem CremersWilcoxSpector2023.exhLUZ_ne_zero (p : CWSParse) (w : CWSWorld) :
                                      ∑' (u : CWSUtterance), (exhLUL0 p u) w ^ 2 * 1 0

                                      EXH-LU per-parse speaker (α = 2, no cost).

                                      Equations
                                      Instances For
                                        theorem CremersWilcoxSpector2023.exhLUS1_apply (p : CWSParse) (w : CWSWorld) (u : CWSUtterance) :
                                        (exhLUS1 p w) u = (exhLUL0 p u) w ^ 2 * 1 * (∑' (u' : CWSUtterance), (exhLUL0 p u') w ^ 2 * 1)⁻¹

                                        EXH-LU marginal speaker over a uniform parse prior.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          theorem CremersWilcoxSpector2023.exhLUMarginalSpeaker_apply (w : CWSWorld) (u : CWSUtterance) :
                                          (exhLUMarginalSpeaker w) u = ENNReal.ofReal (1 / 2) * (exhLUS1 CWSParse.literal w) u + (ENNReal.ofReal (1 / 2) * (exhLUS1 CWSParse.exh w) u + 0)
                                          noncomputable def CremersWilcoxSpector2023.exhLUL1 (u : CWSUtterance) (h : PMF.marginal exhLUMarginalSpeaker (PMF.uniformOfFintype CWSWorld) u 0) :

                                          EXH-LU pragmatic listener (also RSA-LI at L1).

                                          Equations
                                          Instances For
                                            @[reducible, inline]
                                            noncomputable abbrev CremersWilcoxSpector2023.rsaLIL1 (u : CWSUtterance) (h : PMF.marginal exhLUMarginalSpeaker (PMF.uniformOfFintype CWSWorld) u 0) :

                                            RSA-LI (Models 8–9): at L1 with uniform P(i) and equal costs, identical to EXH-LU (Table 1 of [FB20b]).

                                            Equations
                                            Instances For

                                              svRSA (Models 4–5) — [spector-2017] supervaluationist RSA #

                                              QUD is a latent variable, and the prior does not enter meaning (unit weights). Under the coarse QUD Q_A (all A-true worlds in one cell), L0 is uniform 1/2 over both worlds, so S1(A|w, coarse) = 1/5 is world-independent — the prior's effect on S1 is neutralised (Appendix A.3). Under the fine QUD Q_fine, exh makes A false at w_ab, so S1(A|w_ab, fine) = 0 while S1(A|w_a, fine) = 1/2. With a uniform QUD prior the marginal speaker is ms(w_a) = 7/20 > 1/10 = ms(w_ab): categorical blocking (ms(w_a) = ms(w_ab) + (1/2)·S1(A|w_a, fine) > ms(w_ab)), matching Appendix A.3. The QUD values correspond to Discourse.QUD.trivial (coarse) and Discourse.QUD.exact (fine). svRSA1 and svRSA2 differ only at S2; both block at L1.

                                              QUD for svRSA. coarse = Q_A; fine = Q_fine.

                                              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.

                                                  svRSA meaning: unit weights (no prior). Coarse uses literal truth, fine uses exhaustified truth.

                                                  Equations
                                                  Instances For
                                                    theorem CremersWilcoxSpector2023.CWSQUD_sum_univ {β : Type u_1} [AddCommMonoid β] (f : CWSQUDβ) :
                                                    i : CWSQUD, f i = f CWSQUD.coarse + (f CWSQUD.fine + 0)

                                                    Sum-over-CWSQUD unfolder, proved by rfl.

                                                    theorem CremersWilcoxSpector2023.svRSAZ_eq_sum (q : CWSQUD) (w : CWSWorld) :
                                                    svRSAZ q w = ∑' (u : CWSUtterance), (svRSAL0 q u) w ^ 2
                                                    theorem CremersWilcoxSpector2023.svRSAZ_ne_top (q : CWSQUD) (w : CWSWorld) :
                                                    ∑' (u : CWSUtterance), (svRSAL0 q u) w ^ 2 * 1
                                                    theorem CremersWilcoxSpector2023.svRSAZ_ne_zero (q : CWSQUD) (w : CWSWorld) :
                                                    ∑' (u : CWSUtterance), (svRSAL0 q u) w ^ 2 * 1 0
                                                    theorem CremersWilcoxSpector2023.svRSAS1_apply (q : CWSQUD) (w : CWSWorld) (u : CWSUtterance) :
                                                    (svRSAS1 q w) u = (svRSAL0 q u) w ^ 2 * 1 * (∑' (u' : CWSUtterance), (svRSAL0 q u') w ^ 2 * 1)⁻¹
                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For
                                                      theorem CremersWilcoxSpector2023.svRSAMarginalSpeaker_apply (w : CWSWorld) (u : CWSUtterance) :
                                                      (svRSAMarginalSpeaker w) u = ENNReal.ofReal (1 / 2) * (svRSAS1 CWSQUD.coarse w) u + (ENNReal.ofReal (1 / 2) * (svRSAS1 CWSQUD.fine w) u + 0)
                                                      noncomputable def CremersWilcoxSpector2023.svRSAL1 (u : CWSUtterance) (h : PMF.marginal svRSAMarginalSpeaker (PMF.uniformOfFintype CWSWorld) u 0) :

                                                      svRSA pragmatic listener.

                                                      Equations
                                                      Instances For

                                                        FREE-LU (Model 6) — [BLG16] #

                                                        Three interpretations as latent variables (literal / exh / antiExh), each with the prior baked into meaning. The anti-exhaustive interpretation makes A mean A∧B (true only at w_ab). With prior-in-L0, the literal parse is asymmetric (S1(A|w_ab, lit) = 9/25 > 1/17 = S1(A|w_a, lit)), and the anti-exh parse contributes S1(A|w_ab, antiExh) = 1/2 at w_ab (0 at w_a). So T(w_ab) = 9/25 + 0 + 1/2 = 43/50 > 19/34 = 1/17 + 1/2 + 0 = T(w_a). With the uniform interpretation prior the marginal speaker is ms(w_ab) = 43/150 > 19/102 = ms(w_a): genuine anti-exhaustivity, matching the paper.

                                                        Interpretation for FREE-LU. literal, exh (A∧¬B), antiExh (A∧B).

                                                        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.

                                                            FREE-LU meaning lifted to ℝ≥0∞ (prior baked in).

                                                            Equations
                                                            Instances For
                                                              theorem CremersWilcoxSpector2023.interpMeaningE_apply (i : CWSInterpretation) (u : CWSUtterance) (w : CWSWorld) :
                                                              interpMeaningE i u w = if interpMeaning i w u = true then ENNReal.ofReal (priorWeight w) else 0

                                                              Sum-over-CWSInterpretation unfolder, proved by rfl.

                                                              theorem CremersWilcoxSpector2023.freeLUS1_apply (i : CWSInterpretation) (w : CWSWorld) (u : CWSUtterance) :
                                                              (freeLUS1 i w) u = (freeLUL0 i u) w ^ 2 * 1 * (∑' (u' : CWSUtterance), (freeLUL0 i u') w ^ 2 * 1)⁻¹

                                                              exh interpretation: A false at w_a (S1 = 0).

                                                              Equations
                                                              • One or more equations did not get rendered due to their size.
                                                              Instances For
                                                                theorem CremersWilcoxSpector2023.freeLUMarginalSpeaker_apply (w : CWSWorld) (u : CWSUtterance) :
                                                                (freeLUMarginalSpeaker w) u = ENNReal.ofReal (1 / 3) * (freeLUS1 CWSInterpretation.literal w) u + (ENNReal.ofReal (1 / 3) * (freeLUS1 CWSInterpretation.exh w) u + (ENNReal.ofReal (1 / 3) * (freeLUS1 CWSInterpretation.antiExh w) u + 0))
                                                                noncomputable def CremersWilcoxSpector2023.freeLUL1 (u : CWSUtterance) (h : PMF.marginal freeLUMarginalSpeaker (PMF.uniformOfFintype CWSWorld) u 0) :

                                                                FREE-LU pragmatic listener.

                                                                Equations
                                                                Instances For

                                                                  wRSA (Models 2–3) — [DTG15] joint world–background listener #

                                                                  wRSA's distinctive mechanism is a world-dependent latent prior P(w|b)·P(b): the background b is wonky (a uniform world prior) or default_ (the 3:1 bias). The listener is jointly uncertain about (w, b), so the model is a clean RSA.jointListener over the joint prior RSA.jointPrior, with the world belief read off as the W-marginal of the (World × Background) posterior — no bundled-config encoding needed. The per-background speaker reuses the already-proven closed forms: under default_ the biased prior is baked into L0 (eq. 1 of §4.1), so its speaker is baselineS1; under wonky it uses uniform-prior literal meaning, the plain literal RSA speaker — which coincides by construction with svRSAS1 .coarse (whose coarse QUD is the trivial partition), reused here to avoid duplicating the closed forms rather than as a dependence on svRSA.

                                                                  The anti-exhaustivity test wRSAL1(.A) w_ab > wRSAL1(.A) w_a reduces (via RSA.jointListener_lt_iff_sum_score_lt, the marginal normaliser cancelling) to the latent-summed score comparison Σ_b μ(w_ab,b)·S1(.A|w_ab,b) > Σ_b μ(w_a,b)·S1(.A|w_a,b). The prediction is anti-exhaustive (w_ab > w_a), preserving the model's classification: even averaging in the wonky (uniform) background, the biased default_ background amplifies S1 toward w_ab.

                                                                  Background assumption for wRSA: wonky (uniform prior over worlds) vs default_ (prior follows the bias).

                                                                  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.

                                                                      World prior conditioned on the background P(w|b). Under default_, w_ab gets 3× the weight of w_a (P(w_a)=1/4, P(w_ab)=3/4 — the 1:3 bias); under wonky, both worlds are equally likely (1/2, 1/2).

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

                                                                        Background prior P(b): uniform over CWSBackground.

                                                                        Equations
                                                                        Instances For
                                                                          theorem CremersWilcoxSpector2023.bgPrior_apply (b : CWSBackground) :
                                                                          bgPrior b = ENNReal.ofReal (1 / 2)

                                                                          Per-background speaker, reusing this file's proven closed forms by shared construction: default_ bakes the biased prior into L0, so it is baselineS1; wonky uses uniform-prior literal meaning, so it is the plain literal RSA speaker (= svRSAS1 .coarse, whose coarse QUD is the trivial partition).

                                                                          Equations
                                                                          Instances For

                                                                            wRSA pragmatic listener: the world-marginal of the joint (World × Background) posterior (BwRSA is identical at L1).

                                                                            Equations
                                                                            Instances For

                                                                              Predictions #

                                                                              Each prediction reduces, under the uniform world prior, to a marginalSpeaker comparison via PMF.posterior_lt_iff_kernel_lt_of_uniform, then to a rational comparison via ENNReal.ofReal_lt_ofReal_iff.

                                                                              Baseline RSA is genuinely anti-exhaustive: L1(.A) w_ab > L1(.A) w_a.

                                                                              With prior-in-L0, S1 is asymmetric (S1(A|w_ab) = 9/25 > 1/17 = S1(A|w_a)) because L0(w_ab|A) = 3/4 > 1/4 = L0(w_a|A). The speaker preferentially uses A when w_ab is true, since L0 already favours w_ab given A. This is the paper's central problematic prediction (Eq. 6b, Fig. 1).

                                                                              EXH-LU blocks anti-exhaustivity: even with prior-in-L0 and 3:1 bias, L1(.A) w_a > L1(.A) w_ab. The exh parse contributes S1(A|w_a, exh) = 1/2 but S1(A|w_ab, exh) = 0, outweighing the literal parse's prior amplification: ms(w_a) = 19/68 > 9/50 = ms(w_ab).

                                                                              EXH(A) is false in w_ab — the structural basis for blocking.

                                                                              svRSA blocks anti-exhaustivity categorically (Appendix A.3): under the coarse QUD S1(A|w, coarse) = 1/5 for both worlds, and under the fine QUD S1(A|w_ab, fine) = 0 while S1(A|w_a, fine) = 1/2. So ms(w_a) = 7/20 > 1/10 = ms(w_ab).

                                                                              FREE-LU is genuinely anti-exhaustive: with prior-in-L0 the literal parse's S1 asymmetry makes the anti-exh interpretation dominant at w_ab. ms(w_ab) = 43/150 > 19/102 = ms(w_a).

                                                                              wRSA is anti-exhaustive: the default_ background bakes the biased prior into L0, making S1 asymmetric; even averaging in the wonky (uniform) background, the biased background dominates. Reduces to the latent-summed score comparison Σ_b μ(w_ab,b)·S1(.A|w_ab,b) > Σ_b μ(w_a,b)·S1(.A|w_a,b), i.e. 1/20 + 27/200 > 1/20 + 1/136.

                                                                              Classification #

                                                                              The paper's central result: the 9 RSA models fall into two groups. The anti-exhaustive group (baseline, wRSA/BwRSA, FREE-LU) lets the prior bias amplify through S1, predicting listeners infer w_ab from "A" — contradicting the experimental data. The exhaustive group (EXH-LU, RSA-LI1/2, svRSA1/2) blocks anti-exhaustivity via grammatical exhaustification or QUD gating, matching the data.