Cue-Based Retrieval

@cite{lewis-vasishth-2005}

Content-addressable memory retrieval for sentence processing. Items in working memory are encoded with feature bundles and retrieved via parallel cue matching: the parser generates retrieval cues from grammatical constraints, and the item best matching those cues is accessed.

Cue Source Decomposition

Following @cite{bakay-etal-2026}, retrieval cues are classified by source:

• Structural cues derive from hierarchical relations in the evolving parse (c-command, clause-mateness, argument position). These are relational: they describe the configuration between the retrieval site and the candidate, not intrinsic properties of the candidate alone.

• Item-level cues target morphosyntactic features stored with the item (case marking, phi-features like number and gender).

• Positional cues reflect serial position, recency, and linear order.

The central empirical question is whether structural cues contribute to retrieval independently of item-level and positional cues.

Two Accounts

Two classes of model predict a structural advantage — that c-commanding antecedents are retrieved over non-c-commanding distractors even when item-level cues don't distinguish them:

1. Weighted activation (@cite{lewis-vasishth-2005}; @cite{kush-2013}): Activation is a weighted sum of cue matches. Structural cues can be weighted more heavily, or structural features (like Kush's LOCAL:1/0) can be dynamically maintained to approximate c-command.

2. Privileged access (@cite{mcelree-2006}; @cite{oberauer-2002}): Structurally prominent items occupy a "region of direct access" and bypass cue-based search entirely.

The models diverge on interference: the weighted model predicts graded interference from feature-matching distractors, while the privileged- access model predicts little early interference from non-prominent items. @cite{bakay-etal-2026} find limited, inconsistent evidence for number- based interference, leaving this distinction open.

inductive Processing.CueBasedRetrieval.CueSource : Type

Source of a retrieval cue.

@cite{bakay-etal-2026}'s core empirical contribution is decomposing the structural cues that prior studies confounded with clause-level and case-marking cues (their Figure 1 Venn diagram), and showing that structural cues guide retrieval independently.

• structural : CueSource

  Hierarchical relations: c-command, clause-mate, argument role

• itemLevel : CueSource

  Morphosyntactic features of the item: case, number, gender

• positional : CueSource

  Serial order: recency, linear precedence

instance Processing.CueBasedRetrieval.instDecidableEqCueSource : DecidableEq CueSource

Equations

• Processing.CueBasedRetrieval.instDecidableEqCueSource x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

instance Processing.CueBasedRetrieval.instBEqCueSource : BEq CueSource

Equations

• Processing.CueBasedRetrieval.instBEqCueSource = { beq := Processing.CueBasedRetrieval.instBEqCueSource.beq }

def Processing.CueBasedRetrieval.instBEqCueSource.beq : CueSource → CueSource → Bool

Equations

• Processing.CueBasedRetrieval.instBEqCueSource.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

instance Processing.CueBasedRetrieval.instReprCueSource : Repr CueSource

Equations

• Processing.CueBasedRetrieval.instReprCueSource = { reprPrec := Processing.CueBasedRetrieval.instReprCueSource.repr }

def Processing.CueBasedRetrieval.instReprCueSource.repr : CueSource → Nat → Std.Format

Equations

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

structure Processing.CueBasedRetrieval.Cue (F : Type) : Type

A retrieval cue: a feature value tagged with its source.

When a dependency is encountered (e.g., a reciprocal anaphor), the grammar generates a bundle of retrieval cues specifying the required antecedent. For example, processing Turkish birbirleri generates:

• structural: +c-commanding, +clause-mate
• item-level: +plural
• positional: (none — no recency preference)

• source : CueSource
• feature : F

def Processing.CueBasedRetrieval.instReprCue.repr {F✝ : Type} [Repr F✝] : Cue F✝ → Nat → Std.Format

Equations

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

instance Processing.CueBasedRetrieval.instReprCue {F✝ : Type} [Repr F✝] : Repr (Cue F✝)

Equations

• Processing.CueBasedRetrieval.instReprCue = { reprPrec := Processing.CueBasedRetrieval.instReprCue.repr }

structure Processing.CueBasedRetrieval.Item (F : Type) : Type

An item in working memory, stored with a feature bundle.

Features encode both intrinsic properties (case, number, category) and dynamically assigned structural properties (c-commands-anaphor, clause-mate-of-anaphor). The structural features are computed from the evolving parse and dynamically updated at clause boundaries (@cite{kush-2013}: LOCAL:1 items reset to LOCAL:0).

• label : String
• features : List F

def Processing.CueBasedRetrieval.instReprItem.repr {F✝ : Type} [Repr F✝] : Item F✝ → Nat → Std.Format

Equations

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

instance Processing.CueBasedRetrieval.instReprItem {F✝ : Type} [Repr F✝] : Repr (Item F✝)

Equations

• Processing.CueBasedRetrieval.instReprItem = { reprPrec := Processing.CueBasedRetrieval.instReprItem.repr }

def Processing.CueBasedRetrieval.Item.hasFeature {F : Type} [BEq F] (item : Item F) (f : F) : Bool

Does an item's feature bundle contain a given feature?

Equations

• item.hasFeature f = item.features.any fun (x : F) => x == f

def Processing.CueBasedRetrieval.Item.matchesCue {F : Type} [BEq F] (item : Item F) (c : Cue F) : Bool

Does an item match a given cue? Match is based on the feature value only; the cue source is metadata for the retrieval model, not a matching criterion.

Equations

• item.matchesCue c = item.hasFeature c.feature

def Processing.CueBasedRetrieval.matchCount {F : Type} [BEq F] (item : Item F) (cues : List (Cue F)) (s : CueSource) : Nat

Count of cue matches from a specific source type.

Equations

• Processing.CueBasedRetrieval.matchCount item cues s = (List.filter (fun (c : Processing.CueBasedRetrieval.Cue F) => c.source == s && item.matchesCue c) cues).length

def Processing.CueBasedRetrieval.totalMatchCount {F : Type} [BEq F] (item : Item F) (cues : List (Cue F)) : Nat

Total cue matches across all source types.

Equations

• Processing.CueBasedRetrieval.totalMatchCount item cues = (List.filter (fun (x : Processing.CueBasedRetrieval.Cue F) => item.matchesCue x) cues).length

def Processing.CueBasedRetrieval.fan {F : Type} [BEq F] (cue : Cue F) (items : List (Item F)) : Nat

Fan: number of items matching a particular cue. Higher fan reduces the associative boost each item receives from that cue, leading to similarity-based interference (@cite{van-dyke-mcelree-2011}).

Equations

• Processing.CueBasedRetrieval.fan cue items = (List.filter (fun (x : Processing.CueBasedRetrieval.Item F) => x.matchesCue cue) items).length

def Processing.CueBasedRetrieval.isDistractor {F : Type} [BEq F] (item : Item F) (cues : List (Cue F)) : Bool

An item is a distractor for a retrieval scenario if it matches some but not all cues — a partial cue match that competes with the target.

Equations

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

structure Processing.CueBasedRetrieval.Scenario (F : Type) : Type

A retrieval scenario: a probe triggers retrieval with a set of cues, and multiple items in memory compete for access.

• probe : String

  Description of what triggered retrieval (e.g., "reciprocal anaphor")

• cues : List (Cue F)

  Cues generated by the grammar at the retrieval site

• items : List (Item F)

  Items currently in working memory

instance Processing.CueBasedRetrieval.instReprScenario {F✝ : Type} [Repr F✝] : Repr (Scenario F✝)

Equations

• Processing.CueBasedRetrieval.instReprScenario = { reprPrec := Processing.CueBasedRetrieval.instReprScenario.repr }

def Processing.CueBasedRetrieval.instReprScenario.repr {F✝ : Type} [Repr F✝] : Scenario F✝ → Nat → Std.Format

Equations

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

def Processing.CueBasedRetrieval.Scenario.interferenceCount {F : Type} [BEq F] (s : Scenario F) : Nat

Number of interfering items (partial cue matches) in a scenario. Maps to ProcessingModel.ProcessingProfile.referentialLoad.

Equations

• s.interferenceCount = (List.filter (fun (x : Processing.CueBasedRetrieval.Item F) => Processing.CueBasedRetrieval.isDistractor x s.cues) s.items).length

Weighted Activation

@cite{lewis-vasishth-2005}: activation = Σ (weight × match). Items with higher activation are retrieved faster and more accurately. The weights determine the relative importance of different cue sources.

The key prediction: when structural cues are weighted positively, items matching more structural cues are retrieved, independent of item-level overlap between target and distractor.

def Processing.CueBasedRetrieval.weightedActivation {F : Type} [BEq F] (ws wi wp : Nat) (item : Item F) (cues : List (Cue F)) : Nat

Weighted activation: total score is a weighted sum of match counts by source type. Weights are natural numbers; only their relative magnitude matters for ordering predictions.

Equations

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

theorem Processing.CueBasedRetrieval.structural_advantage {F : Type} [BEq F] (ws wi wp : Nat) (h_ws : 0 < ws) (target distractor : Item F) (cues : List (Cue F)) (h_struct : matchCount distractor cues CueSource.structural < matchCount target cues CueSource.structural) (h_item : matchCount target cues CueSource.itemLevel = matchCount distractor cues CueSource.itemLevel) (h_pos : matchCount target cues CueSource.positional = matchCount distractor cues CueSource.positional) : weightedActivation ws wi wp distractor cues < weightedActivation ws wi wp target cues

Structural Advantage Theorem (weighted activation model).

If the target matches strictly more structural cues than the distractor, they tie on item-level and positional cues, and the structural weight is positive, then the target has strictly higher activation.

This is the qualitative prediction tested by @cite{bakay-etal-2026} Experiments 1–3: c-commanding antecedents are retrieved over non-c-commanding distractors even when clause, case, and number are controlled.

The proof reduces to monotonicity of multiplication over ℕ.

theorem Processing.CueBasedRetrieval.recency_advantage {F : Type} [BEq F] (ws wi wp : Nat) (h_wp : 0 < wp) (recent distant : Item F) (cues : List (Cue F)) (h_struct : matchCount recent cues CueSource.structural = matchCount distant cues CueSource.structural) (h_item : matchCount recent cues CueSource.itemLevel = matchCount distant cues CueSource.itemLevel) (h_pos : matchCount distant cues CueSource.positional < matchCount recent cues CueSource.positional) : weightedActivation ws wi wp distant cues < weightedActivation ws wi wp recent cues

Recency Advantage: when only positional cues differ (more recent = more positional matches), a more recent item has higher activation, all else equal.

@cite{bakay-etal-2026} Experiment 1 finds that the recency advantage is additive with the structural advantage: linearly recent targets receive even more looks.

Privileged Access

@cite{mcelree-2006}; @cite{oberauer-2002}: structurally prominent items (those c-commanding the retrieval site) occupy a "region of direct access" in working memory. They are retrieved without search, yielding an immediate structural advantage independent of cue matching.

This model predicts less interference from feature-matching distractors than the weighted model, because non-prominent items don't compete directly — they require slower, search-based retrieval.

def Processing.CueBasedRetrieval.isPrivileged {F : Type} [BEq F] (item : Item F) (cues : List (Cue F)) : Bool

An item is privileged (in the region of direct access) if it matches all structural cues. Under the privileged-access model, such items are retrieved without search.

Equations

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

theorem Processing.CueBasedRetrieval.privileged_structural_advantage {F : Type} [BEq F] (target distractor : Item F) (cues : List (Cue F)) (h_target : isPrivileged target cues = true) (h_distractor : isPrivileged distractor cues = false) : isPrivileged target cues ≠ isPrivileged distractor cues

Under privileged access, if the target is privileged and the distractor is not, the target is accessed directly regardless of the distractor's item-level cue match quality.

This captures the key prediction shared with the weighted model (structural advantage), while remaining agnostic about interference from non-privileged distractors.

Bridge to ProcessingModel

A retrieval scenario can be projected to a ProcessingProfile for comparison across conditions. The mapping:

Retrieval property	ProcessingProfile dimension
Number of distractors	referentialLoad
Distance to target	locality
Clause boundaries crossed	boundaries
Structural cue match quality	ease

This bridge connects cue-based retrieval predictions to the Pareto- dominance comparison framework in Core.ProcessingModel.

def Processing.CueBasedRetrieval.toProcessingProfile {F : Type} [BEq F] (scenario : Scenario F) (target : Item F) (distance clauseBoundaries : Nat) : ProcessingModel.ProcessingProfile

Project a retrieval scenario onto a processing profile. Requires explicit target identification and distance information.

Equations

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