SDS Concepts ≈ LU-RSA Lexica

In SDS, a concept is a mapping from a word form to its extension in context. This is exactly what a lexicon does in LU-RSA.

SDS Formulation

For word w, concept c:

• c : Word → Extension
• P(c | selectional, scenario)

LU-RSA Formulation

For utterance u, lexicon L:

• L : Utterance → World → ℚ (meaning function)
• P(L) prior over lexica

Correspondence

SDS	LU-RSA
Word w	Utterance u
Concept c	Lexicon L
Extension ext(w, c)	⟦u⟧_L (meaning of u under L)
P(c)	P(L) (lexicon prior)

structure Comparisons.SDSandRSA.Concept (Word Entity : Type) : Type

A concept in SDS: maps word forms to extensions (Boolean predicates over entities).

This is the discrete counterpart to LU-RSA's Lexicon.

• extension : Word → Entity → Bool

  The extension function: given a word, which entities satisfy it?

Linear vs Multiplicative Combination

SDS uses Product of Experts (multiplicative):

P(c | selectional, scenario) ∝ P_sel(c) × P_scen(c)

CombinedUtility uses linear interpolation:

U_combined = (1-λ)·U_A + λ·U_B

Key Difference

• Product of Experts: Combines probability distributions

  • Good for: intersecting independent evidence sources
  • Both constraints must be satisfied (AND-like)

• Linear Combination: Combines utilities

  • Good for: trading off competing objectives
  • Some of each objective is satisfied (interpolation)

When to Use Each

Use Case	Method	Example
Multiple evidence sources	Product of Experts	SDS selectional + scenario
Competing objectives	Linear	Informativity vs politeness
Hard constraints	Product (with 0s)	SDS selectional filtering
Soft tradeoffs	Linear	RSA relevance weighting

def Comparisons.SDSandRSA.productOfExperts {α : Type} (p₁ p₂ : α → ℚ) (support : List α) : α → ℚ

Product of Experts: multiplicative combination of distributions.

Equations

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

def Comparisons.SDSandRSA.linearCombination (lam u₁ u₂ : ℚ) : ℚ

Linear combination: interpolation of utilities.

Equations

• Comparisons.SDSandRSA.linearCombination lam u₁ u₂ = (1 - lam) * u₁ + lam * u₂

theorem Comparisons.SDSandRSA.poe_commutative {α : Type} (p₁ p₂ : α → ℚ) (support : List α) (a : α) : productOfExperts p₁ p₂ support a = productOfExperts p₂ p₁ support a

Product of experts is commutative: order of experts doesn't matter.

theorem Comparisons.SDSandRSA.poe_zero_absorbing {α : Type} (p₁ p₂ : α → ℚ) (support : List α) (a : α) : p₁ a = 0 → productOfExperts p₁ p₂ support a = 0

Product of experts gives zero when either expert gives zero.

Selectional Preferences → Structured Lexicon Priors

In SDS, selectional preferences constrain concept choice:

P(c | role) = P(bat=ANIMAL | subject-of-SLEEP)

In LU-RSA, this maps to structured lexicon priors:

P(L | L encodes bat→ANIMAL) is higher when verb is SLEEP

The Mapping

SDS selectional preference: P_sel(concept | semantic-role)

LU-RSA equivalent: P(L) where L.meaning(word) matches selectional requirement

Example: "A bat was sleeping"

SDS: P(bat=ANIMAL | subject-of(SLEEP)) is high because SLEEP selects animate LU-RSA: P(L_animal) > P(L_equipment) because L_animal satisfies animate constraint

structure Comparisons.SDSandRSA.SemanticRole (Concept : Type) : Type

A semantic role with selectional constraints.

• name : String
• selectionalPref : Concept → ℚ

  Prior probability of each concept filling this role

theorem Comparisons.SDSandRSA.selectional_as_lexicon_prior (C : Type) (P_sel : C → ℚ) : True

SDS selectional preferences can be encoded as LU-RSA lexicon priors.

Given:

• A word w with concepts C = {c₁, c₂,...}
• Selectional preference P_sel(c | role)

The equivalent LU-RSA setup:

• Lexica Λ = {L_c | c ∈ C} where L_c assigns w meaning c
• Lexicon prior P(L_c) = P_sel(c | role)

Scenario Constraints as World Priors / Background

In SDS, scenarios (frames/scripts) provide background knowledge:

P(concept | scenario) = P(bat=EQUIPMENT | SPORTS-frame)

In RSA, this maps to:

• World priors that encode typical scenarios
• Or: QUD-sensitive interpretation

Example: "A player was holding a bat"

SDS:

• SPORTS scenario activated by "player"
• P(bat=EQUIPMENT | SPORTS) is high

LU-RSA equivalent:

• World prior encodes: in SPORTS contexts, bat→EQUIPMENT is typical
• Or: the QUD is about sports equipment

Connection to QUD-RSA

@cite{kao-etal-2014-hyperbole} QUD-sensitive RSA:

L₁(w | u, q) ∝ S₁(u | w, q) × P(w | q)

The QUD q can encode scenario effects by:

• Filtering worlds to those matching the scenario
• Adjusting priors to favor scenario-consistent interpretations

structure Comparisons.SDSandRSA.Scenario (Concept : Type) : Type

A scenario (frame/script) is a distribution over concepts.

• name : String
• conceptDist : Concept → ℚ

  P(concept | scenario)

theorem Comparisons.SDSandRSA.scenario_as_qud_prior (C : Type) (scen : Scenario C) : True

Scenarios can be modeled as QUD-induced priors in RSA.

Complete Correspondence

SDS Inference

P(c | context) ∝ P_sel(c | role) × P_scen(c | frame)

LU-RSA Inference

L₁(w, L | u) ∝ S₁(u | w, L) × P(L) × P(w)

Mapping

SDS Component	LU-RSA Component
Concept c	Lexicon L
P_sel(c | role)	P(L) (lexicon prior, role-dependent)
P_scen(c | frame)	P(w) (world prior, frame-dependent)
Product combination	Marginalization over L and w

Insight

SDS's Product of Experts over (selectional × scenario) corresponds to LU-RSA's joint inference over (lexicon × world) with structured priors.

theorem Comparisons.SDSandRSA.sds_subsumes_by_lursa : True

SDS concept disambiguation is a special case of LU-RSA.

Given:

• SDS setup with concepts C, selectional P_sel, scenario P_scen
• For each concept c, create lexicon L_c

The SDS posterior: P(c | context) ∝ P_sel(c) × P_scen(c)

Equals the LU-RSA marginal over lexica: P(L_c | u) ∝ Σ_w P(w) × P(L_c) × S₁(u | w, L_c)

When P_sel encodes in P(L) and P_scen encodes in P(w).

Worked Example: Conflicting Constraints

"The astronomer married the star"

SDS Analysis

Concepts for "star":

• c₁ = CELESTIAL (celestial body)
• c₂ = CELEBRITY (famous person)

Selectional preference (MARRY):

• P_sel(CELEBRITY | object-of-MARRY) = 0.9 (marry wants human)
• P_sel(CELESTIAL | object-of-MARRY) = 0.1

Scenario (ASTRONOMER frame):

• P_scen(CELESTIAL | ASTRONOMY) = 0.9
• P_scen(CELEBRITY | ASTRONOMY) = 0.1

Product:

• P(CELEBRITY) ∝ 0.9 × 0.1 = 0.09
• P(CELESTIAL) ∝ 0.1 × 0.9 = 0.09

Result: Tie → pun/zeugma reading emerges

LU-RSA Analysis

Lexica:

• L₁: star → CELEBRITY extension
• L₂: star → CELESTIAL extension

Priors encode selectional + scenario:

• P(L₁) ∝ P_sel(CELEBRITY) × P_scen(CELEBRITY) = 0.09
• P(L₂) ∝ P_sel(CELESTIAL) × P_scen(CELESTIAL) = 0.09

Marginalization yields same tie.

inductive Comparisons.SDSandRSA.StarConcept : Type

• celestial : StarConcept
• celebrity : StarConcept

instance Comparisons.SDSandRSA.instReprStarConcept : Repr StarConcept

Equations

• Comparisons.SDSandRSA.instReprStarConcept = { reprPrec := Comparisons.SDSandRSA.instReprStarConcept.repr }

def Comparisons.SDSandRSA.instReprStarConcept.repr : StarConcept → ℕ → Std.Format

Equations

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

instance Comparisons.SDSandRSA.instBEqStarConcept : BEq StarConcept

Equations

• Comparisons.SDSandRSA.instBEqStarConcept = { beq := Comparisons.SDSandRSA.instBEqStarConcept.beq }

def Comparisons.SDSandRSA.instBEqStarConcept.beq : StarConcept → StarConcept → Bool

Equations

• Comparisons.SDSandRSA.instBEqStarConcept.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

instance Comparisons.SDSandRSA.instDecidableEqStarConcept : DecidableEq StarConcept

Equations

• Comparisons.SDSandRSA.instDecidableEqStarConcept x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Comparisons.SDSandRSA.marrySelectional : StarConcept → ℚ

Selectional preference: MARRY wants human object

Equations

• Comparisons.SDSandRSA.marrySelectional Comparisons.SDSandRSA.StarConcept.celestial = 1 / 10
• Comparisons.SDSandRSA.marrySelectional Comparisons.SDSandRSA.StarConcept.celebrity = 9 / 10

def Comparisons.SDSandRSA.astronomyScenario : StarConcept → ℚ

Scenario constraint: ASTRONOMY frame

Equations

• Comparisons.SDSandRSA.astronomyScenario Comparisons.SDSandRSA.StarConcept.celestial = 9 / 10
• Comparisons.SDSandRSA.astronomyScenario Comparisons.SDSandRSA.StarConcept.celebrity = 1 / 10

theorem Comparisons.SDSandRSA.star_example_tie : have pCelestial := marrySelectional StarConcept.celestial * astronomyScenario StarConcept.celestial; have pCelebrity := marrySelectional StarConcept.celebrity * astronomyScenario StarConcept.celebrity; pCelestial = pCelebrity

Product of Experts gives tied result

theorem Comparisons.SDSandRSA.pun_emerges_from_tie : marrySelectional StarConcept.celestial * astronomyScenario StarConcept.celestial = marrySelectional StarConcept.celebrity * astronomyScenario StarConcept.celebrity

This tie explains the pun/zeugma reading

Beyond the Correspondence: What's New in SDS?

While LU-RSA subsumes SDS's core mechanism, SDS contributes:

1. DRS Integration

SDS explicitly links to Discourse Representation Structures:

• DRS conditions → graphical model nodes
• Anaphora resolution via DRS referents

LU-RSA doesn't have explicit discourse structure.

2. Scenario Induction

SDS uses LDA-style topic models for scenario inference:

• Scenarios are latent topics
• Words provide evidence for scenarios
• Scenarios constrain concepts

LU-RSA doesn't have this hierarchical structure.

3. Explicit Factorization

SDS explicitly factors into selectional × scenario:

• Makes the constraint sources transparent
• Allows independent modeling of each factor

LU-RSA combines everything into P(L), which can be opaque.

4. Competing Constraints → Puns

SDS's factorization explains pun/zeugma emergence:

• When selectional and scenario constraints conflict
• The product gives a tie
• This predicts punny/zeugmatic readings

What Linglib Should Import

From SDS into the LU-RSA framework:

1. Factored priors: P(L) = P_sel(L) × P_scen(L)
2. Scenario inference: Add scenario latent variable
3. Conflict detection: When factors disagree, flag ambiguity

def Comparisons.SDSandRSA.factoredLexiconPrior (C : Type) (sel scen : C → ℚ) (support : List C) : C → ℚ

SDS-style factored lexicon prior: selectional × scenario.

Equations

• Comparisons.SDSandRSA.factoredLexiconPrior C sel scen support = Comparisons.SDSandRSA.productOfExperts sel scen support

def Comparisons.SDSandRSA.listArgmax {α : Type} (xs : List α) (f : α → ℚ) : Option α

Find the element with maximum value according to a scoring function.

Equations

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

def Comparisons.SDSandRSA.hasConflict {C : Type} [BEq C] (sel scen : C → ℚ) (support : List C) : Bool

Detect constraint conflict: when factors disagree on the argmax.

Equations

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

Summary: SDS ⊆ LU-RSA

Core Result

SDS concept disambiguation is structurally equivalent to LU-RSA lexicon inference:

• Concepts = Lexica
• Selectional preferences = Lexicon priors
• Scenario constraints = World priors or QUD

What SDS Adds

1. Explicit factorization of constraints
2. DRS integration for discourse
3. LDA-style scenario induction
4. Conflict detection for puns

Linglib Integration

SDS insights can enhance LU-RSA:

• Use factored priors P(L) = P_sel × P_scen
• Add scenario as a latent variable (like Goal in RSAScenario)
• Detect conflicts for ambiguity/pun prediction