Sense Gluing: Pomegranates, properly

A28Prose proofGluing local senses into a coherent global meaning.

Discovery is the privilege of the child: the child who has no fear of being once again wrong, of looking like an idiot, of not being serious, of not doing things like everyone else.
— Alexander Grothendieck, Récoltes et Semailles

This chapter formalizes the gluing of sense assignments across contexts, defining Anchor A28 (Sense Gluing). A28 specifies when local sense assignments for a polysemous term can be composed into a global sense, and what structured artifacts the system must produce when they cannot: sense obstructions, sense forks, or sense arbitrations. The construction instantiates A13 (Sheaf Condition) for sense data, fulfills the transport obligations deferred by A6 (Sense Boundary), and applies the witnessed equivalence machinery of A10 and A16 to lexical synonymy. The corresponding narrative development appears in Volume I, Chapters 5 and 8, where polysemy and the pomegranate example motivate the need for scoped disambiguation.

The Word That Splits

Search "pomegranate" in the wrong system and you get paint chips, recipes, and a rug. All relevant. None substitutable.

The paint chip is a color swatch: deep red, between crimson and burgundy. The recipe calls for the fruit: spherical, leathery-skinned, ruby arils. The rug features the motif: a stylized image that appears in Persian textiles and Armenian manuscripts. Three objects, three domains, one word.

This is not mere ambiguity but a gluing failure. The system retrieved items from multiple contexts, each with its own sense of "pomegranate," and conflated them silently. No witness. No scope. No resolution path.

A coherent system returns something different:

Example(What the System Should Return)

Query: "pomegranate"
Result: SenseFork

SenseFork = {
  term: "pomegranate",
  scoped_senses: [
    { sense: fruit, scope: grocery, query: "pomegranate@grocery", 
      examples: ["Organic pomegranate 4-pack", "Pomegranate juice 32oz"] },
    { sense: color, scope: paint, query: "pomegranate@paint",
      examples: ["Pomegranate #8B0000 interior satin"] },
    { sense: motif, scope: textile, query: "pomegranate@textile",
      examples: ["Persian pomegranate silk scarf", "Armenian tapestry"] }
  ],
  message: "3 senses found. Specify scope to proceed.",
  fork_witness: ref(FW-2847)
}

The user sees options, not conflated results. The system produces a checkable result, not a guess.

By default, cross-scope queries return forks; execution requires the user (or a policy) to pick a scope. A system may offer soft defaults (rank by most-likely scope), hard requirements (refuse to proceed without selection), or separated result panes (still a fork, but displayed). The contract is explicit: unscoped queries over polysemous terms produce structured choices, not merged rankings.

Interlude I-A introduced A6 (Sense Boundary) to name the structure: a context-indexed equivalence that partitions uses into sense classes. We said that sense boundaries exist, must persist, and are scoped to contexts. We deferred the hard question: what happens when contexts merge and their sense assignments disagree?

Now we answer. Parts II and III built the machinery: witnessed equivalence (A10), transport certificates (A16), the sheaf condition (A13). Chapter 26 applies that machinery to sense. The answer is A28: Sense Gluing.

Disambiguation as Gluing

Traditional word sense disambiguation(Navigli 2009) treats sense selection as a classification problem. Given a word in context, output a label: fruit, color, or motif. Train a classifier on examples. At inference time, predict.

This framing ignores what matters:

What happens when two contexts merge and their classifiers disagree?
When does a sense assignment transfer to a new context?
How do you record that two contexts assigned different senses to the same referent?

The answer is not "better classifiers." The answer is recognizing that disambiguation is a gluing problem. Local sense choices must agree on shared referents, or the system must maintain explicit forks.

The output of disambiguation is not a label. It is one of:

A global sense (if local assignments agree on overlaps)
A sense obstruction (if they disagree, with resolution options)
A sense fork (if both senses are maintained with scope annotations)
A sense arbitration (if governance picks one as canonical)

Each is an auditable object. None is silent conflation.

Anchor A28: Sense Gluing

A28

A28: Sense Gluing

Fulfills: A6's deferred transport obligations.

Types:

A Sense is a structured object:

Sense = {
  id: SenseID,
  taxonomy_path: [Category...],
  definition: Text,
  provenance: Source
}

Sense assignment (referent-indexed):

\sigma_U : (\text{term}, \text{referent}) \to \text{Sense}

For term $t$ and referent $r$ in context $U$ , $\sigma_U(t, r)$ returns the sense under which $t$ applies to $r$ .

Restriction (agreement on shared referents):

Define two levels of overlap:

$O = \text{overlap}(U, V)$ : the set of shared entities (items, documents, records) between contexts
$O_t \subseteq O$ : the subset where both contexts have a witnessed assignment (or declared unknown) for term $t$ at referent $r$

A context "assigns a sense" to $(t, r)$ when it holds a witnessed label, not merely a classifier output. Unwitnessed guesses do not count; declared unknowns do.

Formally: $\sigma_U(t, r) \in \text{Sense} \cup \{\text{unknown}(\text{reason}, \text{evidence\_ref}?)\}$

Unknowns do not trigger obstruction, but do block gluing into GlobalSense. You can fork or coexist until resolved.

For gluing to succeed:

\forall r \in O_t: \sigma_U(t, r) = \sigma_V(t, r)

If this fails, gluing fails. The system produces a SenseObstruction with resolution options.

Transport (along context equivalence):

If $e : U \simeq V$ is a witnessed context equivalence with transport certificate per A16:

\text{transport}_e(\sigma_U) \text{ defines } \sigma_V

Transport is not automatic. It requires a certificate specifying what sense properties survive the move.

Explicit Fork (when restriction fails):

If $\sigma_U(t, r) \neq \sigma_V(t, r)$ for some $r \in O_t$ , the system may:

Maintain both senses with scope annotations
Record a ForkWitness explaining the divergence
Require downstream queries to specify scope: term@<scope> (e.g., pomegranate@textile)

Result Types:

SenseGluingResult =
    GlobalSense(term, sense, scope, witness)
  | SenseObstruction(term, overlap, sense_U, sense_V, resolution_options)
  | SenseFork(term, scoped_senses, fork_witness)
  | SenseArbitration(term, chosen_sense, authority, arbitration_witness)

Sense predicate (derived from assignment):

p_{\text{sense}}(\text{item}) \to \text{Bool}

A sense boundary becomes a predicate only when we choose a referent domain and an evaluation test (A24): items, documents, spans, or entities. The assignment $\sigma_U(t, r)$ is lexical; the predicate $p_{\text{sense}}$ is operational.

A28 instantiates A13 (sheaves) for sense assignments, and thereby for any predicates derived from them. The sheaf condition says: local data glues into global data when the pieces agree on overlaps. A28 says: local sense assignments glue into global senses when they agree on shared referents. If they disagree, the system produces a structured artifact explaining the failure and offering resolution paths.

The Pomegranate Resolution

Return to the running example. The word pomegranate has three senses:

Sense ID	Taxonomy Path	Definition
`fruit`	[food, produce, fruit]	The spherical, red-ariled fruit
`color`	[color, red, deep_red]	Deep red, between crimson and burgundy
`motif`	[decorative, motif, botanical]	Stylized pattern in Persian/Armenian textiles

Three contexts assign senses. (We expose scopes as user-facing names for contexts: grocery = $U_{\text{grocery}}$ , etc.) For any referent $r$ in each domain:

U_grocery: Grocery catalog. $\sigma_{\text{grocery}}(\text{"pomegranate"}, r) = \text{fruit}$ for $r$ in produce
U_paint: Paint catalog. $\sigma_{\text{paint}}(\text{"pomegranate"}, r) = \text{color}$ for $r$ in swatches
U_textile: Textile catalog. $\sigma_{\text{textile}}(\text{"pomegranate"}, r) = \text{motif}$ for $r$ in textiles

Case A: Disjoint Scopes

If the catalogs have no overlapping products:

overlap(U_grocery, U_paint) = ∅
overlap(U_grocery, U_textile) = ∅
overlap(U_paint, U_textile) = ∅

Gluing is not required. Each sense assignment stands in its scope. A query for "pomegranate" in the grocery context returns fruit; in the textile context, returns items with the motif. No conflict, no obstruction.

This is scoped coexistence: multiple senses of the same word, each valid in its domain.

Case B: Overlapping Scopes

A product appears in both U_grocery and U_textile:

"Pomegranate silk scarf with fruit pattern"

The scarf is sold in the gourmet food section as a gift item (U_grocery) and cataloged as a textile product (U_textile).

overlap(U_grocery, U_textile) = {SKU_12345}

σ_grocery("pomegranate", SKU_12345) = fruit
σ_textile("pomegranate", SKU_12345) = motif

The senses disagree on a shared referent. Gluing fails.

Example(Sense Obstruction)

SenseObstruction = {
  term: "pomegranate",
  failing_overlap: [SKU_12345],
  sense_U: fruit (U_grocery),
  sense_V: motif (U_textile),
  reason: "non-gluable without refinement",
  resolution_options: [reconcile, fork, arbitrate]
}

The obstruction is not a logical contradiction. The scarf can be a motif depicting the fruit. The obstruction means: the contexts disagree, and the system cannot silently pick one.

Resolution Options

Option 1: Reconcile. The description says "fruit pattern," suggesting the motif depicts the fruit. Create a reconciled sense:

GlobalSense = {
  term: "pomegranate",
  sense: {
    id: "fruit_motif",
    taxonomy_path: [decorative, motif, botanical, pomegranate],
    definition: "motif depicting the pomegranate fruit",
    provenance: reconciliation_from_obstruction
  },
  scope: U_grocery ∪ U_textile,
  witness: ReconciliationWitness(evidence: "fruit pattern" phrase)
}

Option 2: Fork. Maintain both senses with explicit scope:

SenseFork = {
  term: "pomegranate",
  scoped_senses: [
    { sense: fruit, scope: U_grocery, query_syntax: "pomegranate@grocery" },
    { sense: motif, scope: U_textile, query_syntax: "pomegranate@textile" }
  ],
  fork_witness: ForkWitness(reason: "legitimate polysemy")
}

Downstream queries must specify scope. A search for pomegranate@textile retrieves items with the motif; pomegranate@grocery retrieves fruit-related items.

Option 3: Arbitrate. A governance authority picks one sense as canonical:

SenseArbitration = {
  term: "pomegranate",
  chosen_sense: motif,
  authority: textile_taxonomy_team,
  arbitration_witness: {
    reason: "Product is primarily a textile; food-section placement is merchandising",
    override_scope: U_grocery
  }
}

Each option produces a witnessed artifact. Each is auditable. None conflates silently.

Case C: Transport Along Equivalence

Two textile catalogs merge: U_textile_A and U_textile_B. Both assign senses to the pomegranate motif, but with different terms:

U_textile_A: pomegranate → motif
U_textile_B: granada (Spanish) → motif

An equivalence witness exists. This is lexical synonymy within textile_domain: two terms that refer to the same sense. This is not entity identity (A10); it is a term-level equivalence scoped to a domain.

Equivalence(e) = {
  terms: [pomegranate, granada],
  kind: lexical_synonym,  // not entity_identity
  scope: textile_domain,
  witness: HistoricalLinguisticEvidence(etymology: "granada" is Spanish for pomegranate),
  certificate: { sense: yes, price: no }
}

Transport applies:

For any shared referent $r$ :

\text{transport}_e(\sigma_{\text{textile\_A}}(\text{"pomegranate"}, r)) = \sigma_{\text{textile\_B}}(\text{"granada"}, r)

In the merged context, "pomegranate" and "granada" refer to the same sense (the motif) with witnessed justification. The certificate specifies that sense transfers, but pricing information does not.

Morning Star and Evening Star

The canonical T2 example(Frege 1892): "morning star" and "evening star" both refer to Venus. Same astronomical object, different names inherited from the pre-telescopic era when observers did not realize the bright object at dawn was the same as the bright object at dusk.

The string empire places the terms at some embedding distance reflecting distributional properties, not astronomical fact. The schema empire stores them as separate records, unconnected unless a DBA manually creates an out-of-band equivalence table. The Third Mode resolves this with a scoped, witnessed equivalence:

Equivalence(e) = {
  entities: [morning_star, evening_star],
  kind: identity,
  scope: astronomical_context,
  witness: OrbitalData(ephemeris, IAU_designation),
  certificate: {
    orbital_properties: yes,
    poetic_substitution: no
  }
}

The equivalence is:

Scoped: Valid in astronomical context
Kinded: Identity (same physical object)
Witnessed: Orbital data and official designation
Partially transportable: You can substitute for orbital calculations, not for poetry

"O morning star, how bright thou art!" is not the same poem as "O evening star, how bright thou art!" The transport certificate says: sense (astronomical reference) transfers; poetic register does not.

This is T2 resolved: equivalence with explicit scope, kind, witness, and transport rules.

Sense as Predicate

A sense boundary is a nascent predicate. Drawing the boundary is the first step toward minting a certified predicate with A24 packaging.

Interlude I-A showed that the system needed a pomegranate_motif predicate but the schema did not have it. A6 said: sense boundaries exist. A28 says: sense boundaries can become predicates.

Sense Assignment to Predicate Package

From sense assignment (for any textile item $r$ ):

\sigma_{\text{textile}}(\text{"pomegranate"}, r) = \text{motif}

Derive predicate:

p_{\text{pomegranate\_motif}}(\text{item}) = \text{true iff item features the stylized pomegranate decorative pattern}

Package per A24:

PredicatePackage(pomegranate_motif) = {
  signature: Item → Bool,
  intension: "Item features the stylized pomegranate decorative pattern",
  domain: textile_artifacts,  // disjoint from edible_items
  tests: {
    positive: [SKU_A, SKU_B, SKU_C],
    negative: [SKU_D, SKU_E]
  },
  invariants: {
    functional_assignment: "For any (term, referent, context), σ assigns exactly one sense",
    typed_domain: "pomegranate_motif ranges over textile_artifacts; pomegranate_fruit ranges over edible_items"
  },
  provenance: { derived_from: sense_boundary_textile_catalog },
  scope: textile_domain
}

This is how T6 (predicate invention) connects to T2 (reference). The sense boundary becomes a predicate. The predicate has a package. The package has tests, invariants, and scope.

Pricing Sense Resolution

Sense resolution has costs. The choice between reconcile, fork, and arbitrate is an engineering decision with budget implications:

Resolution	Cost Profile
Reconcile	High upfront (human refinement to create merged sense), low ongoing
Fork	Low upfront, ongoing per-query burden (users must specify `term@scope`)
Arbitrate	Medium upfront (governance decision), risk of override regret
Global Glue	Scales with overlap size × update frequency

If reconciliation costs exceed budget, fork. If fork maintenance exceeds query tolerance, arbitrate. A21 prices these tradeoffs; A28 provides the operations.

Consequence

T2 is resolved. Disambiguation is gluing: local sense choices must agree on shared referents, or the disagreement must be explicitly recorded.

A6 named the object (sense boundary). Parts II and III built the machinery (witnessed equivalence, transport, sheaves). A28 specifies how senses glue: restriction on shared referents, transport along equivalences, explicit fork when agreement fails.

The pomegranate that split in Interlude I-A can now be handled properly. Fruit in one context, motif in another, color in a third. If scopes are disjoint, they coexist. If scopes overlap, the system detects the disagreement and offers resolution. If contexts merge, transport carries senses along witnessed equivalences.

No silent conflation. No unwitnessed identification. Pomegranates, properly.

Chapter 27 takes up T6 in full: the puffy dress and the new dimension. How does a predicate that does not exist come to exist, with tests, invariants, and scope?